diff options
Diffstat (limited to 'capstone/arch/X86/X86GenInstrInfo.inc')
| -rw-r--r-- | capstone/arch/X86/X86GenInstrInfo.inc | 15158 |
1 files changed, 15158 insertions, 0 deletions
diff --git a/capstone/arch/X86/X86GenInstrInfo.inc b/capstone/arch/X86/X86GenInstrInfo.inc new file mode 100644 index 000000000..16a51b77e --- /dev/null +++ b/capstone/arch/X86/X86GenInstrInfo.inc @@ -0,0 +1,15158 @@ + +/* Capstone Disassembly Engine, http://www.capstone-engine.org */ +/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */ + +/*===- TableGen'erated file -------------------------------------*- C++ -*-===*|* *| +|* Target Instruction Enum Values and Descriptors *| +|* *| +|* Automatically generated file, do not edit! *| +|* *| +\*===----------------------------------------------------------------------===*/ + +#ifdef GET_INSTRINFO_ENUM +#undef GET_INSTRINFO_ENUM + +enum { + X86_AAA = 146, + X86_AAD8i8 = 147, + X86_AAM8i8 = 148, + X86_AAS = 149, + X86_ABS_F = 150, + X86_ABS_Fp32 = 151, + X86_ABS_Fp64 = 152, + X86_ABS_Fp80 = 153, + X86_ADC16i16 = 154, + X86_ADC16mi = 155, + X86_ADC16mi8 = 156, + X86_ADC16mr = 157, + X86_ADC16ri = 158, + X86_ADC16ri8 = 159, + X86_ADC16rm = 160, + X86_ADC16rr = 161, + X86_ADC16rr_REV = 162, + X86_ADC32i32 = 163, + X86_ADC32mi = 164, + X86_ADC32mi8 = 165, + X86_ADC32mr = 166, + X86_ADC32ri = 167, + X86_ADC32ri8 = 168, + X86_ADC32rm = 169, + X86_ADC32rr = 170, + X86_ADC32rr_REV = 171, + X86_ADC64i32 = 172, + X86_ADC64mi32 = 173, + X86_ADC64mi8 = 174, + X86_ADC64mr = 175, + X86_ADC64ri32 = 176, + X86_ADC64ri8 = 177, + X86_ADC64rm = 178, + X86_ADC64rr = 179, + X86_ADC64rr_REV = 180, + X86_ADC8i8 = 181, + X86_ADC8mi = 182, + X86_ADC8mi8 = 183, + X86_ADC8mr = 184, + X86_ADC8ri = 185, + X86_ADC8ri8 = 186, + X86_ADC8rm = 187, + X86_ADC8rr = 188, + X86_ADC8rr_REV = 189, + X86_ADCX32rm = 190, + X86_ADCX32rr = 191, + X86_ADCX64rm = 192, + X86_ADCX64rr = 193, + X86_ADD16i16 = 194, + X86_ADD16mi = 195, + X86_ADD16mi8 = 196, + X86_ADD16mr = 197, + X86_ADD16ri = 198, + X86_ADD16ri8 = 199, + X86_ADD16rm = 200, + X86_ADD16rr = 201, + X86_ADD16rr_REV = 202, + X86_ADD32i32 = 203, + X86_ADD32mi = 204, + X86_ADD32mi8 = 205, + X86_ADD32mr = 206, + X86_ADD32ri = 207, + X86_ADD32ri8 = 208, + X86_ADD32rm = 209, + X86_ADD32rr = 210, + X86_ADD32rr_REV = 211, + X86_ADD64i32 = 212, + X86_ADD64mi32 = 213, + X86_ADD64mi8 = 214, + X86_ADD64mr = 215, + X86_ADD64ri32 = 216, + X86_ADD64ri8 = 217, + X86_ADD64rm = 218, + X86_ADD64rr = 219, + X86_ADD64rr_REV = 220, + X86_ADD8i8 = 221, + X86_ADD8mi = 222, + X86_ADD8mi8 = 223, + X86_ADD8mr = 224, + X86_ADD8ri = 225, + X86_ADD8ri8 = 226, + X86_ADD8rm = 227, + X86_ADD8rr = 228, + X86_ADD8rr_REV = 229, + X86_ADDPDrm = 230, + X86_ADDPDrr = 231, + X86_ADDPSrm = 232, + X86_ADDPSrr = 233, + X86_ADDSDrm = 234, + X86_ADDSDrm_Int = 235, + X86_ADDSDrr = 236, + X86_ADDSDrr_Int = 237, + X86_ADDSSrm = 238, + X86_ADDSSrm_Int = 239, + X86_ADDSSrr = 240, + X86_ADDSSrr_Int = 241, + X86_ADDSUBPDrm = 242, + X86_ADDSUBPDrr = 243, + X86_ADDSUBPSrm = 244, + X86_ADDSUBPSrr = 245, + X86_ADD_F32m = 246, + X86_ADD_F64m = 247, + X86_ADD_FI16m = 248, + X86_ADD_FI32m = 249, + X86_ADD_FPrST0 = 250, + X86_ADD_FST0r = 251, + X86_ADD_Fp32 = 252, + X86_ADD_Fp32m = 253, + X86_ADD_Fp64 = 254, + X86_ADD_Fp64m = 255, + X86_ADD_Fp64m32 = 256, + X86_ADD_Fp80 = 257, + X86_ADD_Fp80m32 = 258, + X86_ADD_Fp80m64 = 259, + X86_ADD_FpI16m32 = 260, + X86_ADD_FpI16m64 = 261, + X86_ADD_FpI16m80 = 262, + X86_ADD_FpI32m32 = 263, + X86_ADD_FpI32m64 = 264, + X86_ADD_FpI32m80 = 265, + X86_ADD_FrST0 = 266, + X86_ADOX32rm = 267, + X86_ADOX32rr = 268, + X86_ADOX64rm = 269, + X86_ADOX64rr = 270, + X86_AESDECLASTrm = 271, + X86_AESDECLASTrr = 272, + X86_AESDECrm = 273, + X86_AESDECrr = 274, + X86_AESENCLASTrm = 275, + X86_AESENCLASTrr = 276, + X86_AESENCrm = 277, + X86_AESENCrr = 278, + X86_AESIMCrm = 279, + X86_AESIMCrr = 280, + X86_AESKEYGENASSIST128rm = 281, + X86_AESKEYGENASSIST128rr = 282, + X86_AND16i16 = 283, + X86_AND16mi = 284, + X86_AND16mi8 = 285, + X86_AND16mr = 286, + X86_AND16ri = 287, + X86_AND16ri8 = 288, + X86_AND16rm = 289, + X86_AND16rr = 290, + X86_AND16rr_REV = 291, + X86_AND32i32 = 292, + X86_AND32mi = 293, + X86_AND32mi8 = 294, + X86_AND32mr = 295, + X86_AND32ri = 296, + X86_AND32ri8 = 297, + X86_AND32rm = 298, + X86_AND32rr = 299, + X86_AND32rr_REV = 300, + X86_AND64i32 = 301, + X86_AND64mi32 = 302, + X86_AND64mi8 = 303, + X86_AND64mr = 304, + X86_AND64ri32 = 305, + X86_AND64ri8 = 306, + X86_AND64rm = 307, + X86_AND64rr = 308, + X86_AND64rr_REV = 309, + X86_AND8i8 = 310, + X86_AND8mi = 311, + X86_AND8mi8 = 312, + X86_AND8mr = 313, + X86_AND8ri = 314, + X86_AND8ri8 = 315, + X86_AND8rm = 316, + X86_AND8rr = 317, + X86_AND8rr_REV = 318, + X86_ANDN32rm = 319, + X86_ANDN32rr = 320, + X86_ANDN64rm = 321, + X86_ANDN64rr = 322, + X86_ANDNPDrm = 323, + X86_ANDNPDrr = 324, + X86_ANDNPSrm = 325, + X86_ANDNPSrr = 326, + X86_ANDPDrm = 327, + X86_ANDPDrr = 328, + X86_ANDPSrm = 329, + X86_ANDPSrr = 330, + X86_ARPL16mr = 331, + X86_ARPL16rr = 332, + X86_BEXTR32rm = 333, + X86_BEXTR32rr = 334, + X86_BEXTR64rm = 335, + X86_BEXTR64rr = 336, + X86_BEXTRI32mi = 337, + X86_BEXTRI32ri = 338, + X86_BEXTRI64mi = 339, + X86_BEXTRI64ri = 340, + X86_BLCFILL32rm = 341, + X86_BLCFILL32rr = 342, + X86_BLCFILL64rm = 343, + X86_BLCFILL64rr = 344, + X86_BLCI32rm = 345, + X86_BLCI32rr = 346, + X86_BLCI64rm = 347, + X86_BLCI64rr = 348, + X86_BLCIC32rm = 349, + X86_BLCIC32rr = 350, + X86_BLCIC64rm = 351, + X86_BLCIC64rr = 352, + X86_BLCMSK32rm = 353, + X86_BLCMSK32rr = 354, + X86_BLCMSK64rm = 355, + X86_BLCMSK64rr = 356, + X86_BLCS32rm = 357, + X86_BLCS32rr = 358, + X86_BLCS64rm = 359, + X86_BLCS64rr = 360, + X86_BLENDPDrmi = 361, + X86_BLENDPDrri = 362, + X86_BLENDPSrmi = 363, + X86_BLENDPSrri = 364, + X86_BLENDVPDrm0 = 365, + X86_BLENDVPDrr0 = 366, + X86_BLENDVPSrm0 = 367, + X86_BLENDVPSrr0 = 368, + X86_BLSFILL32rm = 369, + X86_BLSFILL32rr = 370, + X86_BLSFILL64rm = 371, + X86_BLSFILL64rr = 372, + X86_BLSI32rm = 373, + X86_BLSI32rr = 374, + X86_BLSI64rm = 375, + X86_BLSI64rr = 376, + X86_BLSIC32rm = 377, + X86_BLSIC32rr = 378, + X86_BLSIC64rm = 379, + X86_BLSIC64rr = 380, + X86_BLSMSK32rm = 381, + X86_BLSMSK32rr = 382, + X86_BLSMSK64rm = 383, + X86_BLSMSK64rr = 384, + X86_BLSR32rm = 385, + X86_BLSR32rr = 386, + X86_BLSR64rm = 387, + X86_BLSR64rr = 388, + X86_BNDCL32rm = 389, + X86_BNDCL32rr = 390, + X86_BNDCL64rm = 391, + X86_BNDCL64rr = 392, + X86_BNDCN32rm = 393, + X86_BNDCN32rr = 394, + X86_BNDCN64rm = 395, + X86_BNDCN64rr = 396, + X86_BNDCU32rm = 397, + X86_BNDCU32rr = 398, + X86_BNDCU64rm = 399, + X86_BNDCU64rr = 400, + X86_BNDLDXrm = 401, + X86_BNDMK32rm = 402, + X86_BNDMK64rm = 403, + X86_BNDMOV32mr = 404, + X86_BNDMOV32rm = 405, + X86_BNDMOV64mr = 406, + X86_BNDMOV64rm = 407, + X86_BNDMOVrr = 408, + X86_BNDMOVrr_REV = 409, + X86_BNDSTXmr = 410, + X86_BOUNDS16rm = 411, + X86_BOUNDS32rm = 412, + X86_BSF16rm = 413, + X86_BSF16rr = 414, + X86_BSF32rm = 415, + X86_BSF32rr = 416, + X86_BSF64rm = 417, + X86_BSF64rr = 418, + X86_BSR16rm = 419, + X86_BSR16rr = 420, + X86_BSR32rm = 421, + X86_BSR32rr = 422, + X86_BSR64rm = 423, + X86_BSR64rr = 424, + X86_BSWAP16r_BAD = 425, + X86_BSWAP32r = 426, + X86_BSWAP64r = 427, + X86_BT16mi8 = 428, + X86_BT16mr = 429, + X86_BT16ri8 = 430, + X86_BT16rr = 431, + X86_BT32mi8 = 432, + X86_BT32mr = 433, + X86_BT32ri8 = 434, + X86_BT32rr = 435, + X86_BT64mi8 = 436, + X86_BT64mr = 437, + X86_BT64ri8 = 438, + X86_BT64rr = 439, + X86_BTC16mi8 = 440, + X86_BTC16mr = 441, + X86_BTC16ri8 = 442, + X86_BTC16rr = 443, + X86_BTC32mi8 = 444, + X86_BTC32mr = 445, + X86_BTC32ri8 = 446, + X86_BTC32rr = 447, + X86_BTC64mi8 = 448, + X86_BTC64mr = 449, + X86_BTC64ri8 = 450, + X86_BTC64rr = 451, + X86_BTR16mi8 = 452, + X86_BTR16mr = 453, + X86_BTR16ri8 = 454, + X86_BTR16rr = 455, + X86_BTR32mi8 = 456, + X86_BTR32mr = 457, + X86_BTR32ri8 = 458, + X86_BTR32rr = 459, + X86_BTR64mi8 = 460, + X86_BTR64mr = 461, + X86_BTR64ri8 = 462, + X86_BTR64rr = 463, + X86_BTS16mi8 = 464, + X86_BTS16mr = 465, + X86_BTS16ri8 = 466, + X86_BTS16rr = 467, + X86_BTS32mi8 = 468, + X86_BTS32mr = 469, + X86_BTS32ri8 = 470, + X86_BTS32rr = 471, + X86_BTS64mi8 = 472, + X86_BTS64mr = 473, + X86_BTS64ri8 = 474, + X86_BTS64rr = 475, + X86_BZHI32rm = 476, + X86_BZHI32rr = 477, + X86_BZHI64rm = 478, + X86_BZHI64rr = 479, + X86_CALL16m = 480, + X86_CALL16m_NT = 481, + X86_CALL16r = 482, + X86_CALL16r_NT = 483, + X86_CALL32m = 484, + X86_CALL32m_NT = 485, + X86_CALL32r = 486, + X86_CALL32r_NT = 487, + X86_CALL64m = 488, + X86_CALL64m_NT = 489, + X86_CALL64pcrel32 = 490, + X86_CALL64r = 491, + X86_CALL64r_NT = 492, + X86_CALLpcrel16 = 493, + X86_CALLpcrel32 = 494, + X86_CBW = 495, + X86_CDQ = 496, + X86_CDQE = 497, + X86_CHS_F = 498, + X86_CHS_Fp32 = 499, + X86_CHS_Fp64 = 500, + X86_CHS_Fp80 = 501, + X86_CLAC = 502, + X86_CLC = 503, + X86_CLD = 504, + X86_CLDEMOTE = 505, + X86_CLFLUSH = 506, + X86_CLFLUSHOPT = 507, + X86_CLGI = 508, + X86_CLI = 509, + X86_CLRSSBSY = 510, + X86_CLTS = 511, + X86_CLWB = 512, + X86_CLZEROr = 513, + X86_CMC = 514, + X86_CMOVA16rm = 515, + X86_CMOVA16rr = 516, + X86_CMOVA32rm = 517, + X86_CMOVA32rr = 518, + X86_CMOVA64rm = 519, + X86_CMOVA64rr = 520, + X86_CMOVAE16rm = 521, + X86_CMOVAE16rr = 522, + X86_CMOVAE32rm = 523, + X86_CMOVAE32rr = 524, + X86_CMOVAE64rm = 525, + X86_CMOVAE64rr = 526, + X86_CMOVB16rm = 527, + X86_CMOVB16rr = 528, + X86_CMOVB32rm = 529, + X86_CMOVB32rr = 530, + X86_CMOVB64rm = 531, + X86_CMOVB64rr = 532, + X86_CMOVBE16rm = 533, + X86_CMOVBE16rr = 534, + X86_CMOVBE32rm = 535, + X86_CMOVBE32rr = 536, + X86_CMOVBE64rm = 537, + X86_CMOVBE64rr = 538, + X86_CMOVBE_F = 539, + X86_CMOVBE_Fp32 = 540, + X86_CMOVBE_Fp64 = 541, + X86_CMOVBE_Fp80 = 542, + X86_CMOVB_F = 543, + X86_CMOVB_Fp32 = 544, + X86_CMOVB_Fp64 = 545, + X86_CMOVB_Fp80 = 546, + X86_CMOVE16rm = 547, + X86_CMOVE16rr = 548, + X86_CMOVE32rm = 549, + X86_CMOVE32rr = 550, + X86_CMOVE64rm = 551, + X86_CMOVE64rr = 552, + X86_CMOVE_F = 553, + X86_CMOVE_Fp32 = 554, + X86_CMOVE_Fp64 = 555, + X86_CMOVE_Fp80 = 556, + X86_CMOVG16rm = 557, + X86_CMOVG16rr = 558, + X86_CMOVG32rm = 559, + X86_CMOVG32rr = 560, + X86_CMOVG64rm = 561, + X86_CMOVG64rr = 562, + X86_CMOVGE16rm = 563, + X86_CMOVGE16rr = 564, + X86_CMOVGE32rm = 565, + X86_CMOVGE32rr = 566, + X86_CMOVGE64rm = 567, + X86_CMOVGE64rr = 568, + X86_CMOVL16rm = 569, + X86_CMOVL16rr = 570, + X86_CMOVL32rm = 571, + X86_CMOVL32rr = 572, + X86_CMOVL64rm = 573, + X86_CMOVL64rr = 574, + X86_CMOVLE16rm = 575, + X86_CMOVLE16rr = 576, + X86_CMOVLE32rm = 577, + X86_CMOVLE32rr = 578, + X86_CMOVLE64rm = 579, + X86_CMOVLE64rr = 580, + X86_CMOVNBE_F = 581, + X86_CMOVNBE_Fp32 = 582, + X86_CMOVNBE_Fp64 = 583, + X86_CMOVNBE_Fp80 = 584, + X86_CMOVNB_F = 585, + X86_CMOVNB_Fp32 = 586, + X86_CMOVNB_Fp64 = 587, + X86_CMOVNB_Fp80 = 588, + X86_CMOVNE16rm = 589, + X86_CMOVNE16rr = 590, + X86_CMOVNE32rm = 591, + X86_CMOVNE32rr = 592, + X86_CMOVNE64rm = 593, + X86_CMOVNE64rr = 594, + X86_CMOVNE_F = 595, + X86_CMOVNE_Fp32 = 596, + X86_CMOVNE_Fp64 = 597, + X86_CMOVNE_Fp80 = 598, + X86_CMOVNO16rm = 599, + X86_CMOVNO16rr = 600, + X86_CMOVNO32rm = 601, + X86_CMOVNO32rr = 602, + X86_CMOVNO64rm = 603, + X86_CMOVNO64rr = 604, + X86_CMOVNP16rm = 605, + X86_CMOVNP16rr = 606, + X86_CMOVNP32rm = 607, + X86_CMOVNP32rr = 608, + X86_CMOVNP64rm = 609, + X86_CMOVNP64rr = 610, + X86_CMOVNP_F = 611, + X86_CMOVNP_Fp32 = 612, + X86_CMOVNP_Fp64 = 613, + X86_CMOVNP_Fp80 = 614, + X86_CMOVNS16rm = 615, + X86_CMOVNS16rr = 616, + X86_CMOVNS32rm = 617, + X86_CMOVNS32rr = 618, + X86_CMOVNS64rm = 619, + X86_CMOVNS64rr = 620, + X86_CMOVO16rm = 621, + X86_CMOVO16rr = 622, + X86_CMOVO32rm = 623, + X86_CMOVO32rr = 624, + X86_CMOVO64rm = 625, + X86_CMOVO64rr = 626, + X86_CMOVP16rm = 627, + X86_CMOVP16rr = 628, + X86_CMOVP32rm = 629, + X86_CMOVP32rr = 630, + X86_CMOVP64rm = 631, + X86_CMOVP64rr = 632, + X86_CMOVP_F = 633, + X86_CMOVP_Fp32 = 634, + X86_CMOVP_Fp64 = 635, + X86_CMOVP_Fp80 = 636, + X86_CMOVS16rm = 637, + X86_CMOVS16rr = 638, + X86_CMOVS32rm = 639, + X86_CMOVS32rr = 640, + X86_CMOVS64rm = 641, + X86_CMOVS64rr = 642, + X86_CMP16i16 = 643, + X86_CMP16mi = 644, + X86_CMP16mi8 = 645, + X86_CMP16mr = 646, + X86_CMP16ri = 647, + X86_CMP16ri8 = 648, + X86_CMP16rm = 649, + X86_CMP16rr = 650, + X86_CMP16rr_REV = 651, + X86_CMP32i32 = 652, + X86_CMP32mi = 653, + X86_CMP32mi8 = 654, + X86_CMP32mr = 655, + X86_CMP32ri = 656, + X86_CMP32ri8 = 657, + X86_CMP32rm = 658, + X86_CMP32rr = 659, + X86_CMP32rr_REV = 660, + X86_CMP64i32 = 661, + X86_CMP64mi32 = 662, + X86_CMP64mi8 = 663, + X86_CMP64mr = 664, + X86_CMP64ri32 = 665, + X86_CMP64ri8 = 666, + X86_CMP64rm = 667, + X86_CMP64rr = 668, + X86_CMP64rr_REV = 669, + X86_CMP8i8 = 670, + X86_CMP8mi = 671, + X86_CMP8mi8 = 672, + X86_CMP8mr = 673, + X86_CMP8ri = 674, + X86_CMP8ri8 = 675, + X86_CMP8rm = 676, + X86_CMP8rr = 677, + X86_CMP8rr_REV = 678, + X86_CMPPDrmi = 679, + X86_CMPPDrmi_alt = 680, + X86_CMPPDrri = 681, + X86_CMPPDrri_alt = 682, + X86_CMPPSrmi = 683, + X86_CMPPSrmi_alt = 684, + X86_CMPPSrri = 685, + X86_CMPPSrri_alt = 686, + X86_CMPSB = 687, + X86_CMPSDrm = 688, + X86_CMPSDrm_Int = 689, + X86_CMPSDrm_alt = 690, + X86_CMPSDrr = 691, + X86_CMPSDrr_Int = 692, + X86_CMPSDrr_alt = 693, + X86_CMPSL = 694, + X86_CMPSQ = 695, + X86_CMPSSrm = 696, + X86_CMPSSrm_Int = 697, + X86_CMPSSrm_alt = 698, + X86_CMPSSrr = 699, + X86_CMPSSrr_Int = 700, + X86_CMPSSrr_alt = 701, + X86_CMPSW = 702, + X86_CMPXCHG16B = 703, + X86_CMPXCHG16rm = 704, + X86_CMPXCHG16rr = 705, + X86_CMPXCHG32rm = 706, + X86_CMPXCHG32rr = 707, + X86_CMPXCHG64rm = 708, + X86_CMPXCHG64rr = 709, + X86_CMPXCHG8B = 710, + X86_CMPXCHG8rm = 711, + X86_CMPXCHG8rr = 712, + X86_COMISDrm = 713, + X86_COMISDrm_Int = 714, + X86_COMISDrr = 715, + X86_COMISDrr_Int = 716, + X86_COMISSrm = 717, + X86_COMISSrm_Int = 718, + X86_COMISSrr = 719, + X86_COMISSrr_Int = 720, + X86_COMP_FST0r = 721, + X86_COM_FIPr = 722, + X86_COM_FIr = 723, + X86_COM_FST0r = 724, + X86_COS_F = 725, + X86_COS_Fp32 = 726, + X86_COS_Fp64 = 727, + X86_COS_Fp80 = 728, + X86_CPUID = 729, + X86_CQO = 730, + X86_CRC32r32m16 = 731, + X86_CRC32r32m32 = 732, + X86_CRC32r32m8 = 733, + X86_CRC32r32r16 = 734, + X86_CRC32r32r32 = 735, + X86_CRC32r32r8 = 736, + X86_CRC32r64m64 = 737, + X86_CRC32r64m8 = 738, + X86_CRC32r64r64 = 739, + X86_CRC32r64r8 = 740, + X86_CVTDQ2PDrm = 741, + X86_CVTDQ2PDrr = 742, + X86_CVTDQ2PSrm = 743, + X86_CVTDQ2PSrr = 744, + X86_CVTPD2DQrm = 745, + X86_CVTPD2DQrr = 746, + X86_CVTPD2PSrm = 747, + X86_CVTPD2PSrr = 748, + X86_CVTPS2DQrm = 749, + X86_CVTPS2DQrr = 750, + X86_CVTPS2PDrm = 751, + X86_CVTPS2PDrr = 752, + X86_CVTSD2SI64rm_Int = 753, + X86_CVTSD2SI64rr_Int = 754, + X86_CVTSD2SIrm_Int = 755, + X86_CVTSD2SIrr_Int = 756, + X86_CVTSD2SSrm = 757, + X86_CVTSD2SSrm_Int = 758, + X86_CVTSD2SSrr = 759, + X86_CVTSD2SSrr_Int = 760, + X86_CVTSI2SDrm = 761, + X86_CVTSI2SDrm_Int = 762, + X86_CVTSI2SDrr = 763, + X86_CVTSI2SDrr_Int = 764, + X86_CVTSI2SSrm = 765, + X86_CVTSI2SSrm_Int = 766, + X86_CVTSI2SSrr = 767, + X86_CVTSI2SSrr_Int = 768, + X86_CVTSI642SDrm = 769, + X86_CVTSI642SDrm_Int = 770, + X86_CVTSI642SDrr = 771, + X86_CVTSI642SDrr_Int = 772, + X86_CVTSI642SSrm = 773, + X86_CVTSI642SSrm_Int = 774, + X86_CVTSI642SSrr = 775, + X86_CVTSI642SSrr_Int = 776, + X86_CVTSS2SDrm = 777, + X86_CVTSS2SDrm_Int = 778, + X86_CVTSS2SDrr = 779, + X86_CVTSS2SDrr_Int = 780, + X86_CVTSS2SI64rm_Int = 781, + X86_CVTSS2SI64rr_Int = 782, + X86_CVTSS2SIrm_Int = 783, + X86_CVTSS2SIrr_Int = 784, + X86_CVTTPD2DQrm = 785, + X86_CVTTPD2DQrr = 786, + X86_CVTTPS2DQrm = 787, + X86_CVTTPS2DQrr = 788, + X86_CVTTSD2SI64rm = 789, + X86_CVTTSD2SI64rm_Int = 790, + X86_CVTTSD2SI64rr = 791, + X86_CVTTSD2SI64rr_Int = 792, + X86_CVTTSD2SIrm = 793, + X86_CVTTSD2SIrm_Int = 794, + X86_CVTTSD2SIrr = 795, + X86_CVTTSD2SIrr_Int = 796, + X86_CVTTSS2SI64rm = 797, + X86_CVTTSS2SI64rm_Int = 798, + X86_CVTTSS2SI64rr = 799, + X86_CVTTSS2SI64rr_Int = 800, + X86_CVTTSS2SIrm = 801, + X86_CVTTSS2SIrm_Int = 802, + X86_CVTTSS2SIrr = 803, + X86_CVTTSS2SIrr_Int = 804, + X86_CWD = 805, + X86_CWDE = 806, + X86_DAA = 807, + X86_DAS = 808, + X86_DATA16_PREFIX = 809, + X86_DEC16m = 810, + X86_DEC16r = 811, + X86_DEC16r_alt = 812, + X86_DEC32m = 813, + X86_DEC32r = 814, + X86_DEC32r_alt = 815, + X86_DEC64m = 816, + X86_DEC64r = 817, + X86_DEC8m = 818, + X86_DEC8r = 819, + X86_DIV16m = 820, + X86_DIV16r = 821, + X86_DIV32m = 822, + X86_DIV32r = 823, + X86_DIV64m = 824, + X86_DIV64r = 825, + X86_DIV8m = 826, + X86_DIV8r = 827, + X86_DIVPDrm = 828, + X86_DIVPDrr = 829, + X86_DIVPSrm = 830, + X86_DIVPSrr = 831, + X86_DIVR_F32m = 832, + X86_DIVR_F64m = 833, + X86_DIVR_FI16m = 834, + X86_DIVR_FI32m = 835, + X86_DIVR_FPrST0 = 836, + X86_DIVR_FST0r = 837, + X86_DIVR_Fp32m = 838, + X86_DIVR_Fp64m = 839, + X86_DIVR_Fp64m32 = 840, + X86_DIVR_Fp80m32 = 841, + X86_DIVR_Fp80m64 = 842, + X86_DIVR_FpI16m32 = 843, + X86_DIVR_FpI16m64 = 844, + X86_DIVR_FpI16m80 = 845, + X86_DIVR_FpI32m32 = 846, + X86_DIVR_FpI32m64 = 847, + X86_DIVR_FpI32m80 = 848, + X86_DIVR_FrST0 = 849, + X86_DIVSDrm = 850, + X86_DIVSDrm_Int = 851, + X86_DIVSDrr = 852, + X86_DIVSDrr_Int = 853, + X86_DIVSSrm = 854, + X86_DIVSSrm_Int = 855, + X86_DIVSSrr = 856, + X86_DIVSSrr_Int = 857, + X86_DIV_F32m = 858, + X86_DIV_F64m = 859, + X86_DIV_FI16m = 860, + X86_DIV_FI32m = 861, + X86_DIV_FPrST0 = 862, + X86_DIV_FST0r = 863, + X86_DIV_Fp32 = 864, + X86_DIV_Fp32m = 865, + X86_DIV_Fp64 = 866, + X86_DIV_Fp64m = 867, + X86_DIV_Fp64m32 = 868, + X86_DIV_Fp80 = 869, + X86_DIV_Fp80m32 = 870, + X86_DIV_Fp80m64 = 871, + X86_DIV_FpI16m32 = 872, + X86_DIV_FpI16m64 = 873, + X86_DIV_FpI16m80 = 874, + X86_DIV_FpI32m32 = 875, + X86_DIV_FpI32m64 = 876, + X86_DIV_FpI32m80 = 877, + X86_DIV_FrST0 = 878, + X86_DPPDrmi = 879, + X86_DPPDrri = 880, + X86_DPPSrmi = 881, + X86_DPPSrri = 882, + X86_ENCLS = 883, + X86_ENCLU = 884, + X86_ENCLV = 885, + X86_ENDBR32 = 886, + X86_ENDBR64 = 887, + X86_ENTER = 888, + X86_EXTRACTPSmr = 889, + X86_EXTRACTPSrr = 890, + X86_EXTRQ = 891, + X86_EXTRQI = 892, + X86_F2XM1 = 893, + X86_FARCALL16i = 894, + X86_FARCALL16m = 895, + X86_FARCALL32i = 896, + X86_FARCALL32m = 897, + X86_FARCALL64 = 898, + X86_FARJMP16i = 899, + X86_FARJMP16m = 900, + X86_FARJMP32i = 901, + X86_FARJMP32m = 902, + X86_FARJMP64 = 903, + X86_FBLDm = 904, + X86_FBSTPm = 905, + X86_FCOM32m = 906, + X86_FCOM64m = 907, + X86_FCOMP32m = 908, + X86_FCOMP64m = 909, + X86_FCOMPP = 910, + X86_FDECSTP = 911, + X86_FDISI8087_NOP = 912, + X86_FEMMS = 913, + X86_FENI8087_NOP = 914, + X86_FFREE = 915, + X86_FFREEP = 916, + X86_FICOM16m = 917, + X86_FICOM32m = 918, + X86_FICOMP16m = 919, + X86_FICOMP32m = 920, + X86_FINCSTP = 921, + X86_FLDCW16m = 922, + X86_FLDENVm = 923, + X86_FLDL2E = 924, + X86_FLDL2T = 925, + X86_FLDLG2 = 926, + X86_FLDLN2 = 927, + X86_FLDPI = 928, + X86_FNCLEX = 929, + X86_FNINIT = 930, + X86_FNOP = 931, + X86_FNSTCW16m = 932, + X86_FNSTSW16r = 933, + X86_FNSTSWm = 934, + X86_FPATAN = 935, + X86_FPNCEST0r = 936, + X86_FPREM = 937, + X86_FPREM1 = 938, + X86_FPTAN = 939, + X86_FRNDINT = 940, + X86_FRSTORm = 941, + X86_FSAVEm = 942, + X86_FSCALE = 943, + X86_FSETPM = 944, + X86_FSINCOS = 945, + X86_FSTENVm = 946, + X86_FXAM = 947, + X86_FXRSTOR = 948, + X86_FXRSTOR64 = 949, + X86_FXSAVE = 950, + X86_FXSAVE64 = 951, + X86_FXTRACT = 952, + X86_FYL2X = 953, + X86_FYL2XP1 = 954, + X86_GETSEC = 955, + X86_GF2P8AFFINEINVQBrmi = 956, + X86_GF2P8AFFINEINVQBrri = 957, + X86_GF2P8AFFINEQBrmi = 958, + X86_GF2P8AFFINEQBrri = 959, + X86_GF2P8MULBrm = 960, + X86_GF2P8MULBrr = 961, + X86_HADDPDrm = 962, + X86_HADDPDrr = 963, + X86_HADDPSrm = 964, + X86_HADDPSrr = 965, + X86_HLT = 966, + X86_HSUBPDrm = 967, + X86_HSUBPDrr = 968, + X86_HSUBPSrm = 969, + X86_HSUBPSrr = 970, + X86_IDIV16m = 971, + X86_IDIV16r = 972, + X86_IDIV32m = 973, + X86_IDIV32r = 974, + X86_IDIV64m = 975, + X86_IDIV64r = 976, + X86_IDIV8m = 977, + X86_IDIV8r = 978, + X86_ILD_F16m = 979, + X86_ILD_F32m = 980, + X86_ILD_F64m = 981, + X86_ILD_Fp16m32 = 982, + X86_ILD_Fp16m64 = 983, + X86_ILD_Fp16m80 = 984, + X86_ILD_Fp32m32 = 985, + X86_ILD_Fp32m64 = 986, + X86_ILD_Fp32m80 = 987, + X86_ILD_Fp64m32 = 988, + X86_ILD_Fp64m64 = 989, + X86_ILD_Fp64m80 = 990, + X86_IMUL16m = 991, + X86_IMUL16r = 992, + X86_IMUL16rm = 993, + X86_IMUL16rmi = 994, + X86_IMUL16rmi8 = 995, + X86_IMUL16rr = 996, + X86_IMUL16rri = 997, + X86_IMUL16rri8 = 998, + X86_IMUL32m = 999, + X86_IMUL32r = 1000, + X86_IMUL32rm = 1001, + X86_IMUL32rmi = 1002, + X86_IMUL32rmi8 = 1003, + X86_IMUL32rr = 1004, + X86_IMUL32rri = 1005, + X86_IMUL32rri8 = 1006, + X86_IMUL64m = 1007, + X86_IMUL64r = 1008, + X86_IMUL64rm = 1009, + X86_IMUL64rmi32 = 1010, + X86_IMUL64rmi8 = 1011, + X86_IMUL64rr = 1012, + X86_IMUL64rri32 = 1013, + X86_IMUL64rri8 = 1014, + X86_IMUL8m = 1015, + X86_IMUL8r = 1016, + X86_IN16ri = 1017, + X86_IN16rr = 1018, + X86_IN32ri = 1019, + X86_IN32rr = 1020, + X86_IN8ri = 1021, + X86_IN8rr = 1022, + X86_INC16m = 1023, + X86_INC16r = 1024, + X86_INC16r_alt = 1025, + X86_INC32m = 1026, + X86_INC32r = 1027, + X86_INC32r_alt = 1028, + X86_INC64m = 1029, + X86_INC64r = 1030, + X86_INC8m = 1031, + X86_INC8r = 1032, + X86_INCSSPD = 1033, + X86_INCSSPQ = 1034, + X86_INSB = 1035, + X86_INSERTPSrm = 1036, + X86_INSERTPSrr = 1037, + X86_INSERTQ = 1038, + X86_INSERTQI = 1039, + X86_INSL = 1040, + X86_INSW = 1041, + X86_INT = 1042, + X86_INT1 = 1043, + X86_INT3 = 1044, + X86_INTO = 1045, + X86_INVD = 1046, + X86_INVEPT32 = 1047, + X86_INVEPT64 = 1048, + X86_INVLPG = 1049, + X86_INVLPGA32 = 1050, + X86_INVLPGA64 = 1051, + X86_INVPCID32 = 1052, + X86_INVPCID64 = 1053, + X86_INVVPID32 = 1054, + X86_INVVPID64 = 1055, + X86_IRET16 = 1056, + X86_IRET32 = 1057, + X86_IRET64 = 1058, + X86_ISTT_FP16m = 1059, + X86_ISTT_FP32m = 1060, + X86_ISTT_FP64m = 1061, + X86_ISTT_Fp16m32 = 1062, + X86_ISTT_Fp16m64 = 1063, + X86_ISTT_Fp16m80 = 1064, + X86_ISTT_Fp32m32 = 1065, + X86_ISTT_Fp32m64 = 1066, + X86_ISTT_Fp32m80 = 1067, + X86_ISTT_Fp64m32 = 1068, + X86_ISTT_Fp64m64 = 1069, + X86_ISTT_Fp64m80 = 1070, + X86_IST_F16m = 1071, + X86_IST_F32m = 1072, + X86_IST_FP16m = 1073, + X86_IST_FP32m = 1074, + X86_IST_FP64m = 1075, + X86_IST_Fp16m32 = 1076, + X86_IST_Fp16m64 = 1077, + X86_IST_Fp16m80 = 1078, + X86_IST_Fp32m32 = 1079, + X86_IST_Fp32m64 = 1080, + X86_IST_Fp32m80 = 1081, + X86_IST_Fp64m32 = 1082, + X86_IST_Fp64m64 = 1083, + X86_IST_Fp64m80 = 1084, + X86_JAE_1 = 1085, + X86_JAE_2 = 1086, + X86_JAE_4 = 1087, + X86_JA_1 = 1088, + X86_JA_2 = 1089, + X86_JA_4 = 1090, + X86_JBE_1 = 1091, + X86_JBE_2 = 1092, + X86_JBE_4 = 1093, + X86_JB_1 = 1094, + X86_JB_2 = 1095, + X86_JB_4 = 1096, + X86_JCXZ = 1097, + X86_JECXZ = 1098, + X86_JE_1 = 1099, + X86_JE_2 = 1100, + X86_JE_4 = 1101, + X86_JGE_1 = 1102, + X86_JGE_2 = 1103, + X86_JGE_4 = 1104, + X86_JG_1 = 1105, + X86_JG_2 = 1106, + X86_JG_4 = 1107, + X86_JLE_1 = 1108, + X86_JLE_2 = 1109, + X86_JLE_4 = 1110, + X86_JL_1 = 1111, + X86_JL_2 = 1112, + X86_JL_4 = 1113, + X86_JMP16m = 1114, + X86_JMP16m_NT = 1115, + X86_JMP16r = 1116, + X86_JMP16r_NT = 1117, + X86_JMP32m = 1118, + X86_JMP32m_NT = 1119, + X86_JMP32r = 1120, + X86_JMP32r_NT = 1121, + X86_JMP64m = 1122, + X86_JMP64m_NT = 1123, + X86_JMP64r = 1124, + X86_JMP64r_NT = 1125, + X86_JMP_1 = 1126, + X86_JMP_2 = 1127, + X86_JMP_4 = 1128, + X86_JNE_1 = 1129, + X86_JNE_2 = 1130, + X86_JNE_4 = 1131, + X86_JNO_1 = 1132, + X86_JNO_2 = 1133, + X86_JNO_4 = 1134, + X86_JNP_1 = 1135, + X86_JNP_2 = 1136, + X86_JNP_4 = 1137, + X86_JNS_1 = 1138, + X86_JNS_2 = 1139, + X86_JNS_4 = 1140, + X86_JO_1 = 1141, + X86_JO_2 = 1142, + X86_JO_4 = 1143, + X86_JP_1 = 1144, + X86_JP_2 = 1145, + X86_JP_4 = 1146, + X86_JRCXZ = 1147, + X86_JS_1 = 1148, + X86_JS_2 = 1149, + X86_JS_4 = 1150, + X86_KADDBrr = 1151, + X86_KADDDrr = 1152, + X86_KADDQrr = 1153, + X86_KADDWrr = 1154, + X86_KANDBrr = 1155, + X86_KANDDrr = 1156, + X86_KANDNBrr = 1157, + X86_KANDNDrr = 1158, + X86_KANDNQrr = 1159, + X86_KANDNWrr = 1160, + X86_KANDQrr = 1161, + X86_KANDWrr = 1162, + X86_KMOVBkk = 1163, + X86_KMOVBkm = 1164, + X86_KMOVBkr = 1165, + X86_KMOVBmk = 1166, + X86_KMOVBrk = 1167, + X86_KMOVDkk = 1168, + X86_KMOVDkm = 1169, + X86_KMOVDkr = 1170, + X86_KMOVDmk = 1171, + X86_KMOVDrk = 1172, + X86_KMOVQkk = 1173, + X86_KMOVQkm = 1174, + X86_KMOVQkr = 1175, + X86_KMOVQmk = 1176, + X86_KMOVQrk = 1177, + X86_KMOVWkk = 1178, + X86_KMOVWkm = 1179, + X86_KMOVWkr = 1180, + X86_KMOVWmk = 1181, + X86_KMOVWrk = 1182, + X86_KNOTBrr = 1183, + X86_KNOTDrr = 1184, + X86_KNOTQrr = 1185, + X86_KNOTWrr = 1186, + X86_KORBrr = 1187, + X86_KORDrr = 1188, + X86_KORQrr = 1189, + X86_KORTESTBrr = 1190, + X86_KORTESTDrr = 1191, + X86_KORTESTQrr = 1192, + X86_KORTESTWrr = 1193, + X86_KORWrr = 1194, + X86_KSHIFTLBri = 1195, + X86_KSHIFTLDri = 1196, + X86_KSHIFTLQri = 1197, + X86_KSHIFTLWri = 1198, + X86_KSHIFTRBri = 1199, + X86_KSHIFTRDri = 1200, + X86_KSHIFTRQri = 1201, + X86_KSHIFTRWri = 1202, + X86_KTESTBrr = 1203, + X86_KTESTDrr = 1204, + X86_KTESTQrr = 1205, + X86_KTESTWrr = 1206, + X86_KUNPCKBWrr = 1207, + X86_KUNPCKDQrr = 1208, + X86_KUNPCKWDrr = 1209, + X86_KXNORBrr = 1210, + X86_KXNORDrr = 1211, + X86_KXNORQrr = 1212, + X86_KXNORWrr = 1213, + X86_KXORBrr = 1214, + X86_KXORDrr = 1215, + X86_KXORQrr = 1216, + X86_KXORWrr = 1217, + X86_LAHF = 1218, + X86_LAR16rm = 1219, + X86_LAR16rr = 1220, + X86_LAR32rm = 1221, + X86_LAR32rr = 1222, + X86_LAR64rm = 1223, + X86_LAR64rr = 1224, + X86_LDDQUrm = 1225, + X86_LDMXCSR = 1226, + X86_LDS16rm = 1227, + X86_LDS32rm = 1228, + X86_LD_F0 = 1229, + X86_LD_F1 = 1230, + X86_LD_F32m = 1231, + X86_LD_F64m = 1232, + X86_LD_F80m = 1233, + X86_LD_Fp032 = 1234, + X86_LD_Fp064 = 1235, + X86_LD_Fp080 = 1236, + X86_LD_Fp132 = 1237, + X86_LD_Fp164 = 1238, + X86_LD_Fp180 = 1239, + X86_LD_Fp32m = 1240, + X86_LD_Fp32m64 = 1241, + X86_LD_Fp32m80 = 1242, + X86_LD_Fp64m = 1243, + X86_LD_Fp64m80 = 1244, + X86_LD_Fp80m = 1245, + X86_LD_Frr = 1246, + X86_LEA16r = 1247, + X86_LEA32r = 1248, + X86_LEA64_32r = 1249, + X86_LEA64r = 1250, + X86_LEAVE = 1251, + X86_LEAVE64 = 1252, + X86_LES16rm = 1253, + X86_LES32rm = 1254, + X86_LFENCE = 1255, + X86_LFS16rm = 1256, + X86_LFS32rm = 1257, + X86_LFS64rm = 1258, + X86_LGDT16m = 1259, + X86_LGDT32m = 1260, + X86_LGDT64m = 1261, + X86_LGS16rm = 1262, + X86_LGS32rm = 1263, + X86_LGS64rm = 1264, + X86_LIDT16m = 1265, + X86_LIDT32m = 1266, + X86_LIDT64m = 1267, + X86_LLDT16m = 1268, + X86_LLDT16r = 1269, + X86_LLWPCB = 1270, + X86_LLWPCB64 = 1271, + X86_LMSW16m = 1272, + X86_LMSW16r = 1273, + X86_LOCK_PREFIX = 1274, + X86_LODSB = 1275, + X86_LODSL = 1276, + X86_LODSQ = 1277, + X86_LODSW = 1278, + X86_LOOP = 1279, + X86_LOOPE = 1280, + X86_LOOPNE = 1281, + X86_LRETIL = 1282, + X86_LRETIQ = 1283, + X86_LRETIW = 1284, + X86_LRETL = 1285, + X86_LRETQ = 1286, + X86_LRETW = 1287, + X86_LSL16rm = 1288, + X86_LSL16rr = 1289, + X86_LSL32rm = 1290, + X86_LSL32rr = 1291, + X86_LSL64rm = 1292, + X86_LSL64rr = 1293, + X86_LSS16rm = 1294, + X86_LSS32rm = 1295, + X86_LSS64rm = 1296, + X86_LTRm = 1297, + X86_LTRr = 1298, + X86_LWPINS32rmi = 1299, + X86_LWPINS32rri = 1300, + X86_LWPINS64rmi = 1301, + X86_LWPINS64rri = 1302, + X86_LWPVAL32rmi = 1303, + X86_LWPVAL32rri = 1304, + X86_LWPVAL64rmi = 1305, + X86_LWPVAL64rri = 1306, + X86_LZCNT16rm = 1307, + X86_LZCNT16rr = 1308, + X86_LZCNT32rm = 1309, + X86_LZCNT32rr = 1310, + X86_LZCNT64rm = 1311, + X86_LZCNT64rr = 1312, + X86_MASKMOVDQU = 1313, + X86_MASKMOVDQU64 = 1314, + X86_MAXCPDrm = 1315, + X86_MAXCPDrr = 1316, + X86_MAXCPSrm = 1317, + X86_MAXCPSrr = 1318, + X86_MAXCSDrm = 1319, + X86_MAXCSDrr = 1320, + X86_MAXCSSrm = 1321, + X86_MAXCSSrr = 1322, + X86_MAXPDrm = 1323, + X86_MAXPDrr = 1324, + X86_MAXPSrm = 1325, + X86_MAXPSrr = 1326, + X86_MAXSDrm = 1327, + X86_MAXSDrm_Int = 1328, + X86_MAXSDrr = 1329, + X86_MAXSDrr_Int = 1330, + X86_MAXSSrm = 1331, + X86_MAXSSrm_Int = 1332, + X86_MAXSSrr = 1333, + X86_MAXSSrr_Int = 1334, + X86_MFENCE = 1335, + X86_MINCPDrm = 1336, + X86_MINCPDrr = 1337, + X86_MINCPSrm = 1338, + X86_MINCPSrr = 1339, + X86_MINCSDrm = 1340, + X86_MINCSDrr = 1341, + X86_MINCSSrm = 1342, + X86_MINCSSrr = 1343, + X86_MINPDrm = 1344, + X86_MINPDrr = 1345, + X86_MINPSrm = 1346, + X86_MINPSrr = 1347, + X86_MINSDrm = 1348, + X86_MINSDrm_Int = 1349, + X86_MINSDrr = 1350, + X86_MINSDrr_Int = 1351, + X86_MINSSrm = 1352, + X86_MINSSrm_Int = 1353, + X86_MINSSrr = 1354, + X86_MINSSrr_Int = 1355, + X86_MMX_CVTPD2PIirm = 1356, + X86_MMX_CVTPD2PIirr = 1357, + X86_MMX_CVTPI2PDirm = 1358, + X86_MMX_CVTPI2PDirr = 1359, + X86_MMX_CVTPI2PSirm = 1360, + X86_MMX_CVTPI2PSirr = 1361, + X86_MMX_CVTPS2PIirm = 1362, + X86_MMX_CVTPS2PIirr = 1363, + X86_MMX_CVTTPD2PIirm = 1364, + X86_MMX_CVTTPD2PIirr = 1365, + X86_MMX_CVTTPS2PIirm = 1366, + X86_MMX_CVTTPS2PIirr = 1367, + X86_MMX_EMMS = 1368, + X86_MMX_MASKMOVQ = 1369, + X86_MMX_MASKMOVQ64 = 1370, + X86_MMX_MOVD64from64rm = 1371, + X86_MMX_MOVD64from64rr = 1372, + X86_MMX_MOVD64grr = 1373, + X86_MMX_MOVD64mr = 1374, + X86_MMX_MOVD64rm = 1375, + X86_MMX_MOVD64rr = 1376, + X86_MMX_MOVD64to64rm = 1377, + X86_MMX_MOVD64to64rr = 1378, + X86_MMX_MOVDQ2Qrr = 1379, + X86_MMX_MOVFR642Qrr = 1380, + X86_MMX_MOVNTQmr = 1381, + X86_MMX_MOVQ2DQrr = 1382, + X86_MMX_MOVQ2FR64rr = 1383, + X86_MMX_MOVQ64mr = 1384, + X86_MMX_MOVQ64rm = 1385, + X86_MMX_MOVQ64rr = 1386, + X86_MMX_MOVQ64rr_REV = 1387, + X86_MMX_PABSBrm = 1388, + X86_MMX_PABSBrr = 1389, + X86_MMX_PABSDrm = 1390, + X86_MMX_PABSDrr = 1391, + X86_MMX_PABSWrm = 1392, + X86_MMX_PABSWrr = 1393, + X86_MMX_PACKSSDWirm = 1394, + X86_MMX_PACKSSDWirr = 1395, + X86_MMX_PACKSSWBirm = 1396, + X86_MMX_PACKSSWBirr = 1397, + X86_MMX_PACKUSWBirm = 1398, + X86_MMX_PACKUSWBirr = 1399, + X86_MMX_PADDBirm = 1400, + X86_MMX_PADDBirr = 1401, + X86_MMX_PADDDirm = 1402, + X86_MMX_PADDDirr = 1403, + X86_MMX_PADDQirm = 1404, + X86_MMX_PADDQirr = 1405, + X86_MMX_PADDSBirm = 1406, + X86_MMX_PADDSBirr = 1407, + X86_MMX_PADDSWirm = 1408, + X86_MMX_PADDSWirr = 1409, + X86_MMX_PADDUSBirm = 1410, + X86_MMX_PADDUSBirr = 1411, + X86_MMX_PADDUSWirm = 1412, + X86_MMX_PADDUSWirr = 1413, + X86_MMX_PADDWirm = 1414, + X86_MMX_PADDWirr = 1415, + X86_MMX_PALIGNRrmi = 1416, + X86_MMX_PALIGNRrri = 1417, + X86_MMX_PANDNirm = 1418, + X86_MMX_PANDNirr = 1419, + X86_MMX_PANDirm = 1420, + X86_MMX_PANDirr = 1421, + X86_MMX_PAVGBirm = 1422, + X86_MMX_PAVGBirr = 1423, + X86_MMX_PAVGWirm = 1424, + X86_MMX_PAVGWirr = 1425, + X86_MMX_PCMPEQBirm = 1426, + X86_MMX_PCMPEQBirr = 1427, + X86_MMX_PCMPEQDirm = 1428, + X86_MMX_PCMPEQDirr = 1429, + X86_MMX_PCMPEQWirm = 1430, + X86_MMX_PCMPEQWirr = 1431, + X86_MMX_PCMPGTBirm = 1432, + X86_MMX_PCMPGTBirr = 1433, + X86_MMX_PCMPGTDirm = 1434, + X86_MMX_PCMPGTDirr = 1435, + X86_MMX_PCMPGTWirm = 1436, + X86_MMX_PCMPGTWirr = 1437, + X86_MMX_PEXTRWrr = 1438, + X86_MMX_PHADDDrm = 1439, + X86_MMX_PHADDDrr = 1440, + X86_MMX_PHADDSWrm = 1441, + X86_MMX_PHADDSWrr = 1442, + X86_MMX_PHADDWrm = 1443, + X86_MMX_PHADDWrr = 1444, + X86_MMX_PHSUBDrm = 1445, + X86_MMX_PHSUBDrr = 1446, + X86_MMX_PHSUBSWrm = 1447, + X86_MMX_PHSUBSWrr = 1448, + X86_MMX_PHSUBWrm = 1449, + X86_MMX_PHSUBWrr = 1450, + X86_MMX_PINSRWrm = 1451, + X86_MMX_PINSRWrr = 1452, + X86_MMX_PMADDUBSWrm = 1453, + X86_MMX_PMADDUBSWrr = 1454, + X86_MMX_PMADDWDirm = 1455, + X86_MMX_PMADDWDirr = 1456, + X86_MMX_PMAXSWirm = 1457, + X86_MMX_PMAXSWirr = 1458, + X86_MMX_PMAXUBirm = 1459, + X86_MMX_PMAXUBirr = 1460, + X86_MMX_PMINSWirm = 1461, + X86_MMX_PMINSWirr = 1462, + X86_MMX_PMINUBirm = 1463, + X86_MMX_PMINUBirr = 1464, + X86_MMX_PMOVMSKBrr = 1465, + X86_MMX_PMULHRSWrm = 1466, + X86_MMX_PMULHRSWrr = 1467, + X86_MMX_PMULHUWirm = 1468, + X86_MMX_PMULHUWirr = 1469, + X86_MMX_PMULHWirm = 1470, + X86_MMX_PMULHWirr = 1471, + X86_MMX_PMULLWirm = 1472, + X86_MMX_PMULLWirr = 1473, + X86_MMX_PMULUDQirm = 1474, + X86_MMX_PMULUDQirr = 1475, + X86_MMX_PORirm = 1476, + X86_MMX_PORirr = 1477, + X86_MMX_PSADBWirm = 1478, + X86_MMX_PSADBWirr = 1479, + X86_MMX_PSHUFBrm = 1480, + X86_MMX_PSHUFBrr = 1481, + X86_MMX_PSHUFWmi = 1482, + X86_MMX_PSHUFWri = 1483, + X86_MMX_PSIGNBrm = 1484, + X86_MMX_PSIGNBrr = 1485, + X86_MMX_PSIGNDrm = 1486, + X86_MMX_PSIGNDrr = 1487, + X86_MMX_PSIGNWrm = 1488, + X86_MMX_PSIGNWrr = 1489, + X86_MMX_PSLLDri = 1490, + X86_MMX_PSLLDrm = 1491, + X86_MMX_PSLLDrr = 1492, + X86_MMX_PSLLQri = 1493, + X86_MMX_PSLLQrm = 1494, + X86_MMX_PSLLQrr = 1495, + X86_MMX_PSLLWri = 1496, + X86_MMX_PSLLWrm = 1497, + X86_MMX_PSLLWrr = 1498, + X86_MMX_PSRADri = 1499, + X86_MMX_PSRADrm = 1500, + X86_MMX_PSRADrr = 1501, + X86_MMX_PSRAWri = 1502, + X86_MMX_PSRAWrm = 1503, + X86_MMX_PSRAWrr = 1504, + X86_MMX_PSRLDri = 1505, + X86_MMX_PSRLDrm = 1506, + X86_MMX_PSRLDrr = 1507, + X86_MMX_PSRLQri = 1508, + X86_MMX_PSRLQrm = 1509, + X86_MMX_PSRLQrr = 1510, + X86_MMX_PSRLWri = 1511, + X86_MMX_PSRLWrm = 1512, + X86_MMX_PSRLWrr = 1513, + X86_MMX_PSUBBirm = 1514, + X86_MMX_PSUBBirr = 1515, + X86_MMX_PSUBDirm = 1516, + X86_MMX_PSUBDirr = 1517, + X86_MMX_PSUBQirm = 1518, + X86_MMX_PSUBQirr = 1519, + X86_MMX_PSUBSBirm = 1520, + X86_MMX_PSUBSBirr = 1521, + X86_MMX_PSUBSWirm = 1522, + X86_MMX_PSUBSWirr = 1523, + X86_MMX_PSUBUSBirm = 1524, + X86_MMX_PSUBUSBirr = 1525, + X86_MMX_PSUBUSWirm = 1526, + X86_MMX_PSUBUSWirr = 1527, + X86_MMX_PSUBWirm = 1528, + X86_MMX_PSUBWirr = 1529, + X86_MMX_PUNPCKHBWirm = 1530, + X86_MMX_PUNPCKHBWirr = 1531, + X86_MMX_PUNPCKHDQirm = 1532, + X86_MMX_PUNPCKHDQirr = 1533, + X86_MMX_PUNPCKHWDirm = 1534, + X86_MMX_PUNPCKHWDirr = 1535, + X86_MMX_PUNPCKLBWirm = 1536, + X86_MMX_PUNPCKLBWirr = 1537, + X86_MMX_PUNPCKLDQirm = 1538, + X86_MMX_PUNPCKLDQirr = 1539, + X86_MMX_PUNPCKLWDirm = 1540, + X86_MMX_PUNPCKLWDirr = 1541, + X86_MMX_PXORirm = 1542, + X86_MMX_PXORirr = 1543, + X86_MONITORXrrr = 1544, + X86_MONITORrrr = 1545, + X86_MONTMUL = 1546, + X86_MOV16ao16 = 1547, + X86_MOV16ao32 = 1548, + X86_MOV16ao64 = 1549, + X86_MOV16mi = 1550, + X86_MOV16mr = 1551, + X86_MOV16ms = 1552, + X86_MOV16o16a = 1553, + X86_MOV16o32a = 1554, + X86_MOV16o64a = 1555, + X86_MOV16ri = 1556, + X86_MOV16ri_alt = 1557, + X86_MOV16rm = 1558, + X86_MOV16rr = 1559, + X86_MOV16rr_REV = 1560, + X86_MOV16rs = 1561, + X86_MOV16sm = 1562, + X86_MOV16sr = 1563, + X86_MOV32ao16 = 1564, + X86_MOV32ao32 = 1565, + X86_MOV32ao64 = 1566, + X86_MOV32cr = 1567, + X86_MOV32dr = 1568, + X86_MOV32mi = 1569, + X86_MOV32mr = 1570, + X86_MOV32o16a = 1571, + X86_MOV32o32a = 1572, + X86_MOV32o64a = 1573, + X86_MOV32rc = 1574, + X86_MOV32rd = 1575, + X86_MOV32ri = 1576, + X86_MOV32ri_alt = 1577, + X86_MOV32rm = 1578, + X86_MOV32rr = 1579, + X86_MOV32rr_REV = 1580, + X86_MOV32rs = 1581, + X86_MOV32sr = 1582, + X86_MOV64ao32 = 1583, + X86_MOV64ao64 = 1584, + X86_MOV64cr = 1585, + X86_MOV64dr = 1586, + X86_MOV64mi32 = 1587, + X86_MOV64mr = 1588, + X86_MOV64o32a = 1589, + X86_MOV64o64a = 1590, + X86_MOV64rc = 1591, + X86_MOV64rd = 1592, + X86_MOV64ri = 1593, + X86_MOV64ri32 = 1594, + X86_MOV64rm = 1595, + X86_MOV64rr = 1596, + X86_MOV64rr_REV = 1597, + X86_MOV64rs = 1598, + X86_MOV64sr = 1599, + X86_MOV64toPQIrm = 1600, + X86_MOV64toPQIrr = 1601, + X86_MOV64toSDrm = 1602, + X86_MOV64toSDrr = 1603, + X86_MOV8ao16 = 1604, + X86_MOV8ao32 = 1605, + X86_MOV8ao64 = 1606, + X86_MOV8mi = 1607, + X86_MOV8mr = 1608, + X86_MOV8mr_NOREX = 1609, + X86_MOV8o16a = 1610, + X86_MOV8o32a = 1611, + X86_MOV8o64a = 1612, + X86_MOV8ri = 1613, + X86_MOV8ri_alt = 1614, + X86_MOV8rm = 1615, + X86_MOV8rm_NOREX = 1616, + X86_MOV8rr = 1617, + X86_MOV8rr_NOREX = 1618, + X86_MOV8rr_REV = 1619, + X86_MOVAPDmr = 1620, + X86_MOVAPDrm = 1621, + X86_MOVAPDrr = 1622, + X86_MOVAPDrr_REV = 1623, + X86_MOVAPSmr = 1624, + X86_MOVAPSrm = 1625, + X86_MOVAPSrr = 1626, + X86_MOVAPSrr_REV = 1627, + X86_MOVBE16mr = 1628, + X86_MOVBE16rm = 1629, + X86_MOVBE32mr = 1630, + X86_MOVBE32rm = 1631, + X86_MOVBE64mr = 1632, + X86_MOVBE64rm = 1633, + X86_MOVDDUPrm = 1634, + X86_MOVDDUPrr = 1635, + X86_MOVDI2PDIrm = 1636, + X86_MOVDI2PDIrr = 1637, + X86_MOVDI2SSrm = 1638, + X86_MOVDI2SSrr = 1639, + X86_MOVDIR64B16 = 1640, + X86_MOVDIR64B32 = 1641, + X86_MOVDIR64B64 = 1642, + X86_MOVDIRI32 = 1643, + X86_MOVDIRI64 = 1644, + X86_MOVDQAmr = 1645, + X86_MOVDQArm = 1646, + X86_MOVDQArr = 1647, + X86_MOVDQArr_REV = 1648, + X86_MOVDQUmr = 1649, + X86_MOVDQUrm = 1650, + X86_MOVDQUrr = 1651, + X86_MOVDQUrr_REV = 1652, + X86_MOVHLPSrr = 1653, + X86_MOVHPDmr = 1654, + X86_MOVHPDrm = 1655, + X86_MOVHPSmr = 1656, + X86_MOVHPSrm = 1657, + X86_MOVLHPSrr = 1658, + X86_MOVLPDmr = 1659, + X86_MOVLPDrm = 1660, + X86_MOVLPSmr = 1661, + X86_MOVLPSrm = 1662, + X86_MOVMSKPDrr = 1663, + X86_MOVMSKPSrr = 1664, + X86_MOVNTDQArm = 1665, + X86_MOVNTDQmr = 1666, + X86_MOVNTI_64mr = 1667, + X86_MOVNTImr = 1668, + X86_MOVNTPDmr = 1669, + X86_MOVNTPSmr = 1670, + X86_MOVNTSD = 1671, + X86_MOVNTSS = 1672, + X86_MOVPDI2DImr = 1673, + X86_MOVPDI2DIrr = 1674, + X86_MOVPQI2QImr = 1675, + X86_MOVPQI2QIrr = 1676, + X86_MOVPQIto64mr = 1677, + X86_MOVPQIto64rr = 1678, + X86_MOVQI2PQIrm = 1679, + X86_MOVSB = 1680, + X86_MOVSDmr = 1681, + X86_MOVSDrm = 1682, + X86_MOVSDrr = 1683, + X86_MOVSDrr_REV = 1684, + X86_MOVSDto64mr = 1685, + X86_MOVSDto64rr = 1686, + X86_MOVSHDUPrm = 1687, + X86_MOVSHDUPrr = 1688, + X86_MOVSL = 1689, + X86_MOVSLDUPrm = 1690, + X86_MOVSLDUPrr = 1691, + X86_MOVSQ = 1692, + X86_MOVSS2DImr = 1693, + X86_MOVSS2DIrr = 1694, + X86_MOVSSmr = 1695, + X86_MOVSSrm = 1696, + X86_MOVSSrr = 1697, + X86_MOVSSrr_REV = 1698, + X86_MOVSW = 1699, + X86_MOVSX16rm16 = 1700, + X86_MOVSX16rm8 = 1701, + X86_MOVSX16rr16 = 1702, + X86_MOVSX16rr8 = 1703, + X86_MOVSX32rm16 = 1704, + X86_MOVSX32rm8 = 1705, + X86_MOVSX32rm8_NOREX = 1706, + X86_MOVSX32rr16 = 1707, + X86_MOVSX32rr8 = 1708, + X86_MOVSX32rr8_NOREX = 1709, + X86_MOVSX64rm16 = 1710, + X86_MOVSX64rm32 = 1711, + X86_MOVSX64rm8 = 1712, + X86_MOVSX64rr16 = 1713, + X86_MOVSX64rr32 = 1714, + X86_MOVSX64rr8 = 1715, + X86_MOVUPDmr = 1716, + X86_MOVUPDrm = 1717, + X86_MOVUPDrr = 1718, + X86_MOVUPDrr_REV = 1719, + X86_MOVUPSmr = 1720, + X86_MOVUPSrm = 1721, + X86_MOVUPSrr = 1722, + X86_MOVUPSrr_REV = 1723, + X86_MOVZPQILo2PQIrr = 1724, + X86_MOVZX16rm16 = 1725, + X86_MOVZX16rm8 = 1726, + X86_MOVZX16rr16 = 1727, + X86_MOVZX16rr8 = 1728, + X86_MOVZX32rm16 = 1729, + X86_MOVZX32rm8 = 1730, + X86_MOVZX32rm8_NOREX = 1731, + X86_MOVZX32rr16 = 1732, + X86_MOVZX32rr8 = 1733, + X86_MOVZX32rr8_NOREX = 1734, + X86_MOVZX64rm16 = 1735, + X86_MOVZX64rm8 = 1736, + X86_MOVZX64rr16 = 1737, + X86_MOVZX64rr8 = 1738, + X86_MPSADBWrmi = 1739, + X86_MPSADBWrri = 1740, + X86_MUL16m = 1741, + X86_MUL16r = 1742, + X86_MUL32m = 1743, + X86_MUL32r = 1744, + X86_MUL64m = 1745, + X86_MUL64r = 1746, + X86_MUL8m = 1747, + X86_MUL8r = 1748, + X86_MULPDrm = 1749, + X86_MULPDrr = 1750, + X86_MULPSrm = 1751, + X86_MULPSrr = 1752, + X86_MULSDrm = 1753, + X86_MULSDrm_Int = 1754, + X86_MULSDrr = 1755, + X86_MULSDrr_Int = 1756, + X86_MULSSrm = 1757, + X86_MULSSrm_Int = 1758, + X86_MULSSrr = 1759, + X86_MULSSrr_Int = 1760, + X86_MULX32rm = 1761, + X86_MULX32rr = 1762, + X86_MULX64rm = 1763, + X86_MULX64rr = 1764, + X86_MUL_F32m = 1765, + X86_MUL_F64m = 1766, + X86_MUL_FI16m = 1767, + X86_MUL_FI32m = 1768, + X86_MUL_FPrST0 = 1769, + X86_MUL_FST0r = 1770, + X86_MUL_Fp32 = 1771, + X86_MUL_Fp32m = 1772, + X86_MUL_Fp64 = 1773, + X86_MUL_Fp64m = 1774, + X86_MUL_Fp64m32 = 1775, + X86_MUL_Fp80 = 1776, + X86_MUL_Fp80m32 = 1777, + X86_MUL_Fp80m64 = 1778, + X86_MUL_FpI16m32 = 1779, + X86_MUL_FpI16m64 = 1780, + X86_MUL_FpI16m80 = 1781, + X86_MUL_FpI32m32 = 1782, + X86_MUL_FpI32m64 = 1783, + X86_MUL_FpI32m80 = 1784, + X86_MUL_FrST0 = 1785, + X86_MWAITXrrr = 1786, + X86_MWAITrr = 1787, + X86_NEG16m = 1788, + X86_NEG16r = 1789, + X86_NEG32m = 1790, + X86_NEG32r = 1791, + X86_NEG64m = 1792, + X86_NEG64r = 1793, + X86_NEG8m = 1794, + X86_NEG8r = 1795, + X86_NOOP = 1796, + X86_NOOP18_16m4 = 1797, + X86_NOOP18_16m5 = 1798, + X86_NOOP18_16m6 = 1799, + X86_NOOP18_16m7 = 1800, + X86_NOOP18_16r4 = 1801, + X86_NOOP18_16r5 = 1802, + X86_NOOP18_16r6 = 1803, + X86_NOOP18_16r7 = 1804, + X86_NOOP18_m4 = 1805, + X86_NOOP18_m5 = 1806, + X86_NOOP18_m6 = 1807, + X86_NOOP18_m7 = 1808, + X86_NOOP18_r4 = 1809, + X86_NOOP18_r5 = 1810, + X86_NOOP18_r6 = 1811, + X86_NOOP18_r7 = 1812, + X86_NOOP19rr = 1813, + X86_NOOPL = 1814, + X86_NOOPL_19 = 1815, + X86_NOOPL_1d = 1816, + X86_NOOPL_1e = 1817, + X86_NOOPLr = 1818, + X86_NOOPQ = 1819, + X86_NOOPQr = 1820, + X86_NOOPW = 1821, + X86_NOOPW_19 = 1822, + X86_NOOPW_1c = 1823, + X86_NOOPW_1d = 1824, + X86_NOOPW_1e = 1825, + X86_NOOPWr = 1826, + X86_NOT16m = 1827, + X86_NOT16r = 1828, + X86_NOT32m = 1829, + X86_NOT32r = 1830, + X86_NOT64m = 1831, + X86_NOT64r = 1832, + X86_NOT8m = 1833, + X86_NOT8r = 1834, + X86_OR16i16 = 1835, + X86_OR16mi = 1836, + X86_OR16mi8 = 1837, + X86_OR16mr = 1838, + X86_OR16ri = 1839, + X86_OR16ri8 = 1840, + X86_OR16rm = 1841, + X86_OR16rr = 1842, + X86_OR16rr_REV = 1843, + X86_OR32i32 = 1844, + X86_OR32mi = 1845, + X86_OR32mi8 = 1846, + X86_OR32mr = 1847, + X86_OR32ri = 1848, + X86_OR32ri8 = 1849, + X86_OR32rm = 1850, + X86_OR32rr = 1851, + X86_OR32rr_REV = 1852, + X86_OR64i32 = 1853, + X86_OR64mi32 = 1854, + X86_OR64mi8 = 1855, + X86_OR64mr = 1856, + X86_OR64ri32 = 1857, + X86_OR64ri8 = 1858, + X86_OR64rm = 1859, + X86_OR64rr = 1860, + X86_OR64rr_REV = 1861, + X86_OR8i8 = 1862, + X86_OR8mi = 1863, + X86_OR8mi8 = 1864, + X86_OR8mr = 1865, + X86_OR8ri = 1866, + X86_OR8ri8 = 1867, + X86_OR8rm = 1868, + X86_OR8rr = 1869, + X86_OR8rr_REV = 1870, + X86_ORPDrm = 1871, + X86_ORPDrr = 1872, + X86_ORPSrm = 1873, + X86_ORPSrr = 1874, + X86_OUT16ir = 1875, + X86_OUT16rr = 1876, + X86_OUT32ir = 1877, + X86_OUT32rr = 1878, + X86_OUT8ir = 1879, + X86_OUT8rr = 1880, + X86_OUTSB = 1881, + X86_OUTSL = 1882, + X86_OUTSW = 1883, + X86_PABSBrm = 1884, + X86_PABSBrr = 1885, + X86_PABSDrm = 1886, + X86_PABSDrr = 1887, + X86_PABSWrm = 1888, + X86_PABSWrr = 1889, + X86_PACKSSDWrm = 1890, + X86_PACKSSDWrr = 1891, + X86_PACKSSWBrm = 1892, + X86_PACKSSWBrr = 1893, + X86_PACKUSDWrm = 1894, + X86_PACKUSDWrr = 1895, + X86_PACKUSWBrm = 1896, + X86_PACKUSWBrr = 1897, + X86_PADDBrm = 1898, + X86_PADDBrr = 1899, + X86_PADDDrm = 1900, + X86_PADDDrr = 1901, + X86_PADDQrm = 1902, + X86_PADDQrr = 1903, + X86_PADDSBrm = 1904, + X86_PADDSBrr = 1905, + X86_PADDSWrm = 1906, + X86_PADDSWrr = 1907, + X86_PADDUSBrm = 1908, + X86_PADDUSBrr = 1909, + X86_PADDUSWrm = 1910, + X86_PADDUSWrr = 1911, + X86_PADDWrm = 1912, + X86_PADDWrr = 1913, + X86_PALIGNRrmi = 1914, + X86_PALIGNRrri = 1915, + X86_PANDNrm = 1916, + X86_PANDNrr = 1917, + X86_PANDrm = 1918, + X86_PANDrr = 1919, + X86_PAUSE = 1920, + X86_PAVGBrm = 1921, + X86_PAVGBrr = 1922, + X86_PAVGUSBrm = 1923, + X86_PAVGUSBrr = 1924, + X86_PAVGWrm = 1925, + X86_PAVGWrr = 1926, + X86_PBLENDVBrm0 = 1927, + X86_PBLENDVBrr0 = 1928, + X86_PBLENDWrmi = 1929, + X86_PBLENDWrri = 1930, + X86_PCLMULQDQrm = 1931, + X86_PCLMULQDQrr = 1932, + X86_PCMPEQBrm = 1933, + X86_PCMPEQBrr = 1934, + X86_PCMPEQDrm = 1935, + X86_PCMPEQDrr = 1936, + X86_PCMPEQQrm = 1937, + X86_PCMPEQQrr = 1938, + X86_PCMPEQWrm = 1939, + X86_PCMPEQWrr = 1940, + X86_PCMPESTRIrm = 1941, + X86_PCMPESTRIrr = 1942, + X86_PCMPESTRMrm = 1943, + X86_PCMPESTRMrr = 1944, + X86_PCMPGTBrm = 1945, + X86_PCMPGTBrr = 1946, + X86_PCMPGTDrm = 1947, + X86_PCMPGTDrr = 1948, + X86_PCMPGTQrm = 1949, + X86_PCMPGTQrr = 1950, + X86_PCMPGTWrm = 1951, + X86_PCMPGTWrr = 1952, + X86_PCMPISTRIrm = 1953, + X86_PCMPISTRIrr = 1954, + X86_PCMPISTRMrm = 1955, + X86_PCMPISTRMrr = 1956, + X86_PCONFIG = 1957, + X86_PDEP32rm = 1958, + X86_PDEP32rr = 1959, + X86_PDEP64rm = 1960, + X86_PDEP64rr = 1961, + X86_PEXT32rm = 1962, + X86_PEXT32rr = 1963, + X86_PEXT64rm = 1964, + X86_PEXT64rr = 1965, + X86_PEXTRBmr = 1966, + X86_PEXTRBrr = 1967, + X86_PEXTRDmr = 1968, + X86_PEXTRDrr = 1969, + X86_PEXTRQmr = 1970, + X86_PEXTRQrr = 1971, + X86_PEXTRWmr = 1972, + X86_PEXTRWrr = 1973, + X86_PEXTRWrr_REV = 1974, + X86_PF2IDrm = 1975, + X86_PF2IDrr = 1976, + X86_PF2IWrm = 1977, + X86_PF2IWrr = 1978, + X86_PFACCrm = 1979, + X86_PFACCrr = 1980, + X86_PFADDrm = 1981, + X86_PFADDrr = 1982, + X86_PFCMPEQrm = 1983, + X86_PFCMPEQrr = 1984, + X86_PFCMPGErm = 1985, + X86_PFCMPGErr = 1986, + X86_PFCMPGTrm = 1987, + X86_PFCMPGTrr = 1988, + X86_PFMAXrm = 1989, + X86_PFMAXrr = 1990, + X86_PFMINrm = 1991, + X86_PFMINrr = 1992, + X86_PFMULrm = 1993, + X86_PFMULrr = 1994, + X86_PFNACCrm = 1995, + X86_PFNACCrr = 1996, + X86_PFPNACCrm = 1997, + X86_PFPNACCrr = 1998, + X86_PFRCPIT1rm = 1999, + X86_PFRCPIT1rr = 2000, + X86_PFRCPIT2rm = 2001, + X86_PFRCPIT2rr = 2002, + X86_PFRCPrm = 2003, + X86_PFRCPrr = 2004, + X86_PFRSQIT1rm = 2005, + X86_PFRSQIT1rr = 2006, + X86_PFRSQRTrm = 2007, + X86_PFRSQRTrr = 2008, + X86_PFSUBRrm = 2009, + X86_PFSUBRrr = 2010, + X86_PFSUBrm = 2011, + X86_PFSUBrr = 2012, + X86_PHADDDrm = 2013, + X86_PHADDDrr = 2014, + X86_PHADDSWrm = 2015, + X86_PHADDSWrr = 2016, + X86_PHADDWrm = 2017, + X86_PHADDWrr = 2018, + X86_PHMINPOSUWrm = 2019, + X86_PHMINPOSUWrr = 2020, + X86_PHSUBDrm = 2021, + X86_PHSUBDrr = 2022, + X86_PHSUBSWrm = 2023, + X86_PHSUBSWrr = 2024, + X86_PHSUBWrm = 2025, + X86_PHSUBWrr = 2026, + X86_PI2FDrm = 2027, + X86_PI2FDrr = 2028, + X86_PI2FWrm = 2029, + X86_PI2FWrr = 2030, + X86_PINSRBrm = 2031, + X86_PINSRBrr = 2032, + X86_PINSRDrm = 2033, + X86_PINSRDrr = 2034, + X86_PINSRQrm = 2035, + X86_PINSRQrr = 2036, + X86_PINSRWrm = 2037, + X86_PINSRWrr = 2038, + X86_PMADDUBSWrm = 2039, + X86_PMADDUBSWrr = 2040, + X86_PMADDWDrm = 2041, + X86_PMADDWDrr = 2042, + X86_PMAXSBrm = 2043, + X86_PMAXSBrr = 2044, + X86_PMAXSDrm = 2045, + X86_PMAXSDrr = 2046, + X86_PMAXSWrm = 2047, + X86_PMAXSWrr = 2048, + X86_PMAXUBrm = 2049, + X86_PMAXUBrr = 2050, + X86_PMAXUDrm = 2051, + X86_PMAXUDrr = 2052, + X86_PMAXUWrm = 2053, + X86_PMAXUWrr = 2054, + X86_PMINSBrm = 2055, + X86_PMINSBrr = 2056, + X86_PMINSDrm = 2057, + X86_PMINSDrr = 2058, + X86_PMINSWrm = 2059, + X86_PMINSWrr = 2060, + X86_PMINUBrm = 2061, + X86_PMINUBrr = 2062, + X86_PMINUDrm = 2063, + X86_PMINUDrr = 2064, + X86_PMINUWrm = 2065, + X86_PMINUWrr = 2066, + X86_PMOVMSKBrr = 2067, + X86_PMOVSXBDrm = 2068, + X86_PMOVSXBDrr = 2069, + X86_PMOVSXBQrm = 2070, + X86_PMOVSXBQrr = 2071, + X86_PMOVSXBWrm = 2072, + X86_PMOVSXBWrr = 2073, + X86_PMOVSXDQrm = 2074, + X86_PMOVSXDQrr = 2075, + X86_PMOVSXWDrm = 2076, + X86_PMOVSXWDrr = 2077, + X86_PMOVSXWQrm = 2078, + X86_PMOVSXWQrr = 2079, + X86_PMOVZXBDrm = 2080, + X86_PMOVZXBDrr = 2081, + X86_PMOVZXBQrm = 2082, + X86_PMOVZXBQrr = 2083, + X86_PMOVZXBWrm = 2084, + X86_PMOVZXBWrr = 2085, + X86_PMOVZXDQrm = 2086, + X86_PMOVZXDQrr = 2087, + X86_PMOVZXWDrm = 2088, + X86_PMOVZXWDrr = 2089, + X86_PMOVZXWQrm = 2090, + X86_PMOVZXWQrr = 2091, + X86_PMULDQrm = 2092, + X86_PMULDQrr = 2093, + X86_PMULHRSWrm = 2094, + X86_PMULHRSWrr = 2095, + X86_PMULHRWrm = 2096, + X86_PMULHRWrr = 2097, + X86_PMULHUWrm = 2098, + X86_PMULHUWrr = 2099, + X86_PMULHWrm = 2100, + X86_PMULHWrr = 2101, + X86_PMULLDrm = 2102, + X86_PMULLDrr = 2103, + X86_PMULLWrm = 2104, + X86_PMULLWrr = 2105, + X86_PMULUDQrm = 2106, + X86_PMULUDQrr = 2107, + X86_POP16r = 2108, + X86_POP16rmm = 2109, + X86_POP16rmr = 2110, + X86_POP32r = 2111, + X86_POP32rmm = 2112, + X86_POP32rmr = 2113, + X86_POP64r = 2114, + X86_POP64rmm = 2115, + X86_POP64rmr = 2116, + X86_POPA16 = 2117, + X86_POPA32 = 2118, + X86_POPCNT16rm = 2119, + X86_POPCNT16rr = 2120, + X86_POPCNT32rm = 2121, + X86_POPCNT32rr = 2122, + X86_POPCNT64rm = 2123, + X86_POPCNT64rr = 2124, + X86_POPDS16 = 2125, + X86_POPDS32 = 2126, + X86_POPES16 = 2127, + X86_POPES32 = 2128, + X86_POPF16 = 2129, + X86_POPF32 = 2130, + X86_POPF64 = 2131, + X86_POPFS16 = 2132, + X86_POPFS32 = 2133, + X86_POPFS64 = 2134, + X86_POPGS16 = 2135, + X86_POPGS32 = 2136, + X86_POPGS64 = 2137, + X86_POPSS16 = 2138, + X86_POPSS32 = 2139, + X86_PORrm = 2140, + X86_PORrr = 2141, + X86_PREFETCH = 2142, + X86_PREFETCHNTA = 2143, + X86_PREFETCHT0 = 2144, + X86_PREFETCHT1 = 2145, + X86_PREFETCHT2 = 2146, + X86_PREFETCHW = 2147, + X86_PREFETCHWT1 = 2148, + X86_PSADBWrm = 2149, + X86_PSADBWrr = 2150, + X86_PSHUFBrm = 2151, + X86_PSHUFBrr = 2152, + X86_PSHUFDmi = 2153, + X86_PSHUFDri = 2154, + X86_PSHUFHWmi = 2155, + X86_PSHUFHWri = 2156, + X86_PSHUFLWmi = 2157, + X86_PSHUFLWri = 2158, + X86_PSIGNBrm = 2159, + X86_PSIGNBrr = 2160, + X86_PSIGNDrm = 2161, + X86_PSIGNDrr = 2162, + X86_PSIGNWrm = 2163, + X86_PSIGNWrr = 2164, + X86_PSLLDQri = 2165, + X86_PSLLDri = 2166, + X86_PSLLDrm = 2167, + X86_PSLLDrr = 2168, + X86_PSLLQri = 2169, + X86_PSLLQrm = 2170, + X86_PSLLQrr = 2171, + X86_PSLLWri = 2172, + X86_PSLLWrm = 2173, + X86_PSLLWrr = 2174, + X86_PSRADri = 2175, + X86_PSRADrm = 2176, + X86_PSRADrr = 2177, + X86_PSRAWri = 2178, + X86_PSRAWrm = 2179, + X86_PSRAWrr = 2180, + X86_PSRLDQri = 2181, + X86_PSRLDri = 2182, + X86_PSRLDrm = 2183, + X86_PSRLDrr = 2184, + X86_PSRLQri = 2185, + X86_PSRLQrm = 2186, + X86_PSRLQrr = 2187, + X86_PSRLWri = 2188, + X86_PSRLWrm = 2189, + X86_PSRLWrr = 2190, + X86_PSUBBrm = 2191, + X86_PSUBBrr = 2192, + X86_PSUBDrm = 2193, + X86_PSUBDrr = 2194, + X86_PSUBQrm = 2195, + X86_PSUBQrr = 2196, + X86_PSUBSBrm = 2197, + X86_PSUBSBrr = 2198, + X86_PSUBSWrm = 2199, + X86_PSUBSWrr = 2200, + X86_PSUBUSBrm = 2201, + X86_PSUBUSBrr = 2202, + X86_PSUBUSWrm = 2203, + X86_PSUBUSWrr = 2204, + X86_PSUBWrm = 2205, + X86_PSUBWrr = 2206, + X86_PSWAPDrm = 2207, + X86_PSWAPDrr = 2208, + X86_PTESTrm = 2209, + X86_PTESTrr = 2210, + X86_PTWRITE64m = 2211, + X86_PTWRITE64r = 2212, + X86_PTWRITEm = 2213, + X86_PTWRITEr = 2214, + X86_PUNPCKHBWrm = 2215, + X86_PUNPCKHBWrr = 2216, + X86_PUNPCKHDQrm = 2217, + X86_PUNPCKHDQrr = 2218, + X86_PUNPCKHQDQrm = 2219, + X86_PUNPCKHQDQrr = 2220, + X86_PUNPCKHWDrm = 2221, + X86_PUNPCKHWDrr = 2222, + X86_PUNPCKLBWrm = 2223, + X86_PUNPCKLBWrr = 2224, + X86_PUNPCKLDQrm = 2225, + X86_PUNPCKLDQrr = 2226, + X86_PUNPCKLQDQrm = 2227, + X86_PUNPCKLQDQrr = 2228, + X86_PUNPCKLWDrm = 2229, + X86_PUNPCKLWDrr = 2230, + X86_PUSH16i8 = 2231, + X86_PUSH16r = 2232, + X86_PUSH16rmm = 2233, + X86_PUSH16rmr = 2234, + X86_PUSH32i8 = 2235, + X86_PUSH32r = 2236, + X86_PUSH32rmm = 2237, + X86_PUSH32rmr = 2238, + X86_PUSH64i32 = 2239, + X86_PUSH64i8 = 2240, + X86_PUSH64r = 2241, + X86_PUSH64rmm = 2242, + X86_PUSH64rmr = 2243, + X86_PUSHA16 = 2244, + X86_PUSHA32 = 2245, + X86_PUSHCS16 = 2246, + X86_PUSHCS32 = 2247, + X86_PUSHDS16 = 2248, + X86_PUSHDS32 = 2249, + X86_PUSHES16 = 2250, + X86_PUSHES32 = 2251, + X86_PUSHF16 = 2252, + X86_PUSHF32 = 2253, + X86_PUSHF64 = 2254, + X86_PUSHFS16 = 2255, + X86_PUSHFS32 = 2256, + X86_PUSHFS64 = 2257, + X86_PUSHGS16 = 2258, + X86_PUSHGS32 = 2259, + X86_PUSHGS64 = 2260, + X86_PUSHSS16 = 2261, + X86_PUSHSS32 = 2262, + X86_PUSHi16 = 2263, + X86_PUSHi32 = 2264, + X86_PXORrm = 2265, + X86_PXORrr = 2266, + X86_RCL16m1 = 2267, + X86_RCL16mCL = 2268, + X86_RCL16mi = 2269, + X86_RCL16r1 = 2270, + X86_RCL16rCL = 2271, + X86_RCL16ri = 2272, + X86_RCL32m1 = 2273, + X86_RCL32mCL = 2274, + X86_RCL32mi = 2275, + X86_RCL32r1 = 2276, + X86_RCL32rCL = 2277, + X86_RCL32ri = 2278, + X86_RCL64m1 = 2279, + X86_RCL64mCL = 2280, + X86_RCL64mi = 2281, + X86_RCL64r1 = 2282, + X86_RCL64rCL = 2283, + X86_RCL64ri = 2284, + X86_RCL8m1 = 2285, + X86_RCL8mCL = 2286, + X86_RCL8mi = 2287, + X86_RCL8r1 = 2288, + X86_RCL8rCL = 2289, + X86_RCL8ri = 2290, + X86_RCPPSm = 2291, + X86_RCPPSr = 2292, + X86_RCPSSm = 2293, + X86_RCPSSm_Int = 2294, + X86_RCPSSr = 2295, + X86_RCPSSr_Int = 2296, + X86_RCR16m1 = 2297, + X86_RCR16mCL = 2298, + X86_RCR16mi = 2299, + X86_RCR16r1 = 2300, + X86_RCR16rCL = 2301, + X86_RCR16ri = 2302, + X86_RCR32m1 = 2303, + X86_RCR32mCL = 2304, + X86_RCR32mi = 2305, + X86_RCR32r1 = 2306, + X86_RCR32rCL = 2307, + X86_RCR32ri = 2308, + X86_RCR64m1 = 2309, + X86_RCR64mCL = 2310, + X86_RCR64mi = 2311, + X86_RCR64r1 = 2312, + X86_RCR64rCL = 2313, + X86_RCR64ri = 2314, + X86_RCR8m1 = 2315, + X86_RCR8mCL = 2316, + X86_RCR8mi = 2317, + X86_RCR8r1 = 2318, + X86_RCR8rCL = 2319, + X86_RCR8ri = 2320, + X86_RDFSBASE = 2321, + X86_RDFSBASE64 = 2322, + X86_RDGSBASE = 2323, + X86_RDGSBASE64 = 2324, + X86_RDMSR = 2325, + X86_RDPID32 = 2326, + X86_RDPID64 = 2327, + X86_RDPKRUr = 2328, + X86_RDPMC = 2329, + X86_RDRAND16r = 2330, + X86_RDRAND32r = 2331, + X86_RDRAND64r = 2332, + X86_RDSEED16r = 2333, + X86_RDSEED32r = 2334, + X86_RDSEED64r = 2335, + X86_RDSSPD = 2336, + X86_RDSSPQ = 2337, + X86_RDTSC = 2338, + X86_RDTSCP = 2339, + X86_REPNE_PREFIX = 2340, + X86_REP_PREFIX = 2341, + X86_RETIL = 2342, + X86_RETIQ = 2343, + X86_RETIW = 2344, + X86_RETL = 2345, + X86_RETQ = 2346, + X86_RETW = 2347, + X86_REX64_PREFIX = 2348, + X86_ROL16m1 = 2349, + X86_ROL16mCL = 2350, + X86_ROL16mi = 2351, + X86_ROL16r1 = 2352, + X86_ROL16rCL = 2353, + X86_ROL16ri = 2354, + X86_ROL32m1 = 2355, + X86_ROL32mCL = 2356, + X86_ROL32mi = 2357, + X86_ROL32r1 = 2358, + X86_ROL32rCL = 2359, + X86_ROL32ri = 2360, + X86_ROL64m1 = 2361, + X86_ROL64mCL = 2362, + X86_ROL64mi = 2363, + X86_ROL64r1 = 2364, + X86_ROL64rCL = 2365, + X86_ROL64ri = 2366, + X86_ROL8m1 = 2367, + X86_ROL8mCL = 2368, + X86_ROL8mi = 2369, + X86_ROL8r1 = 2370, + X86_ROL8rCL = 2371, + X86_ROL8ri = 2372, + X86_ROR16m1 = 2373, + X86_ROR16mCL = 2374, + X86_ROR16mi = 2375, + X86_ROR16r1 = 2376, + X86_ROR16rCL = 2377, + X86_ROR16ri = 2378, + X86_ROR32m1 = 2379, + X86_ROR32mCL = 2380, + X86_ROR32mi = 2381, + X86_ROR32r1 = 2382, + X86_ROR32rCL = 2383, + X86_ROR32ri = 2384, + X86_ROR64m1 = 2385, + X86_ROR64mCL = 2386, + X86_ROR64mi = 2387, + X86_ROR64r1 = 2388, + X86_ROR64rCL = 2389, + X86_ROR64ri = 2390, + X86_ROR8m1 = 2391, + X86_ROR8mCL = 2392, + X86_ROR8mi = 2393, + X86_ROR8r1 = 2394, + X86_ROR8rCL = 2395, + X86_ROR8ri = 2396, + X86_RORX32mi = 2397, + X86_RORX32ri = 2398, + X86_RORX64mi = 2399, + X86_RORX64ri = 2400, + X86_ROUNDPDm = 2401, + X86_ROUNDPDr = 2402, + X86_ROUNDPSm = 2403, + X86_ROUNDPSr = 2404, + X86_ROUNDSDm = 2405, + X86_ROUNDSDm_Int = 2406, + X86_ROUNDSDr = 2407, + X86_ROUNDSDr_Int = 2408, + X86_ROUNDSSm = 2409, + X86_ROUNDSSm_Int = 2410, + X86_ROUNDSSr = 2411, + X86_ROUNDSSr_Int = 2412, + X86_RSM = 2413, + X86_RSQRTPSm = 2414, + X86_RSQRTPSr = 2415, + X86_RSQRTSSm = 2416, + X86_RSQRTSSm_Int = 2417, + X86_RSQRTSSr = 2418, + X86_RSQRTSSr_Int = 2419, + X86_RSTORSSP = 2420, + X86_SAHF = 2421, + X86_SAL16m1 = 2422, + X86_SAL16mCL = 2423, + X86_SAL16mi = 2424, + X86_SAL16r1 = 2425, + X86_SAL16rCL = 2426, + X86_SAL16ri = 2427, + X86_SAL32m1 = 2428, + X86_SAL32mCL = 2429, + X86_SAL32mi = 2430, + X86_SAL32r1 = 2431, + X86_SAL32rCL = 2432, + X86_SAL32ri = 2433, + X86_SAL64m1 = 2434, + X86_SAL64mCL = 2435, + X86_SAL64mi = 2436, + X86_SAL64r1 = 2437, + X86_SAL64rCL = 2438, + X86_SAL64ri = 2439, + X86_SAL8m1 = 2440, + X86_SAL8mCL = 2441, + X86_SAL8mi = 2442, + X86_SAL8r1 = 2443, + X86_SAL8rCL = 2444, + X86_SAL8ri = 2445, + X86_SALC = 2446, + X86_SAR16m1 = 2447, + X86_SAR16mCL = 2448, + X86_SAR16mi = 2449, + X86_SAR16r1 = 2450, + X86_SAR16rCL = 2451, + X86_SAR16ri = 2452, + X86_SAR32m1 = 2453, + X86_SAR32mCL = 2454, + X86_SAR32mi = 2455, + X86_SAR32r1 = 2456, + X86_SAR32rCL = 2457, + X86_SAR32ri = 2458, + X86_SAR64m1 = 2459, + X86_SAR64mCL = 2460, + X86_SAR64mi = 2461, + X86_SAR64r1 = 2462, + X86_SAR64rCL = 2463, + X86_SAR64ri = 2464, + X86_SAR8m1 = 2465, + X86_SAR8mCL = 2466, + X86_SAR8mi = 2467, + X86_SAR8r1 = 2468, + X86_SAR8rCL = 2469, + X86_SAR8ri = 2470, + X86_SARX32rm = 2471, + X86_SARX32rr = 2472, + X86_SARX64rm = 2473, + X86_SARX64rr = 2474, + X86_SAVEPREVSSP = 2475, + X86_SBB16i16 = 2476, + X86_SBB16mi = 2477, + X86_SBB16mi8 = 2478, + X86_SBB16mr = 2479, + X86_SBB16ri = 2480, + X86_SBB16ri8 = 2481, + X86_SBB16rm = 2482, + X86_SBB16rr = 2483, + X86_SBB16rr_REV = 2484, + X86_SBB32i32 = 2485, + X86_SBB32mi = 2486, + X86_SBB32mi8 = 2487, + X86_SBB32mr = 2488, + X86_SBB32ri = 2489, + X86_SBB32ri8 = 2490, + X86_SBB32rm = 2491, + X86_SBB32rr = 2492, + X86_SBB32rr_REV = 2493, + X86_SBB64i32 = 2494, + X86_SBB64mi32 = 2495, + X86_SBB64mi8 = 2496, + X86_SBB64mr = 2497, + X86_SBB64ri32 = 2498, + X86_SBB64ri8 = 2499, + X86_SBB64rm = 2500, + X86_SBB64rr = 2501, + X86_SBB64rr_REV = 2502, + X86_SBB8i8 = 2503, + X86_SBB8mi = 2504, + X86_SBB8mi8 = 2505, + X86_SBB8mr = 2506, + X86_SBB8ri = 2507, + X86_SBB8ri8 = 2508, + X86_SBB8rm = 2509, + X86_SBB8rr = 2510, + X86_SBB8rr_REV = 2511, + X86_SCASB = 2512, + X86_SCASL = 2513, + X86_SCASQ = 2514, + X86_SCASW = 2515, + X86_SETAEm = 2516, + X86_SETAEr = 2517, + X86_SETAm = 2518, + X86_SETAr = 2519, + X86_SETBEm = 2520, + X86_SETBEr = 2521, + X86_SETBm = 2522, + X86_SETBr = 2523, + X86_SETEm = 2524, + X86_SETEr = 2525, + X86_SETGEm = 2526, + X86_SETGEr = 2527, + X86_SETGm = 2528, + X86_SETGr = 2529, + X86_SETLEm = 2530, + X86_SETLEr = 2531, + X86_SETLm = 2532, + X86_SETLr = 2533, + X86_SETNEm = 2534, + X86_SETNEr = 2535, + X86_SETNOm = 2536, + X86_SETNOr = 2537, + X86_SETNPm = 2538, + X86_SETNPr = 2539, + X86_SETNSm = 2540, + X86_SETNSr = 2541, + X86_SETOm = 2542, + X86_SETOr = 2543, + X86_SETPm = 2544, + X86_SETPr = 2545, + X86_SETSSBSY = 2546, + X86_SETSm = 2547, + X86_SETSr = 2548, + X86_SFENCE = 2549, + X86_SGDT16m = 2550, + X86_SGDT32m = 2551, + X86_SGDT64m = 2552, + X86_SHA1MSG1rm = 2553, + X86_SHA1MSG1rr = 2554, + X86_SHA1MSG2rm = 2555, + X86_SHA1MSG2rr = 2556, + X86_SHA1NEXTErm = 2557, + X86_SHA1NEXTErr = 2558, + X86_SHA1RNDS4rmi = 2559, + X86_SHA1RNDS4rri = 2560, + X86_SHA256MSG1rm = 2561, + X86_SHA256MSG1rr = 2562, + X86_SHA256MSG2rm = 2563, + X86_SHA256MSG2rr = 2564, + X86_SHA256RNDS2rm = 2565, + X86_SHA256RNDS2rr = 2566, + X86_SHL16m1 = 2567, + X86_SHL16mCL = 2568, + X86_SHL16mi = 2569, + X86_SHL16r1 = 2570, + X86_SHL16rCL = 2571, + X86_SHL16ri = 2572, + X86_SHL32m1 = 2573, + X86_SHL32mCL = 2574, + X86_SHL32mi = 2575, + X86_SHL32r1 = 2576, + X86_SHL32rCL = 2577, + X86_SHL32ri = 2578, + X86_SHL64m1 = 2579, + X86_SHL64mCL = 2580, + X86_SHL64mi = 2581, + X86_SHL64r1 = 2582, + X86_SHL64rCL = 2583, + X86_SHL64ri = 2584, + X86_SHL8m1 = 2585, + X86_SHL8mCL = 2586, + X86_SHL8mi = 2587, + X86_SHL8r1 = 2588, + X86_SHL8rCL = 2589, + X86_SHL8ri = 2590, + X86_SHLD16mrCL = 2591, + X86_SHLD16mri8 = 2592, + X86_SHLD16rrCL = 2593, + X86_SHLD16rri8 = 2594, + X86_SHLD32mrCL = 2595, + X86_SHLD32mri8 = 2596, + X86_SHLD32rrCL = 2597, + X86_SHLD32rri8 = 2598, + X86_SHLD64mrCL = 2599, + X86_SHLD64mri8 = 2600, + X86_SHLD64rrCL = 2601, + X86_SHLD64rri8 = 2602, + X86_SHLX32rm = 2603, + X86_SHLX32rr = 2604, + X86_SHLX64rm = 2605, + X86_SHLX64rr = 2606, + X86_SHR16m1 = 2607, + X86_SHR16mCL = 2608, + X86_SHR16mi = 2609, + X86_SHR16r1 = 2610, + X86_SHR16rCL = 2611, + X86_SHR16ri = 2612, + X86_SHR32m1 = 2613, + X86_SHR32mCL = 2614, + X86_SHR32mi = 2615, + X86_SHR32r1 = 2616, + X86_SHR32rCL = 2617, + X86_SHR32ri = 2618, + X86_SHR64m1 = 2619, + X86_SHR64mCL = 2620, + X86_SHR64mi = 2621, + X86_SHR64r1 = 2622, + X86_SHR64rCL = 2623, + X86_SHR64ri = 2624, + X86_SHR8m1 = 2625, + X86_SHR8mCL = 2626, + X86_SHR8mi = 2627, + X86_SHR8r1 = 2628, + X86_SHR8rCL = 2629, + X86_SHR8ri = 2630, + X86_SHRD16mrCL = 2631, + X86_SHRD16mri8 = 2632, + X86_SHRD16rrCL = 2633, + X86_SHRD16rri8 = 2634, + X86_SHRD32mrCL = 2635, + X86_SHRD32mri8 = 2636, + X86_SHRD32rrCL = 2637, + X86_SHRD32rri8 = 2638, + X86_SHRD64mrCL = 2639, + X86_SHRD64mri8 = 2640, + X86_SHRD64rrCL = 2641, + X86_SHRD64rri8 = 2642, + X86_SHRX32rm = 2643, + X86_SHRX32rr = 2644, + X86_SHRX64rm = 2645, + X86_SHRX64rr = 2646, + X86_SHUFPDrmi = 2647, + X86_SHUFPDrri = 2648, + X86_SHUFPSrmi = 2649, + X86_SHUFPSrri = 2650, + X86_SIDT16m = 2651, + X86_SIDT32m = 2652, + X86_SIDT64m = 2653, + X86_SIN_F = 2654, + X86_SIN_Fp32 = 2655, + X86_SIN_Fp64 = 2656, + X86_SIN_Fp80 = 2657, + X86_SKINIT = 2658, + X86_SLDT16m = 2659, + X86_SLDT16r = 2660, + X86_SLDT32r = 2661, + X86_SLDT64r = 2662, + X86_SLWPCB = 2663, + X86_SLWPCB64 = 2664, + X86_SMSW16m = 2665, + X86_SMSW16r = 2666, + X86_SMSW32r = 2667, + X86_SMSW64r = 2668, + X86_SQRTPDm = 2669, + X86_SQRTPDr = 2670, + X86_SQRTPSm = 2671, + X86_SQRTPSr = 2672, + X86_SQRTSDm = 2673, + X86_SQRTSDm_Int = 2674, + X86_SQRTSDr = 2675, + X86_SQRTSDr_Int = 2676, + X86_SQRTSSm = 2677, + X86_SQRTSSm_Int = 2678, + X86_SQRTSSr = 2679, + X86_SQRTSSr_Int = 2680, + X86_SQRT_F = 2681, + X86_SQRT_Fp32 = 2682, + X86_SQRT_Fp64 = 2683, + X86_SQRT_Fp80 = 2684, + X86_STAC = 2685, + X86_STC = 2686, + X86_STD = 2687, + X86_STGI = 2688, + X86_STI = 2689, + X86_STMXCSR = 2690, + X86_STOSB = 2691, + X86_STOSL = 2692, + X86_STOSQ = 2693, + X86_STOSW = 2694, + X86_STR16r = 2695, + X86_STR32r = 2696, + X86_STR64r = 2697, + X86_STRm = 2698, + X86_ST_F32m = 2699, + X86_ST_F64m = 2700, + X86_ST_FP32m = 2701, + X86_ST_FP64m = 2702, + X86_ST_FP80m = 2703, + X86_ST_FPrr = 2704, + X86_ST_Fp32m = 2705, + X86_ST_Fp64m = 2706, + X86_ST_Fp64m32 = 2707, + X86_ST_Fp80m32 = 2708, + X86_ST_Fp80m64 = 2709, + X86_ST_FpP32m = 2710, + X86_ST_FpP64m = 2711, + X86_ST_FpP64m32 = 2712, + X86_ST_FpP80m = 2713, + X86_ST_FpP80m32 = 2714, + X86_ST_FpP80m64 = 2715, + X86_ST_Frr = 2716, + X86_SUB16i16 = 2717, + X86_SUB16mi = 2718, + X86_SUB16mi8 = 2719, + X86_SUB16mr = 2720, + X86_SUB16ri = 2721, + X86_SUB16ri8 = 2722, + X86_SUB16rm = 2723, + X86_SUB16rr = 2724, + X86_SUB16rr_REV = 2725, + X86_SUB32i32 = 2726, + X86_SUB32mi = 2727, + X86_SUB32mi8 = 2728, + X86_SUB32mr = 2729, + X86_SUB32ri = 2730, + X86_SUB32ri8 = 2731, + X86_SUB32rm = 2732, + X86_SUB32rr = 2733, + X86_SUB32rr_REV = 2734, + X86_SUB64i32 = 2735, + X86_SUB64mi32 = 2736, + X86_SUB64mi8 = 2737, + X86_SUB64mr = 2738, + X86_SUB64ri32 = 2739, + X86_SUB64ri8 = 2740, + X86_SUB64rm = 2741, + X86_SUB64rr = 2742, + X86_SUB64rr_REV = 2743, + X86_SUB8i8 = 2744, + X86_SUB8mi = 2745, + X86_SUB8mi8 = 2746, + X86_SUB8mr = 2747, + X86_SUB8ri = 2748, + X86_SUB8ri8 = 2749, + X86_SUB8rm = 2750, + X86_SUB8rr = 2751, + X86_SUB8rr_REV = 2752, + X86_SUBPDrm = 2753, + X86_SUBPDrr = 2754, + X86_SUBPSrm = 2755, + X86_SUBPSrr = 2756, + X86_SUBR_F32m = 2757, + X86_SUBR_F64m = 2758, + X86_SUBR_FI16m = 2759, + X86_SUBR_FI32m = 2760, + X86_SUBR_FPrST0 = 2761, + X86_SUBR_FST0r = 2762, + X86_SUBR_Fp32m = 2763, + X86_SUBR_Fp64m = 2764, + X86_SUBR_Fp64m32 = 2765, + X86_SUBR_Fp80m32 = 2766, + X86_SUBR_Fp80m64 = 2767, + X86_SUBR_FpI16m32 = 2768, + X86_SUBR_FpI16m64 = 2769, + X86_SUBR_FpI16m80 = 2770, + X86_SUBR_FpI32m32 = 2771, + X86_SUBR_FpI32m64 = 2772, + X86_SUBR_FpI32m80 = 2773, + X86_SUBR_FrST0 = 2774, + X86_SUBSDrm = 2775, + X86_SUBSDrm_Int = 2776, + X86_SUBSDrr = 2777, + X86_SUBSDrr_Int = 2778, + X86_SUBSSrm = 2779, + X86_SUBSSrm_Int = 2780, + X86_SUBSSrr = 2781, + X86_SUBSSrr_Int = 2782, + X86_SUB_F32m = 2783, + X86_SUB_F64m = 2784, + X86_SUB_FI16m = 2785, + X86_SUB_FI32m = 2786, + X86_SUB_FPrST0 = 2787, + X86_SUB_FST0r = 2788, + X86_SUB_Fp32 = 2789, + X86_SUB_Fp32m = 2790, + X86_SUB_Fp64 = 2791, + X86_SUB_Fp64m = 2792, + X86_SUB_Fp64m32 = 2793, + X86_SUB_Fp80 = 2794, + X86_SUB_Fp80m32 = 2795, + X86_SUB_Fp80m64 = 2796, + X86_SUB_FpI16m32 = 2797, + X86_SUB_FpI16m64 = 2798, + X86_SUB_FpI16m80 = 2799, + X86_SUB_FpI32m32 = 2800, + X86_SUB_FpI32m64 = 2801, + X86_SUB_FpI32m80 = 2802, + X86_SUB_FrST0 = 2803, + X86_SWAPGS = 2804, + X86_SYSCALL = 2805, + X86_SYSENTER = 2806, + X86_SYSEXIT = 2807, + X86_SYSEXIT64 = 2808, + X86_SYSRET = 2809, + X86_SYSRET64 = 2810, + X86_T1MSKC32rm = 2811, + X86_T1MSKC32rr = 2812, + X86_T1MSKC64rm = 2813, + X86_T1MSKC64rr = 2814, + X86_TEST16i16 = 2815, + X86_TEST16mi = 2816, + X86_TEST16mi_alt = 2817, + X86_TEST16mr = 2818, + X86_TEST16ri = 2819, + X86_TEST16ri_alt = 2820, + X86_TEST16rr = 2821, + X86_TEST32i32 = 2822, + X86_TEST32mi = 2823, + X86_TEST32mi_alt = 2824, + X86_TEST32mr = 2825, + X86_TEST32ri = 2826, + X86_TEST32ri_alt = 2827, + X86_TEST32rr = 2828, + X86_TEST64i32 = 2829, + X86_TEST64mi32 = 2830, + X86_TEST64mi32_alt = 2831, + X86_TEST64mr = 2832, + X86_TEST64ri32 = 2833, + X86_TEST64ri32_alt = 2834, + X86_TEST64rr = 2835, + X86_TEST8i8 = 2836, + X86_TEST8mi = 2837, + X86_TEST8mi_alt = 2838, + X86_TEST8mr = 2839, + X86_TEST8ri = 2840, + X86_TEST8ri_alt = 2841, + X86_TEST8rr = 2842, + X86_TPAUSE = 2843, + X86_TST_F = 2844, + X86_TST_Fp32 = 2845, + X86_TST_Fp64 = 2846, + X86_TST_Fp80 = 2847, + X86_TZCNT16rm = 2848, + X86_TZCNT16rr = 2849, + X86_TZCNT32rm = 2850, + X86_TZCNT32rr = 2851, + X86_TZCNT64rm = 2852, + X86_TZCNT64rr = 2853, + X86_TZMSK32rm = 2854, + X86_TZMSK32rr = 2855, + X86_TZMSK64rm = 2856, + X86_TZMSK64rr = 2857, + X86_UCOMISDrm = 2858, + X86_UCOMISDrm_Int = 2859, + X86_UCOMISDrr = 2860, + X86_UCOMISDrr_Int = 2861, + X86_UCOMISSrm = 2862, + X86_UCOMISSrm_Int = 2863, + X86_UCOMISSrr = 2864, + X86_UCOMISSrr_Int = 2865, + X86_UCOM_FIPr = 2866, + X86_UCOM_FIr = 2867, + X86_UCOM_FPPr = 2868, + X86_UCOM_FPr = 2869, + X86_UCOM_FpIr32 = 2870, + X86_UCOM_FpIr64 = 2871, + X86_UCOM_FpIr80 = 2872, + X86_UCOM_Fpr32 = 2873, + X86_UCOM_Fpr64 = 2874, + X86_UCOM_Fpr80 = 2875, + X86_UCOM_Fr = 2876, + X86_UD0 = 2877, + X86_UD1 = 2878, + X86_UD2 = 2879, + X86_UMONITOR16 = 2880, + X86_UMONITOR32 = 2881, + X86_UMONITOR64 = 2882, + X86_UMWAIT = 2883, + X86_UNPCKHPDrm = 2884, + X86_UNPCKHPDrr = 2885, + X86_UNPCKHPSrm = 2886, + X86_UNPCKHPSrr = 2887, + X86_UNPCKLPDrm = 2888, + X86_UNPCKLPDrr = 2889, + X86_UNPCKLPSrm = 2890, + X86_UNPCKLPSrr = 2891, + X86_V4FMADDPSrm = 2892, + X86_V4FMADDPSrmk = 2893, + X86_V4FMADDPSrmkz = 2894, + X86_V4FMADDSSrm = 2895, + X86_V4FMADDSSrmk = 2896, + X86_V4FMADDSSrmkz = 2897, + X86_V4FNMADDPSrm = 2898, + X86_V4FNMADDPSrmk = 2899, + X86_V4FNMADDPSrmkz = 2900, + X86_V4FNMADDSSrm = 2901, + X86_V4FNMADDSSrmk = 2902, + X86_V4FNMADDSSrmkz = 2903, + X86_VADDPDYrm = 2904, + X86_VADDPDYrr = 2905, + X86_VADDPDZ128rm = 2906, + X86_VADDPDZ128rmb = 2907, + X86_VADDPDZ128rmbk = 2908, + X86_VADDPDZ128rmbkz = 2909, + X86_VADDPDZ128rmk = 2910, + X86_VADDPDZ128rmkz = 2911, + X86_VADDPDZ128rr = 2912, + X86_VADDPDZ128rrk = 2913, + X86_VADDPDZ128rrkz = 2914, + X86_VADDPDZ256rm = 2915, + X86_VADDPDZ256rmb = 2916, + X86_VADDPDZ256rmbk = 2917, + X86_VADDPDZ256rmbkz = 2918, + X86_VADDPDZ256rmk = 2919, + X86_VADDPDZ256rmkz = 2920, + X86_VADDPDZ256rr = 2921, + X86_VADDPDZ256rrk = 2922, + X86_VADDPDZ256rrkz = 2923, + X86_VADDPDZrm = 2924, + X86_VADDPDZrmb = 2925, + X86_VADDPDZrmbk = 2926, + X86_VADDPDZrmbkz = 2927, + X86_VADDPDZrmk = 2928, + X86_VADDPDZrmkz = 2929, + X86_VADDPDZrr = 2930, + X86_VADDPDZrrb = 2931, + X86_VADDPDZrrbk = 2932, + X86_VADDPDZrrbkz = 2933, + X86_VADDPDZrrk = 2934, + X86_VADDPDZrrkz = 2935, + X86_VADDPDrm = 2936, + X86_VADDPDrr = 2937, + X86_VADDPSYrm = 2938, + X86_VADDPSYrr = 2939, + X86_VADDPSZ128rm = 2940, + X86_VADDPSZ128rmb = 2941, + X86_VADDPSZ128rmbk = 2942, + X86_VADDPSZ128rmbkz = 2943, + X86_VADDPSZ128rmk = 2944, + X86_VADDPSZ128rmkz = 2945, + X86_VADDPSZ128rr = 2946, + X86_VADDPSZ128rrk = 2947, + X86_VADDPSZ128rrkz = 2948, + X86_VADDPSZ256rm = 2949, + X86_VADDPSZ256rmb = 2950, + X86_VADDPSZ256rmbk = 2951, + X86_VADDPSZ256rmbkz = 2952, + X86_VADDPSZ256rmk = 2953, + X86_VADDPSZ256rmkz = 2954, + X86_VADDPSZ256rr = 2955, + X86_VADDPSZ256rrk = 2956, + X86_VADDPSZ256rrkz = 2957, + X86_VADDPSZrm = 2958, + X86_VADDPSZrmb = 2959, + X86_VADDPSZrmbk = 2960, + X86_VADDPSZrmbkz = 2961, + X86_VADDPSZrmk = 2962, + X86_VADDPSZrmkz = 2963, + X86_VADDPSZrr = 2964, + X86_VADDPSZrrb = 2965, + X86_VADDPSZrrbk = 2966, + X86_VADDPSZrrbkz = 2967, + X86_VADDPSZrrk = 2968, + X86_VADDPSZrrkz = 2969, + X86_VADDPSrm = 2970, + X86_VADDPSrr = 2971, + X86_VADDSDZrm = 2972, + X86_VADDSDZrm_Int = 2973, + X86_VADDSDZrm_Intk = 2974, + X86_VADDSDZrm_Intkz = 2975, + X86_VADDSDZrr = 2976, + X86_VADDSDZrr_Int = 2977, + X86_VADDSDZrr_Intk = 2978, + X86_VADDSDZrr_Intkz = 2979, + X86_VADDSDZrrb_Int = 2980, + X86_VADDSDZrrb_Intk = 2981, + X86_VADDSDZrrb_Intkz = 2982, + X86_VADDSDrm = 2983, + X86_VADDSDrm_Int = 2984, + X86_VADDSDrr = 2985, + X86_VADDSDrr_Int = 2986, + X86_VADDSSZrm = 2987, + X86_VADDSSZrm_Int = 2988, + X86_VADDSSZrm_Intk = 2989, + X86_VADDSSZrm_Intkz = 2990, + X86_VADDSSZrr = 2991, + X86_VADDSSZrr_Int = 2992, + X86_VADDSSZrr_Intk = 2993, + X86_VADDSSZrr_Intkz = 2994, + X86_VADDSSZrrb_Int = 2995, + X86_VADDSSZrrb_Intk = 2996, + X86_VADDSSZrrb_Intkz = 2997, + X86_VADDSSrm = 2998, + X86_VADDSSrm_Int = 2999, + X86_VADDSSrr = 3000, + X86_VADDSSrr_Int = 3001, + X86_VADDSUBPDYrm = 3002, + X86_VADDSUBPDYrr = 3003, + X86_VADDSUBPDrm = 3004, + X86_VADDSUBPDrr = 3005, + X86_VADDSUBPSYrm = 3006, + X86_VADDSUBPSYrr = 3007, + X86_VADDSUBPSrm = 3008, + X86_VADDSUBPSrr = 3009, + X86_VAESDECLASTYrm = 3010, + X86_VAESDECLASTYrr = 3011, + X86_VAESDECLASTZ128rm = 3012, + X86_VAESDECLASTZ128rr = 3013, + X86_VAESDECLASTZ256rm = 3014, + X86_VAESDECLASTZ256rr = 3015, + X86_VAESDECLASTZrm = 3016, + X86_VAESDECLASTZrr = 3017, + X86_VAESDECLASTrm = 3018, + X86_VAESDECLASTrr = 3019, + X86_VAESDECYrm = 3020, + X86_VAESDECYrr = 3021, + X86_VAESDECZ128rm = 3022, + X86_VAESDECZ128rr = 3023, + X86_VAESDECZ256rm = 3024, + X86_VAESDECZ256rr = 3025, + X86_VAESDECZrm = 3026, + X86_VAESDECZrr = 3027, + X86_VAESDECrm = 3028, + X86_VAESDECrr = 3029, + X86_VAESENCLASTYrm = 3030, + X86_VAESENCLASTYrr = 3031, + X86_VAESENCLASTZ128rm = 3032, + X86_VAESENCLASTZ128rr = 3033, + X86_VAESENCLASTZ256rm = 3034, + X86_VAESENCLASTZ256rr = 3035, + X86_VAESENCLASTZrm = 3036, + X86_VAESENCLASTZrr = 3037, + X86_VAESENCLASTrm = 3038, + X86_VAESENCLASTrr = 3039, + X86_VAESENCYrm = 3040, + X86_VAESENCYrr = 3041, + X86_VAESENCZ128rm = 3042, + X86_VAESENCZ128rr = 3043, + X86_VAESENCZ256rm = 3044, + X86_VAESENCZ256rr = 3045, + X86_VAESENCZrm = 3046, + X86_VAESENCZrr = 3047, + X86_VAESENCrm = 3048, + X86_VAESENCrr = 3049, + X86_VAESIMCrm = 3050, + X86_VAESIMCrr = 3051, + X86_VAESKEYGENASSIST128rm = 3052, + X86_VAESKEYGENASSIST128rr = 3053, + X86_VALIGNDZ128rmbi = 3054, + X86_VALIGNDZ128rmbik = 3055, + X86_VALIGNDZ128rmbikz = 3056, + X86_VALIGNDZ128rmi = 3057, + X86_VALIGNDZ128rmik = 3058, + X86_VALIGNDZ128rmikz = 3059, + X86_VALIGNDZ128rri = 3060, + X86_VALIGNDZ128rrik = 3061, + X86_VALIGNDZ128rrikz = 3062, + X86_VALIGNDZ256rmbi = 3063, + X86_VALIGNDZ256rmbik = 3064, + X86_VALIGNDZ256rmbikz = 3065, + X86_VALIGNDZ256rmi = 3066, + X86_VALIGNDZ256rmik = 3067, + X86_VALIGNDZ256rmikz = 3068, + X86_VALIGNDZ256rri = 3069, + X86_VALIGNDZ256rrik = 3070, + X86_VALIGNDZ256rrikz = 3071, + X86_VALIGNDZrmbi = 3072, + X86_VALIGNDZrmbik = 3073, + X86_VALIGNDZrmbikz = 3074, + X86_VALIGNDZrmi = 3075, + X86_VALIGNDZrmik = 3076, + X86_VALIGNDZrmikz = 3077, + X86_VALIGNDZrri = 3078, + X86_VALIGNDZrrik = 3079, + X86_VALIGNDZrrikz = 3080, + X86_VALIGNQZ128rmbi = 3081, + X86_VALIGNQZ128rmbik = 3082, + X86_VALIGNQZ128rmbikz = 3083, + X86_VALIGNQZ128rmi = 3084, + X86_VALIGNQZ128rmik = 3085, + X86_VALIGNQZ128rmikz = 3086, + X86_VALIGNQZ128rri = 3087, + X86_VALIGNQZ128rrik = 3088, + X86_VALIGNQZ128rrikz = 3089, + X86_VALIGNQZ256rmbi = 3090, + X86_VALIGNQZ256rmbik = 3091, + X86_VALIGNQZ256rmbikz = 3092, + X86_VALIGNQZ256rmi = 3093, + X86_VALIGNQZ256rmik = 3094, + X86_VALIGNQZ256rmikz = 3095, + X86_VALIGNQZ256rri = 3096, + X86_VALIGNQZ256rrik = 3097, + X86_VALIGNQZ256rrikz = 3098, + X86_VALIGNQZrmbi = 3099, + X86_VALIGNQZrmbik = 3100, + X86_VALIGNQZrmbikz = 3101, + X86_VALIGNQZrmi = 3102, + X86_VALIGNQZrmik = 3103, + X86_VALIGNQZrmikz = 3104, + X86_VALIGNQZrri = 3105, + X86_VALIGNQZrrik = 3106, + X86_VALIGNQZrrikz = 3107, + X86_VANDNPDYrm = 3108, + X86_VANDNPDYrr = 3109, + X86_VANDNPDZ128rm = 3110, + X86_VANDNPDZ128rmb = 3111, + X86_VANDNPDZ128rmbk = 3112, + X86_VANDNPDZ128rmbkz = 3113, + X86_VANDNPDZ128rmk = 3114, + X86_VANDNPDZ128rmkz = 3115, + X86_VANDNPDZ128rr = 3116, + X86_VANDNPDZ128rrk = 3117, + X86_VANDNPDZ128rrkz = 3118, + X86_VANDNPDZ256rm = 3119, + X86_VANDNPDZ256rmb = 3120, + X86_VANDNPDZ256rmbk = 3121, + X86_VANDNPDZ256rmbkz = 3122, + X86_VANDNPDZ256rmk = 3123, + X86_VANDNPDZ256rmkz = 3124, + X86_VANDNPDZ256rr = 3125, + X86_VANDNPDZ256rrk = 3126, + X86_VANDNPDZ256rrkz = 3127, + X86_VANDNPDZrm = 3128, + X86_VANDNPDZrmb = 3129, + X86_VANDNPDZrmbk = 3130, + X86_VANDNPDZrmbkz = 3131, + X86_VANDNPDZrmk = 3132, + X86_VANDNPDZrmkz = 3133, + X86_VANDNPDZrr = 3134, + X86_VANDNPDZrrk = 3135, + X86_VANDNPDZrrkz = 3136, + X86_VANDNPDrm = 3137, + X86_VANDNPDrr = 3138, + X86_VANDNPSYrm = 3139, + X86_VANDNPSYrr = 3140, + X86_VANDNPSZ128rm = 3141, + X86_VANDNPSZ128rmb = 3142, + X86_VANDNPSZ128rmbk = 3143, + X86_VANDNPSZ128rmbkz = 3144, + X86_VANDNPSZ128rmk = 3145, + X86_VANDNPSZ128rmkz = 3146, + X86_VANDNPSZ128rr = 3147, + X86_VANDNPSZ128rrk = 3148, + X86_VANDNPSZ128rrkz = 3149, + X86_VANDNPSZ256rm = 3150, + X86_VANDNPSZ256rmb = 3151, + X86_VANDNPSZ256rmbk = 3152, + X86_VANDNPSZ256rmbkz = 3153, + X86_VANDNPSZ256rmk = 3154, + X86_VANDNPSZ256rmkz = 3155, + X86_VANDNPSZ256rr = 3156, + X86_VANDNPSZ256rrk = 3157, + X86_VANDNPSZ256rrkz = 3158, + X86_VANDNPSZrm = 3159, + X86_VANDNPSZrmb = 3160, + X86_VANDNPSZrmbk = 3161, + X86_VANDNPSZrmbkz = 3162, + X86_VANDNPSZrmk = 3163, + X86_VANDNPSZrmkz = 3164, + X86_VANDNPSZrr = 3165, + X86_VANDNPSZrrk = 3166, + X86_VANDNPSZrrkz = 3167, + X86_VANDNPSrm = 3168, + X86_VANDNPSrr = 3169, + X86_VANDPDYrm = 3170, + X86_VANDPDYrr = 3171, + X86_VANDPDZ128rm = 3172, + X86_VANDPDZ128rmb = 3173, + X86_VANDPDZ128rmbk = 3174, + X86_VANDPDZ128rmbkz = 3175, + X86_VANDPDZ128rmk = 3176, + X86_VANDPDZ128rmkz = 3177, + X86_VANDPDZ128rr = 3178, + X86_VANDPDZ128rrk = 3179, + X86_VANDPDZ128rrkz = 3180, + X86_VANDPDZ256rm = 3181, + X86_VANDPDZ256rmb = 3182, + X86_VANDPDZ256rmbk = 3183, + X86_VANDPDZ256rmbkz = 3184, + X86_VANDPDZ256rmk = 3185, + X86_VANDPDZ256rmkz = 3186, + X86_VANDPDZ256rr = 3187, + X86_VANDPDZ256rrk = 3188, + X86_VANDPDZ256rrkz = 3189, + X86_VANDPDZrm = 3190, + X86_VANDPDZrmb = 3191, + X86_VANDPDZrmbk = 3192, + X86_VANDPDZrmbkz = 3193, + X86_VANDPDZrmk = 3194, + X86_VANDPDZrmkz = 3195, + X86_VANDPDZrr = 3196, + X86_VANDPDZrrk = 3197, + X86_VANDPDZrrkz = 3198, + X86_VANDPDrm = 3199, + X86_VANDPDrr = 3200, + X86_VANDPSYrm = 3201, + X86_VANDPSYrr = 3202, + X86_VANDPSZ128rm = 3203, + X86_VANDPSZ128rmb = 3204, + X86_VANDPSZ128rmbk = 3205, + X86_VANDPSZ128rmbkz = 3206, + X86_VANDPSZ128rmk = 3207, + X86_VANDPSZ128rmkz = 3208, + X86_VANDPSZ128rr = 3209, + X86_VANDPSZ128rrk = 3210, + X86_VANDPSZ128rrkz = 3211, + X86_VANDPSZ256rm = 3212, + X86_VANDPSZ256rmb = 3213, + X86_VANDPSZ256rmbk = 3214, + X86_VANDPSZ256rmbkz = 3215, + X86_VANDPSZ256rmk = 3216, + X86_VANDPSZ256rmkz = 3217, + X86_VANDPSZ256rr = 3218, + X86_VANDPSZ256rrk = 3219, + X86_VANDPSZ256rrkz = 3220, + X86_VANDPSZrm = 3221, + X86_VANDPSZrmb = 3222, + X86_VANDPSZrmbk = 3223, + X86_VANDPSZrmbkz = 3224, + X86_VANDPSZrmk = 3225, + X86_VANDPSZrmkz = 3226, + X86_VANDPSZrr = 3227, + X86_VANDPSZrrk = 3228, + X86_VANDPSZrrkz = 3229, + X86_VANDPSrm = 3230, + X86_VANDPSrr = 3231, + X86_VBLENDMPDZ128rm = 3232, + X86_VBLENDMPDZ128rmb = 3233, + X86_VBLENDMPDZ128rmbk = 3234, + X86_VBLENDMPDZ128rmbkz = 3235, + X86_VBLENDMPDZ128rmk = 3236, + X86_VBLENDMPDZ128rmkz = 3237, + X86_VBLENDMPDZ128rr = 3238, + X86_VBLENDMPDZ128rrk = 3239, + X86_VBLENDMPDZ128rrkz = 3240, + X86_VBLENDMPDZ256rm = 3241, + X86_VBLENDMPDZ256rmb = 3242, + X86_VBLENDMPDZ256rmbk = 3243, + X86_VBLENDMPDZ256rmbkz = 3244, + X86_VBLENDMPDZ256rmk = 3245, + X86_VBLENDMPDZ256rmkz = 3246, + X86_VBLENDMPDZ256rr = 3247, + X86_VBLENDMPDZ256rrk = 3248, + X86_VBLENDMPDZ256rrkz = 3249, + X86_VBLENDMPDZrm = 3250, + X86_VBLENDMPDZrmb = 3251, + X86_VBLENDMPDZrmbk = 3252, + X86_VBLENDMPDZrmbkz = 3253, + X86_VBLENDMPDZrmk = 3254, + X86_VBLENDMPDZrmkz = 3255, + X86_VBLENDMPDZrr = 3256, + X86_VBLENDMPDZrrk = 3257, + X86_VBLENDMPDZrrkz = 3258, + X86_VBLENDMPSZ128rm = 3259, + X86_VBLENDMPSZ128rmb = 3260, + X86_VBLENDMPSZ128rmbk = 3261, + X86_VBLENDMPSZ128rmbkz = 3262, + X86_VBLENDMPSZ128rmk = 3263, + X86_VBLENDMPSZ128rmkz = 3264, + X86_VBLENDMPSZ128rr = 3265, + X86_VBLENDMPSZ128rrk = 3266, + X86_VBLENDMPSZ128rrkz = 3267, + X86_VBLENDMPSZ256rm = 3268, + X86_VBLENDMPSZ256rmb = 3269, + X86_VBLENDMPSZ256rmbk = 3270, + X86_VBLENDMPSZ256rmbkz = 3271, + X86_VBLENDMPSZ256rmk = 3272, + X86_VBLENDMPSZ256rmkz = 3273, + X86_VBLENDMPSZ256rr = 3274, + X86_VBLENDMPSZ256rrk = 3275, + X86_VBLENDMPSZ256rrkz = 3276, + X86_VBLENDMPSZrm = 3277, + X86_VBLENDMPSZrmb = 3278, + X86_VBLENDMPSZrmbk = 3279, + X86_VBLENDMPSZrmbkz = 3280, + X86_VBLENDMPSZrmk = 3281, + X86_VBLENDMPSZrmkz = 3282, + X86_VBLENDMPSZrr = 3283, + X86_VBLENDMPSZrrk = 3284, + X86_VBLENDMPSZrrkz = 3285, + X86_VBLENDPDYrmi = 3286, + X86_VBLENDPDYrri = 3287, + X86_VBLENDPDrmi = 3288, + X86_VBLENDPDrri = 3289, + X86_VBLENDPSYrmi = 3290, + X86_VBLENDPSYrri = 3291, + X86_VBLENDPSrmi = 3292, + X86_VBLENDPSrri = 3293, + X86_VBLENDVPDYrm = 3294, + X86_VBLENDVPDYrr = 3295, + X86_VBLENDVPDrm = 3296, + X86_VBLENDVPDrr = 3297, + X86_VBLENDVPSYrm = 3298, + X86_VBLENDVPSYrr = 3299, + X86_VBLENDVPSrm = 3300, + X86_VBLENDVPSrr = 3301, + X86_VBROADCASTF128 = 3302, + X86_VBROADCASTF32X2Z256m = 3303, + X86_VBROADCASTF32X2Z256mk = 3304, + X86_VBROADCASTF32X2Z256mkz = 3305, + X86_VBROADCASTF32X2Z256r = 3306, + X86_VBROADCASTF32X2Z256rk = 3307, + X86_VBROADCASTF32X2Z256rkz = 3308, + X86_VBROADCASTF32X2Zm = 3309, + X86_VBROADCASTF32X2Zmk = 3310, + X86_VBROADCASTF32X2Zmkz = 3311, + X86_VBROADCASTF32X2Zr = 3312, + X86_VBROADCASTF32X2Zrk = 3313, + X86_VBROADCASTF32X2Zrkz = 3314, + X86_VBROADCASTF32X4Z256rm = 3315, + X86_VBROADCASTF32X4Z256rmk = 3316, + X86_VBROADCASTF32X4Z256rmkz = 3317, + X86_VBROADCASTF32X4rm = 3318, + X86_VBROADCASTF32X4rmk = 3319, + X86_VBROADCASTF32X4rmkz = 3320, + X86_VBROADCASTF32X8rm = 3321, + X86_VBROADCASTF32X8rmk = 3322, + X86_VBROADCASTF32X8rmkz = 3323, + X86_VBROADCASTF64X2Z128rm = 3324, + X86_VBROADCASTF64X2Z128rmk = 3325, + X86_VBROADCASTF64X2Z128rmkz = 3326, + X86_VBROADCASTF64X2rm = 3327, + X86_VBROADCASTF64X2rmk = 3328, + X86_VBROADCASTF64X2rmkz = 3329, + X86_VBROADCASTF64X4rm = 3330, + X86_VBROADCASTF64X4rmk = 3331, + X86_VBROADCASTF64X4rmkz = 3332, + X86_VBROADCASTI128 = 3333, + X86_VBROADCASTI32X2Z128m = 3334, + X86_VBROADCASTI32X2Z128mk = 3335, + X86_VBROADCASTI32X2Z128mkz = 3336, + X86_VBROADCASTI32X2Z128r = 3337, + X86_VBROADCASTI32X2Z128rk = 3338, + X86_VBROADCASTI32X2Z128rkz = 3339, + X86_VBROADCASTI32X2Z256m = 3340, + X86_VBROADCASTI32X2Z256mk = 3341, + X86_VBROADCASTI32X2Z256mkz = 3342, + X86_VBROADCASTI32X2Z256r = 3343, + X86_VBROADCASTI32X2Z256rk = 3344, + X86_VBROADCASTI32X2Z256rkz = 3345, + X86_VBROADCASTI32X2Zm = 3346, + X86_VBROADCASTI32X2Zmk = 3347, + X86_VBROADCASTI32X2Zmkz = 3348, + X86_VBROADCASTI32X2Zr = 3349, + X86_VBROADCASTI32X2Zrk = 3350, + X86_VBROADCASTI32X2Zrkz = 3351, + X86_VBROADCASTI32X4Z256rm = 3352, + X86_VBROADCASTI32X4Z256rmk = 3353, + X86_VBROADCASTI32X4Z256rmkz = 3354, + X86_VBROADCASTI32X4rm = 3355, + X86_VBROADCASTI32X4rmk = 3356, + X86_VBROADCASTI32X4rmkz = 3357, + X86_VBROADCASTI32X8rm = 3358, + X86_VBROADCASTI32X8rmk = 3359, + X86_VBROADCASTI32X8rmkz = 3360, + X86_VBROADCASTI64X2Z128rm = 3361, + X86_VBROADCASTI64X2Z128rmk = 3362, + X86_VBROADCASTI64X2Z128rmkz = 3363, + X86_VBROADCASTI64X2rm = 3364, + X86_VBROADCASTI64X2rmk = 3365, + X86_VBROADCASTI64X2rmkz = 3366, + X86_VBROADCASTI64X4rm = 3367, + X86_VBROADCASTI64X4rmk = 3368, + X86_VBROADCASTI64X4rmkz = 3369, + X86_VBROADCASTSDYrm = 3370, + X86_VBROADCASTSDYrr = 3371, + X86_VBROADCASTSDZ256m = 3372, + X86_VBROADCASTSDZ256mk = 3373, + X86_VBROADCASTSDZ256mkz = 3374, + X86_VBROADCASTSDZ256r = 3375, + X86_VBROADCASTSDZ256rk = 3376, + X86_VBROADCASTSDZ256rkz = 3377, + X86_VBROADCASTSDZm = 3378, + X86_VBROADCASTSDZmk = 3379, + X86_VBROADCASTSDZmkz = 3380, + X86_VBROADCASTSDZr = 3381, + X86_VBROADCASTSDZrk = 3382, + X86_VBROADCASTSDZrkz = 3383, + X86_VBROADCASTSSYrm = 3384, + X86_VBROADCASTSSYrr = 3385, + X86_VBROADCASTSSZ128m = 3386, + X86_VBROADCASTSSZ128mk = 3387, + X86_VBROADCASTSSZ128mkz = 3388, + X86_VBROADCASTSSZ128r = 3389, + X86_VBROADCASTSSZ128rk = 3390, + X86_VBROADCASTSSZ128rkz = 3391, + X86_VBROADCASTSSZ256m = 3392, + X86_VBROADCASTSSZ256mk = 3393, + X86_VBROADCASTSSZ256mkz = 3394, + X86_VBROADCASTSSZ256r = 3395, + X86_VBROADCASTSSZ256rk = 3396, + X86_VBROADCASTSSZ256rkz = 3397, + X86_VBROADCASTSSZm = 3398, + X86_VBROADCASTSSZmk = 3399, + X86_VBROADCASTSSZmkz = 3400, + X86_VBROADCASTSSZr = 3401, + X86_VBROADCASTSSZrk = 3402, + X86_VBROADCASTSSZrkz = 3403, + X86_VBROADCASTSSrm = 3404, + X86_VBROADCASTSSrr = 3405, + X86_VCMPPDYrmi = 3406, + X86_VCMPPDYrmi_alt = 3407, + X86_VCMPPDYrri = 3408, + X86_VCMPPDYrri_alt = 3409, + X86_VCMPPDZ128rmbi = 3410, + X86_VCMPPDZ128rmbi_alt = 3411, + X86_VCMPPDZ128rmbi_altk = 3412, + X86_VCMPPDZ128rmbik = 3413, + X86_VCMPPDZ128rmi = 3414, + X86_VCMPPDZ128rmi_alt = 3415, + X86_VCMPPDZ128rmi_altk = 3416, + X86_VCMPPDZ128rmik = 3417, + X86_VCMPPDZ128rri = 3418, + X86_VCMPPDZ128rri_alt = 3419, + X86_VCMPPDZ128rri_altk = 3420, + X86_VCMPPDZ128rrik = 3421, + X86_VCMPPDZ256rmbi = 3422, + X86_VCMPPDZ256rmbi_alt = 3423, + X86_VCMPPDZ256rmbi_altk = 3424, + X86_VCMPPDZ256rmbik = 3425, + X86_VCMPPDZ256rmi = 3426, + X86_VCMPPDZ256rmi_alt = 3427, + X86_VCMPPDZ256rmi_altk = 3428, + X86_VCMPPDZ256rmik = 3429, + X86_VCMPPDZ256rri = 3430, + X86_VCMPPDZ256rri_alt = 3431, + X86_VCMPPDZ256rri_altk = 3432, + X86_VCMPPDZ256rrik = 3433, + X86_VCMPPDZrmbi = 3434, + X86_VCMPPDZrmbi_alt = 3435, + X86_VCMPPDZrmbi_altk = 3436, + X86_VCMPPDZrmbik = 3437, + X86_VCMPPDZrmi = 3438, + X86_VCMPPDZrmi_alt = 3439, + X86_VCMPPDZrmi_altk = 3440, + X86_VCMPPDZrmik = 3441, + X86_VCMPPDZrri = 3442, + X86_VCMPPDZrri_alt = 3443, + X86_VCMPPDZrri_altk = 3444, + X86_VCMPPDZrrib = 3445, + X86_VCMPPDZrrib_alt = 3446, + X86_VCMPPDZrrib_altk = 3447, + X86_VCMPPDZrribk = 3448, + X86_VCMPPDZrrik = 3449, + X86_VCMPPDrmi = 3450, + X86_VCMPPDrmi_alt = 3451, + X86_VCMPPDrri = 3452, + X86_VCMPPDrri_alt = 3453, + X86_VCMPPSYrmi = 3454, + X86_VCMPPSYrmi_alt = 3455, + X86_VCMPPSYrri = 3456, + X86_VCMPPSYrri_alt = 3457, + X86_VCMPPSZ128rmbi = 3458, + X86_VCMPPSZ128rmbi_alt = 3459, + X86_VCMPPSZ128rmbi_altk = 3460, + X86_VCMPPSZ128rmbik = 3461, + X86_VCMPPSZ128rmi = 3462, + X86_VCMPPSZ128rmi_alt = 3463, + X86_VCMPPSZ128rmi_altk = 3464, + X86_VCMPPSZ128rmik = 3465, + X86_VCMPPSZ128rri = 3466, + X86_VCMPPSZ128rri_alt = 3467, + X86_VCMPPSZ128rri_altk = 3468, + X86_VCMPPSZ128rrik = 3469, + X86_VCMPPSZ256rmbi = 3470, + X86_VCMPPSZ256rmbi_alt = 3471, + X86_VCMPPSZ256rmbi_altk = 3472, + X86_VCMPPSZ256rmbik = 3473, + X86_VCMPPSZ256rmi = 3474, + X86_VCMPPSZ256rmi_alt = 3475, + X86_VCMPPSZ256rmi_altk = 3476, + X86_VCMPPSZ256rmik = 3477, + X86_VCMPPSZ256rri = 3478, + X86_VCMPPSZ256rri_alt = 3479, + X86_VCMPPSZ256rri_altk = 3480, + X86_VCMPPSZ256rrik = 3481, + X86_VCMPPSZrmbi = 3482, + X86_VCMPPSZrmbi_alt = 3483, + X86_VCMPPSZrmbi_altk = 3484, + X86_VCMPPSZrmbik = 3485, + X86_VCMPPSZrmi = 3486, + X86_VCMPPSZrmi_alt = 3487, + X86_VCMPPSZrmi_altk = 3488, + X86_VCMPPSZrmik = 3489, + X86_VCMPPSZrri = 3490, + X86_VCMPPSZrri_alt = 3491, + X86_VCMPPSZrri_altk = 3492, + X86_VCMPPSZrrib = 3493, + X86_VCMPPSZrrib_alt = 3494, + X86_VCMPPSZrrib_altk = 3495, + X86_VCMPPSZrribk = 3496, + X86_VCMPPSZrrik = 3497, + X86_VCMPPSrmi = 3498, + X86_VCMPPSrmi_alt = 3499, + X86_VCMPPSrri = 3500, + X86_VCMPPSrri_alt = 3501, + X86_VCMPSDZrm = 3502, + X86_VCMPSDZrm_Int = 3503, + X86_VCMPSDZrm_Intk = 3504, + X86_VCMPSDZrmi_alt = 3505, + X86_VCMPSDZrmi_altk = 3506, + X86_VCMPSDZrr = 3507, + X86_VCMPSDZrr_Int = 3508, + X86_VCMPSDZrr_Intk = 3509, + X86_VCMPSDZrrb_Int = 3510, + X86_VCMPSDZrrb_Intk = 3511, + X86_VCMPSDZrrb_alt = 3512, + X86_VCMPSDZrrb_altk = 3513, + X86_VCMPSDZrri_alt = 3514, + X86_VCMPSDZrri_altk = 3515, + X86_VCMPSDrm = 3516, + X86_VCMPSDrm_Int = 3517, + X86_VCMPSDrm_alt = 3518, + X86_VCMPSDrr = 3519, + X86_VCMPSDrr_Int = 3520, + X86_VCMPSDrr_alt = 3521, + X86_VCMPSSZrm = 3522, + X86_VCMPSSZrm_Int = 3523, + X86_VCMPSSZrm_Intk = 3524, + X86_VCMPSSZrmi_alt = 3525, + X86_VCMPSSZrmi_altk = 3526, + X86_VCMPSSZrr = 3527, + X86_VCMPSSZrr_Int = 3528, + X86_VCMPSSZrr_Intk = 3529, + X86_VCMPSSZrrb_Int = 3530, + X86_VCMPSSZrrb_Intk = 3531, + X86_VCMPSSZrrb_alt = 3532, + X86_VCMPSSZrrb_altk = 3533, + X86_VCMPSSZrri_alt = 3534, + X86_VCMPSSZrri_altk = 3535, + X86_VCMPSSrm = 3536, + X86_VCMPSSrm_Int = 3537, + X86_VCMPSSrm_alt = 3538, + X86_VCMPSSrr = 3539, + X86_VCMPSSrr_Int = 3540, + X86_VCMPSSrr_alt = 3541, + X86_VCOMISDZrm = 3542, + X86_VCOMISDZrm_Int = 3543, + X86_VCOMISDZrr = 3544, + X86_VCOMISDZrr_Int = 3545, + X86_VCOMISDZrrb = 3546, + X86_VCOMISDrm = 3547, + X86_VCOMISDrm_Int = 3548, + X86_VCOMISDrr = 3549, + X86_VCOMISDrr_Int = 3550, + X86_VCOMISSZrm = 3551, + X86_VCOMISSZrm_Int = 3552, + X86_VCOMISSZrr = 3553, + X86_VCOMISSZrr_Int = 3554, + X86_VCOMISSZrrb = 3555, + X86_VCOMISSrm = 3556, + X86_VCOMISSrm_Int = 3557, + X86_VCOMISSrr = 3558, + X86_VCOMISSrr_Int = 3559, + X86_VCOMPRESSPDZ128mr = 3560, + X86_VCOMPRESSPDZ128mrk = 3561, + X86_VCOMPRESSPDZ128rr = 3562, + X86_VCOMPRESSPDZ128rrk = 3563, + X86_VCOMPRESSPDZ128rrkz = 3564, + X86_VCOMPRESSPDZ256mr = 3565, + X86_VCOMPRESSPDZ256mrk = 3566, + X86_VCOMPRESSPDZ256rr = 3567, + X86_VCOMPRESSPDZ256rrk = 3568, + X86_VCOMPRESSPDZ256rrkz = 3569, + X86_VCOMPRESSPDZmr = 3570, + X86_VCOMPRESSPDZmrk = 3571, + X86_VCOMPRESSPDZrr = 3572, + X86_VCOMPRESSPDZrrk = 3573, + X86_VCOMPRESSPDZrrkz = 3574, + X86_VCOMPRESSPSZ128mr = 3575, + X86_VCOMPRESSPSZ128mrk = 3576, + X86_VCOMPRESSPSZ128rr = 3577, + X86_VCOMPRESSPSZ128rrk = 3578, + X86_VCOMPRESSPSZ128rrkz = 3579, + X86_VCOMPRESSPSZ256mr = 3580, + X86_VCOMPRESSPSZ256mrk = 3581, + X86_VCOMPRESSPSZ256rr = 3582, + X86_VCOMPRESSPSZ256rrk = 3583, + X86_VCOMPRESSPSZ256rrkz = 3584, + X86_VCOMPRESSPSZmr = 3585, + X86_VCOMPRESSPSZmrk = 3586, + X86_VCOMPRESSPSZrr = 3587, + X86_VCOMPRESSPSZrrk = 3588, + X86_VCOMPRESSPSZrrkz = 3589, + X86_VCVTDQ2PDYrm = 3590, + X86_VCVTDQ2PDYrr = 3591, + X86_VCVTDQ2PDZ128rm = 3592, + X86_VCVTDQ2PDZ128rmb = 3593, + X86_VCVTDQ2PDZ128rmbk = 3594, + X86_VCVTDQ2PDZ128rmbkz = 3595, + X86_VCVTDQ2PDZ128rmk = 3596, + X86_VCVTDQ2PDZ128rmkz = 3597, + X86_VCVTDQ2PDZ128rr = 3598, + X86_VCVTDQ2PDZ128rrk = 3599, + X86_VCVTDQ2PDZ128rrkz = 3600, + X86_VCVTDQ2PDZ256rm = 3601, + X86_VCVTDQ2PDZ256rmb = 3602, + X86_VCVTDQ2PDZ256rmbk = 3603, + X86_VCVTDQ2PDZ256rmbkz = 3604, + X86_VCVTDQ2PDZ256rmk = 3605, + X86_VCVTDQ2PDZ256rmkz = 3606, + X86_VCVTDQ2PDZ256rr = 3607, + X86_VCVTDQ2PDZ256rrk = 3608, + X86_VCVTDQ2PDZ256rrkz = 3609, + X86_VCVTDQ2PDZrm = 3610, + X86_VCVTDQ2PDZrmb = 3611, + X86_VCVTDQ2PDZrmbk = 3612, + X86_VCVTDQ2PDZrmbkz = 3613, + X86_VCVTDQ2PDZrmk = 3614, + X86_VCVTDQ2PDZrmkz = 3615, + X86_VCVTDQ2PDZrr = 3616, + X86_VCVTDQ2PDZrrk = 3617, + X86_VCVTDQ2PDZrrkz = 3618, + X86_VCVTDQ2PDrm = 3619, + X86_VCVTDQ2PDrr = 3620, + X86_VCVTDQ2PSYrm = 3621, + X86_VCVTDQ2PSYrr = 3622, + X86_VCVTDQ2PSZ128rm = 3623, + X86_VCVTDQ2PSZ128rmb = 3624, + X86_VCVTDQ2PSZ128rmbk = 3625, + X86_VCVTDQ2PSZ128rmbkz = 3626, + X86_VCVTDQ2PSZ128rmk = 3627, + X86_VCVTDQ2PSZ128rmkz = 3628, + X86_VCVTDQ2PSZ128rr = 3629, + X86_VCVTDQ2PSZ128rrk = 3630, + X86_VCVTDQ2PSZ128rrkz = 3631, + X86_VCVTDQ2PSZ256rm = 3632, + X86_VCVTDQ2PSZ256rmb = 3633, + X86_VCVTDQ2PSZ256rmbk = 3634, + X86_VCVTDQ2PSZ256rmbkz = 3635, + X86_VCVTDQ2PSZ256rmk = 3636, + X86_VCVTDQ2PSZ256rmkz = 3637, + X86_VCVTDQ2PSZ256rr = 3638, + X86_VCVTDQ2PSZ256rrk = 3639, + X86_VCVTDQ2PSZ256rrkz = 3640, + X86_VCVTDQ2PSZrm = 3641, + X86_VCVTDQ2PSZrmb = 3642, + X86_VCVTDQ2PSZrmbk = 3643, + X86_VCVTDQ2PSZrmbkz = 3644, + X86_VCVTDQ2PSZrmk = 3645, + X86_VCVTDQ2PSZrmkz = 3646, + X86_VCVTDQ2PSZrr = 3647, + X86_VCVTDQ2PSZrrb = 3648, + X86_VCVTDQ2PSZrrbk = 3649, + X86_VCVTDQ2PSZrrbkz = 3650, + X86_VCVTDQ2PSZrrk = 3651, + X86_VCVTDQ2PSZrrkz = 3652, + X86_VCVTDQ2PSrm = 3653, + X86_VCVTDQ2PSrr = 3654, + X86_VCVTPD2DQYrm = 3655, + X86_VCVTPD2DQYrr = 3656, + X86_VCVTPD2DQZ128rm = 3657, + X86_VCVTPD2DQZ128rmb = 3658, + X86_VCVTPD2DQZ128rmbk = 3659, + X86_VCVTPD2DQZ128rmbkz = 3660, + X86_VCVTPD2DQZ128rmk = 3661, + X86_VCVTPD2DQZ128rmkz = 3662, + X86_VCVTPD2DQZ128rr = 3663, + X86_VCVTPD2DQZ128rrk = 3664, + X86_VCVTPD2DQZ128rrkz = 3665, + X86_VCVTPD2DQZ256rm = 3666, + X86_VCVTPD2DQZ256rmb = 3667, + X86_VCVTPD2DQZ256rmbk = 3668, + X86_VCVTPD2DQZ256rmbkz = 3669, + X86_VCVTPD2DQZ256rmk = 3670, + X86_VCVTPD2DQZ256rmkz = 3671, + X86_VCVTPD2DQZ256rr = 3672, + X86_VCVTPD2DQZ256rrk = 3673, + X86_VCVTPD2DQZ256rrkz = 3674, + X86_VCVTPD2DQZrm = 3675, + X86_VCVTPD2DQZrmb = 3676, + X86_VCVTPD2DQZrmbk = 3677, + X86_VCVTPD2DQZrmbkz = 3678, + X86_VCVTPD2DQZrmk = 3679, + X86_VCVTPD2DQZrmkz = 3680, + X86_VCVTPD2DQZrr = 3681, + X86_VCVTPD2DQZrrb = 3682, + X86_VCVTPD2DQZrrbk = 3683, + X86_VCVTPD2DQZrrbkz = 3684, + X86_VCVTPD2DQZrrk = 3685, + X86_VCVTPD2DQZrrkz = 3686, + X86_VCVTPD2DQrm = 3687, + X86_VCVTPD2DQrr = 3688, + X86_VCVTPD2PSYrm = 3689, + X86_VCVTPD2PSYrr = 3690, + X86_VCVTPD2PSZ128rm = 3691, + X86_VCVTPD2PSZ128rmb = 3692, + X86_VCVTPD2PSZ128rmbk = 3693, + X86_VCVTPD2PSZ128rmbkz = 3694, + X86_VCVTPD2PSZ128rmk = 3695, + X86_VCVTPD2PSZ128rmkz = 3696, + X86_VCVTPD2PSZ128rr = 3697, + X86_VCVTPD2PSZ128rrk = 3698, + X86_VCVTPD2PSZ128rrkz = 3699, + X86_VCVTPD2PSZ256rm = 3700, + X86_VCVTPD2PSZ256rmb = 3701, + X86_VCVTPD2PSZ256rmbk = 3702, + X86_VCVTPD2PSZ256rmbkz = 3703, + X86_VCVTPD2PSZ256rmk = 3704, + X86_VCVTPD2PSZ256rmkz = 3705, + X86_VCVTPD2PSZ256rr = 3706, + X86_VCVTPD2PSZ256rrk = 3707, + X86_VCVTPD2PSZ256rrkz = 3708, + X86_VCVTPD2PSZrm = 3709, + X86_VCVTPD2PSZrmb = 3710, + X86_VCVTPD2PSZrmbk = 3711, + X86_VCVTPD2PSZrmbkz = 3712, + X86_VCVTPD2PSZrmk = 3713, + X86_VCVTPD2PSZrmkz = 3714, + X86_VCVTPD2PSZrr = 3715, + X86_VCVTPD2PSZrrb = 3716, + X86_VCVTPD2PSZrrbk = 3717, + X86_VCVTPD2PSZrrbkz = 3718, + X86_VCVTPD2PSZrrk = 3719, + X86_VCVTPD2PSZrrkz = 3720, + X86_VCVTPD2PSrm = 3721, + X86_VCVTPD2PSrr = 3722, + X86_VCVTPD2QQZ128rm = 3723, + X86_VCVTPD2QQZ128rmb = 3724, + X86_VCVTPD2QQZ128rmbk = 3725, + X86_VCVTPD2QQZ128rmbkz = 3726, + X86_VCVTPD2QQZ128rmk = 3727, + X86_VCVTPD2QQZ128rmkz = 3728, + X86_VCVTPD2QQZ128rr = 3729, + X86_VCVTPD2QQZ128rrk = 3730, + X86_VCVTPD2QQZ128rrkz = 3731, + X86_VCVTPD2QQZ256rm = 3732, + X86_VCVTPD2QQZ256rmb = 3733, + X86_VCVTPD2QQZ256rmbk = 3734, + X86_VCVTPD2QQZ256rmbkz = 3735, + X86_VCVTPD2QQZ256rmk = 3736, + X86_VCVTPD2QQZ256rmkz = 3737, + X86_VCVTPD2QQZ256rr = 3738, + X86_VCVTPD2QQZ256rrk = 3739, + X86_VCVTPD2QQZ256rrkz = 3740, + X86_VCVTPD2QQZrm = 3741, + X86_VCVTPD2QQZrmb = 3742, + X86_VCVTPD2QQZrmbk = 3743, + X86_VCVTPD2QQZrmbkz = 3744, + X86_VCVTPD2QQZrmk = 3745, + X86_VCVTPD2QQZrmkz = 3746, + X86_VCVTPD2QQZrr = 3747, + X86_VCVTPD2QQZrrb = 3748, + X86_VCVTPD2QQZrrbk = 3749, + X86_VCVTPD2QQZrrbkz = 3750, + X86_VCVTPD2QQZrrk = 3751, + X86_VCVTPD2QQZrrkz = 3752, + X86_VCVTPD2UDQZ128rm = 3753, + X86_VCVTPD2UDQZ128rmb = 3754, + X86_VCVTPD2UDQZ128rmbk = 3755, + X86_VCVTPD2UDQZ128rmbkz = 3756, + X86_VCVTPD2UDQZ128rmk = 3757, + X86_VCVTPD2UDQZ128rmkz = 3758, + X86_VCVTPD2UDQZ128rr = 3759, + X86_VCVTPD2UDQZ128rrk = 3760, + X86_VCVTPD2UDQZ128rrkz = 3761, + X86_VCVTPD2UDQZ256rm = 3762, + X86_VCVTPD2UDQZ256rmb = 3763, + X86_VCVTPD2UDQZ256rmbk = 3764, + X86_VCVTPD2UDQZ256rmbkz = 3765, + X86_VCVTPD2UDQZ256rmk = 3766, + X86_VCVTPD2UDQZ256rmkz = 3767, + X86_VCVTPD2UDQZ256rr = 3768, + X86_VCVTPD2UDQZ256rrk = 3769, + X86_VCVTPD2UDQZ256rrkz = 3770, + X86_VCVTPD2UDQZrm = 3771, + X86_VCVTPD2UDQZrmb = 3772, + X86_VCVTPD2UDQZrmbk = 3773, + X86_VCVTPD2UDQZrmbkz = 3774, + X86_VCVTPD2UDQZrmk = 3775, + X86_VCVTPD2UDQZrmkz = 3776, + X86_VCVTPD2UDQZrr = 3777, + X86_VCVTPD2UDQZrrb = 3778, + X86_VCVTPD2UDQZrrbk = 3779, + X86_VCVTPD2UDQZrrbkz = 3780, + X86_VCVTPD2UDQZrrk = 3781, + X86_VCVTPD2UDQZrrkz = 3782, + X86_VCVTPD2UQQZ128rm = 3783, + X86_VCVTPD2UQQZ128rmb = 3784, + X86_VCVTPD2UQQZ128rmbk = 3785, + X86_VCVTPD2UQQZ128rmbkz = 3786, + X86_VCVTPD2UQQZ128rmk = 3787, + X86_VCVTPD2UQQZ128rmkz = 3788, + X86_VCVTPD2UQQZ128rr = 3789, + X86_VCVTPD2UQQZ128rrk = 3790, + X86_VCVTPD2UQQZ128rrkz = 3791, + X86_VCVTPD2UQQZ256rm = 3792, + X86_VCVTPD2UQQZ256rmb = 3793, + X86_VCVTPD2UQQZ256rmbk = 3794, + X86_VCVTPD2UQQZ256rmbkz = 3795, + X86_VCVTPD2UQQZ256rmk = 3796, + X86_VCVTPD2UQQZ256rmkz = 3797, + X86_VCVTPD2UQQZ256rr = 3798, + X86_VCVTPD2UQQZ256rrk = 3799, + X86_VCVTPD2UQQZ256rrkz = 3800, + X86_VCVTPD2UQQZrm = 3801, + X86_VCVTPD2UQQZrmb = 3802, + X86_VCVTPD2UQQZrmbk = 3803, + X86_VCVTPD2UQQZrmbkz = 3804, + X86_VCVTPD2UQQZrmk = 3805, + X86_VCVTPD2UQQZrmkz = 3806, + X86_VCVTPD2UQQZrr = 3807, + X86_VCVTPD2UQQZrrb = 3808, + X86_VCVTPD2UQQZrrbk = 3809, + X86_VCVTPD2UQQZrrbkz = 3810, + X86_VCVTPD2UQQZrrk = 3811, + X86_VCVTPD2UQQZrrkz = 3812, + X86_VCVTPH2PSYrm = 3813, + X86_VCVTPH2PSYrr = 3814, + X86_VCVTPH2PSZ128rm = 3815, + X86_VCVTPH2PSZ128rmk = 3816, + X86_VCVTPH2PSZ128rmkz = 3817, + X86_VCVTPH2PSZ128rr = 3818, + X86_VCVTPH2PSZ128rrk = 3819, + X86_VCVTPH2PSZ128rrkz = 3820, + X86_VCVTPH2PSZ256rm = 3821, + X86_VCVTPH2PSZ256rmk = 3822, + X86_VCVTPH2PSZ256rmkz = 3823, + X86_VCVTPH2PSZ256rr = 3824, + X86_VCVTPH2PSZ256rrk = 3825, + X86_VCVTPH2PSZ256rrkz = 3826, + X86_VCVTPH2PSZrm = 3827, + X86_VCVTPH2PSZrmk = 3828, + X86_VCVTPH2PSZrmkz = 3829, + X86_VCVTPH2PSZrr = 3830, + X86_VCVTPH2PSZrrb = 3831, + X86_VCVTPH2PSZrrbk = 3832, + X86_VCVTPH2PSZrrbkz = 3833, + X86_VCVTPH2PSZrrk = 3834, + X86_VCVTPH2PSZrrkz = 3835, + X86_VCVTPH2PSrm = 3836, + X86_VCVTPH2PSrr = 3837, + X86_VCVTPS2DQYrm = 3838, + X86_VCVTPS2DQYrr = 3839, + X86_VCVTPS2DQZ128rm = 3840, + X86_VCVTPS2DQZ128rmb = 3841, + X86_VCVTPS2DQZ128rmbk = 3842, + X86_VCVTPS2DQZ128rmbkz = 3843, + X86_VCVTPS2DQZ128rmk = 3844, + X86_VCVTPS2DQZ128rmkz = 3845, + X86_VCVTPS2DQZ128rr = 3846, + X86_VCVTPS2DQZ128rrk = 3847, + X86_VCVTPS2DQZ128rrkz = 3848, + X86_VCVTPS2DQZ256rm = 3849, + X86_VCVTPS2DQZ256rmb = 3850, + X86_VCVTPS2DQZ256rmbk = 3851, + X86_VCVTPS2DQZ256rmbkz = 3852, + X86_VCVTPS2DQZ256rmk = 3853, + X86_VCVTPS2DQZ256rmkz = 3854, + X86_VCVTPS2DQZ256rr = 3855, + X86_VCVTPS2DQZ256rrk = 3856, + X86_VCVTPS2DQZ256rrkz = 3857, + X86_VCVTPS2DQZrm = 3858, + X86_VCVTPS2DQZrmb = 3859, + X86_VCVTPS2DQZrmbk = 3860, + X86_VCVTPS2DQZrmbkz = 3861, + X86_VCVTPS2DQZrmk = 3862, + X86_VCVTPS2DQZrmkz = 3863, + X86_VCVTPS2DQZrr = 3864, + X86_VCVTPS2DQZrrb = 3865, + X86_VCVTPS2DQZrrbk = 3866, + X86_VCVTPS2DQZrrbkz = 3867, + X86_VCVTPS2DQZrrk = 3868, + X86_VCVTPS2DQZrrkz = 3869, + X86_VCVTPS2DQrm = 3870, + X86_VCVTPS2DQrr = 3871, + X86_VCVTPS2PDYrm = 3872, + X86_VCVTPS2PDYrr = 3873, + X86_VCVTPS2PDZ128rm = 3874, + X86_VCVTPS2PDZ128rmb = 3875, + X86_VCVTPS2PDZ128rmbk = 3876, + X86_VCVTPS2PDZ128rmbkz = 3877, + X86_VCVTPS2PDZ128rmk = 3878, + X86_VCVTPS2PDZ128rmkz = 3879, + X86_VCVTPS2PDZ128rr = 3880, + X86_VCVTPS2PDZ128rrk = 3881, + X86_VCVTPS2PDZ128rrkz = 3882, + X86_VCVTPS2PDZ256rm = 3883, + X86_VCVTPS2PDZ256rmb = 3884, + X86_VCVTPS2PDZ256rmbk = 3885, + X86_VCVTPS2PDZ256rmbkz = 3886, + X86_VCVTPS2PDZ256rmk = 3887, + X86_VCVTPS2PDZ256rmkz = 3888, + X86_VCVTPS2PDZ256rr = 3889, + X86_VCVTPS2PDZ256rrk = 3890, + X86_VCVTPS2PDZ256rrkz = 3891, + X86_VCVTPS2PDZrm = 3892, + X86_VCVTPS2PDZrmb = 3893, + X86_VCVTPS2PDZrmbk = 3894, + X86_VCVTPS2PDZrmbkz = 3895, + X86_VCVTPS2PDZrmk = 3896, + X86_VCVTPS2PDZrmkz = 3897, + X86_VCVTPS2PDZrr = 3898, + X86_VCVTPS2PDZrrb = 3899, + X86_VCVTPS2PDZrrbk = 3900, + X86_VCVTPS2PDZrrbkz = 3901, + X86_VCVTPS2PDZrrk = 3902, + X86_VCVTPS2PDZrrkz = 3903, + X86_VCVTPS2PDrm = 3904, + X86_VCVTPS2PDrr = 3905, + X86_VCVTPS2PHYmr = 3906, + X86_VCVTPS2PHYrr = 3907, + X86_VCVTPS2PHZ128mr = 3908, + X86_VCVTPS2PHZ128mrk = 3909, + X86_VCVTPS2PHZ128rr = 3910, + X86_VCVTPS2PHZ128rrk = 3911, + X86_VCVTPS2PHZ128rrkz = 3912, + X86_VCVTPS2PHZ256mr = 3913, + X86_VCVTPS2PHZ256mrk = 3914, + X86_VCVTPS2PHZ256rr = 3915, + X86_VCVTPS2PHZ256rrk = 3916, + X86_VCVTPS2PHZ256rrkz = 3917, + X86_VCVTPS2PHZmr = 3918, + X86_VCVTPS2PHZmrk = 3919, + X86_VCVTPS2PHZrr = 3920, + X86_VCVTPS2PHZrrb = 3921, + X86_VCVTPS2PHZrrbk = 3922, + X86_VCVTPS2PHZrrbkz = 3923, + X86_VCVTPS2PHZrrk = 3924, + X86_VCVTPS2PHZrrkz = 3925, + X86_VCVTPS2PHmr = 3926, + X86_VCVTPS2PHrr = 3927, + X86_VCVTPS2QQZ128rm = 3928, + X86_VCVTPS2QQZ128rmb = 3929, + X86_VCVTPS2QQZ128rmbk = 3930, + X86_VCVTPS2QQZ128rmbkz = 3931, + X86_VCVTPS2QQZ128rmk = 3932, + X86_VCVTPS2QQZ128rmkz = 3933, + X86_VCVTPS2QQZ128rr = 3934, + X86_VCVTPS2QQZ128rrk = 3935, + X86_VCVTPS2QQZ128rrkz = 3936, + X86_VCVTPS2QQZ256rm = 3937, + X86_VCVTPS2QQZ256rmb = 3938, + X86_VCVTPS2QQZ256rmbk = 3939, + X86_VCVTPS2QQZ256rmbkz = 3940, + X86_VCVTPS2QQZ256rmk = 3941, + X86_VCVTPS2QQZ256rmkz = 3942, + X86_VCVTPS2QQZ256rr = 3943, + X86_VCVTPS2QQZ256rrk = 3944, + X86_VCVTPS2QQZ256rrkz = 3945, + X86_VCVTPS2QQZrm = 3946, + X86_VCVTPS2QQZrmb = 3947, + X86_VCVTPS2QQZrmbk = 3948, + X86_VCVTPS2QQZrmbkz = 3949, + X86_VCVTPS2QQZrmk = 3950, + X86_VCVTPS2QQZrmkz = 3951, + X86_VCVTPS2QQZrr = 3952, + X86_VCVTPS2QQZrrb = 3953, + X86_VCVTPS2QQZrrbk = 3954, + X86_VCVTPS2QQZrrbkz = 3955, + X86_VCVTPS2QQZrrk = 3956, + X86_VCVTPS2QQZrrkz = 3957, + X86_VCVTPS2UDQZ128rm = 3958, + X86_VCVTPS2UDQZ128rmb = 3959, + X86_VCVTPS2UDQZ128rmbk = 3960, + X86_VCVTPS2UDQZ128rmbkz = 3961, + X86_VCVTPS2UDQZ128rmk = 3962, + X86_VCVTPS2UDQZ128rmkz = 3963, + X86_VCVTPS2UDQZ128rr = 3964, + X86_VCVTPS2UDQZ128rrk = 3965, + X86_VCVTPS2UDQZ128rrkz = 3966, + X86_VCVTPS2UDQZ256rm = 3967, + X86_VCVTPS2UDQZ256rmb = 3968, + X86_VCVTPS2UDQZ256rmbk = 3969, + X86_VCVTPS2UDQZ256rmbkz = 3970, + X86_VCVTPS2UDQZ256rmk = 3971, + X86_VCVTPS2UDQZ256rmkz = 3972, + X86_VCVTPS2UDQZ256rr = 3973, + X86_VCVTPS2UDQZ256rrk = 3974, + X86_VCVTPS2UDQZ256rrkz = 3975, + X86_VCVTPS2UDQZrm = 3976, + X86_VCVTPS2UDQZrmb = 3977, + X86_VCVTPS2UDQZrmbk = 3978, + X86_VCVTPS2UDQZrmbkz = 3979, + X86_VCVTPS2UDQZrmk = 3980, + X86_VCVTPS2UDQZrmkz = 3981, + X86_VCVTPS2UDQZrr = 3982, + X86_VCVTPS2UDQZrrb = 3983, + X86_VCVTPS2UDQZrrbk = 3984, + X86_VCVTPS2UDQZrrbkz = 3985, + X86_VCVTPS2UDQZrrk = 3986, + X86_VCVTPS2UDQZrrkz = 3987, + X86_VCVTPS2UQQZ128rm = 3988, + X86_VCVTPS2UQQZ128rmb = 3989, + X86_VCVTPS2UQQZ128rmbk = 3990, + X86_VCVTPS2UQQZ128rmbkz = 3991, + X86_VCVTPS2UQQZ128rmk = 3992, + X86_VCVTPS2UQQZ128rmkz = 3993, + X86_VCVTPS2UQQZ128rr = 3994, + X86_VCVTPS2UQQZ128rrk = 3995, + X86_VCVTPS2UQQZ128rrkz = 3996, + X86_VCVTPS2UQQZ256rm = 3997, + X86_VCVTPS2UQQZ256rmb = 3998, + X86_VCVTPS2UQQZ256rmbk = 3999, + X86_VCVTPS2UQQZ256rmbkz = 4000, + X86_VCVTPS2UQQZ256rmk = 4001, + X86_VCVTPS2UQQZ256rmkz = 4002, + X86_VCVTPS2UQQZ256rr = 4003, + X86_VCVTPS2UQQZ256rrk = 4004, + X86_VCVTPS2UQQZ256rrkz = 4005, + X86_VCVTPS2UQQZrm = 4006, + X86_VCVTPS2UQQZrmb = 4007, + X86_VCVTPS2UQQZrmbk = 4008, + X86_VCVTPS2UQQZrmbkz = 4009, + X86_VCVTPS2UQQZrmk = 4010, + X86_VCVTPS2UQQZrmkz = 4011, + X86_VCVTPS2UQQZrr = 4012, + X86_VCVTPS2UQQZrrb = 4013, + X86_VCVTPS2UQQZrrbk = 4014, + X86_VCVTPS2UQQZrrbkz = 4015, + X86_VCVTPS2UQQZrrk = 4016, + X86_VCVTPS2UQQZrrkz = 4017, + X86_VCVTQQ2PDZ128rm = 4018, + X86_VCVTQQ2PDZ128rmb = 4019, + X86_VCVTQQ2PDZ128rmbk = 4020, + X86_VCVTQQ2PDZ128rmbkz = 4021, + X86_VCVTQQ2PDZ128rmk = 4022, + X86_VCVTQQ2PDZ128rmkz = 4023, + X86_VCVTQQ2PDZ128rr = 4024, + X86_VCVTQQ2PDZ128rrk = 4025, + X86_VCVTQQ2PDZ128rrkz = 4026, + X86_VCVTQQ2PDZ256rm = 4027, + X86_VCVTQQ2PDZ256rmb = 4028, + X86_VCVTQQ2PDZ256rmbk = 4029, + X86_VCVTQQ2PDZ256rmbkz = 4030, + X86_VCVTQQ2PDZ256rmk = 4031, + X86_VCVTQQ2PDZ256rmkz = 4032, + X86_VCVTQQ2PDZ256rr = 4033, + X86_VCVTQQ2PDZ256rrk = 4034, + X86_VCVTQQ2PDZ256rrkz = 4035, + X86_VCVTQQ2PDZrm = 4036, + X86_VCVTQQ2PDZrmb = 4037, + X86_VCVTQQ2PDZrmbk = 4038, + X86_VCVTQQ2PDZrmbkz = 4039, + X86_VCVTQQ2PDZrmk = 4040, + X86_VCVTQQ2PDZrmkz = 4041, + X86_VCVTQQ2PDZrr = 4042, + X86_VCVTQQ2PDZrrb = 4043, + X86_VCVTQQ2PDZrrbk = 4044, + X86_VCVTQQ2PDZrrbkz = 4045, + X86_VCVTQQ2PDZrrk = 4046, + X86_VCVTQQ2PDZrrkz = 4047, + X86_VCVTQQ2PSZ128rm = 4048, + X86_VCVTQQ2PSZ128rmb = 4049, + X86_VCVTQQ2PSZ128rmbk = 4050, + X86_VCVTQQ2PSZ128rmbkz = 4051, + X86_VCVTQQ2PSZ128rmk = 4052, + X86_VCVTQQ2PSZ128rmkz = 4053, + X86_VCVTQQ2PSZ128rr = 4054, + X86_VCVTQQ2PSZ128rrk = 4055, + X86_VCVTQQ2PSZ128rrkz = 4056, + X86_VCVTQQ2PSZ256rm = 4057, + X86_VCVTQQ2PSZ256rmb = 4058, + X86_VCVTQQ2PSZ256rmbk = 4059, + X86_VCVTQQ2PSZ256rmbkz = 4060, + X86_VCVTQQ2PSZ256rmk = 4061, + X86_VCVTQQ2PSZ256rmkz = 4062, + X86_VCVTQQ2PSZ256rr = 4063, + X86_VCVTQQ2PSZ256rrk = 4064, + X86_VCVTQQ2PSZ256rrkz = 4065, + X86_VCVTQQ2PSZrm = 4066, + X86_VCVTQQ2PSZrmb = 4067, + X86_VCVTQQ2PSZrmbk = 4068, + X86_VCVTQQ2PSZrmbkz = 4069, + X86_VCVTQQ2PSZrmk = 4070, + X86_VCVTQQ2PSZrmkz = 4071, + X86_VCVTQQ2PSZrr = 4072, + X86_VCVTQQ2PSZrrb = 4073, + X86_VCVTQQ2PSZrrbk = 4074, + X86_VCVTQQ2PSZrrbkz = 4075, + X86_VCVTQQ2PSZrrk = 4076, + X86_VCVTQQ2PSZrrkz = 4077, + X86_VCVTSD2SI64Zrm_Int = 4078, + X86_VCVTSD2SI64Zrr_Int = 4079, + X86_VCVTSD2SI64Zrrb_Int = 4080, + X86_VCVTSD2SI64rm_Int = 4081, + X86_VCVTSD2SI64rr_Int = 4082, + X86_VCVTSD2SIZrm_Int = 4083, + X86_VCVTSD2SIZrr_Int = 4084, + X86_VCVTSD2SIZrrb_Int = 4085, + X86_VCVTSD2SIrm_Int = 4086, + X86_VCVTSD2SIrr_Int = 4087, + X86_VCVTSD2SSZrm = 4088, + X86_VCVTSD2SSZrm_Int = 4089, + X86_VCVTSD2SSZrm_Intk = 4090, + X86_VCVTSD2SSZrm_Intkz = 4091, + X86_VCVTSD2SSZrr = 4092, + X86_VCVTSD2SSZrr_Int = 4093, + X86_VCVTSD2SSZrr_Intk = 4094, + X86_VCVTSD2SSZrr_Intkz = 4095, + X86_VCVTSD2SSZrrb_Int = 4096, + X86_VCVTSD2SSZrrb_Intk = 4097, + X86_VCVTSD2SSZrrb_Intkz = 4098, + X86_VCVTSD2SSrm = 4099, + X86_VCVTSD2SSrm_Int = 4100, + X86_VCVTSD2SSrr = 4101, + X86_VCVTSD2SSrr_Int = 4102, + X86_VCVTSD2USI64Zrm_Int = 4103, + X86_VCVTSD2USI64Zrr_Int = 4104, + X86_VCVTSD2USI64Zrrb_Int = 4105, + X86_VCVTSD2USIZrm_Int = 4106, + X86_VCVTSD2USIZrr_Int = 4107, + X86_VCVTSD2USIZrrb_Int = 4108, + X86_VCVTSI2SDZrm = 4109, + X86_VCVTSI2SDZrm_Int = 4110, + X86_VCVTSI2SDZrr = 4111, + X86_VCVTSI2SDZrr_Int = 4112, + X86_VCVTSI2SDZrrb_Int = 4113, + X86_VCVTSI2SDrm = 4114, + X86_VCVTSI2SDrm_Int = 4115, + X86_VCVTSI2SDrr = 4116, + X86_VCVTSI2SDrr_Int = 4117, + X86_VCVTSI2SSZrm = 4118, + X86_VCVTSI2SSZrm_Int = 4119, + X86_VCVTSI2SSZrr = 4120, + X86_VCVTSI2SSZrr_Int = 4121, + X86_VCVTSI2SSZrrb_Int = 4122, + X86_VCVTSI2SSrm = 4123, + X86_VCVTSI2SSrm_Int = 4124, + X86_VCVTSI2SSrr = 4125, + X86_VCVTSI2SSrr_Int = 4126, + X86_VCVTSI642SDZrm = 4127, + X86_VCVTSI642SDZrm_Int = 4128, + X86_VCVTSI642SDZrr = 4129, + X86_VCVTSI642SDZrr_Int = 4130, + X86_VCVTSI642SDZrrb_Int = 4131, + X86_VCVTSI642SDrm = 4132, + X86_VCVTSI642SDrm_Int = 4133, + X86_VCVTSI642SDrr = 4134, + X86_VCVTSI642SDrr_Int = 4135, + X86_VCVTSI642SSZrm = 4136, + X86_VCVTSI642SSZrm_Int = 4137, + X86_VCVTSI642SSZrr = 4138, + X86_VCVTSI642SSZrr_Int = 4139, + X86_VCVTSI642SSZrrb_Int = 4140, + X86_VCVTSI642SSrm = 4141, + X86_VCVTSI642SSrm_Int = 4142, + X86_VCVTSI642SSrr = 4143, + X86_VCVTSI642SSrr_Int = 4144, + X86_VCVTSS2SDZrm = 4145, + X86_VCVTSS2SDZrm_Int = 4146, + X86_VCVTSS2SDZrm_Intk = 4147, + X86_VCVTSS2SDZrm_Intkz = 4148, + X86_VCVTSS2SDZrr = 4149, + X86_VCVTSS2SDZrr_Int = 4150, + X86_VCVTSS2SDZrr_Intk = 4151, + X86_VCVTSS2SDZrr_Intkz = 4152, + X86_VCVTSS2SDZrrb_Int = 4153, + X86_VCVTSS2SDZrrb_Intk = 4154, + X86_VCVTSS2SDZrrb_Intkz = 4155, + X86_VCVTSS2SDrm = 4156, + X86_VCVTSS2SDrm_Int = 4157, + X86_VCVTSS2SDrr = 4158, + X86_VCVTSS2SDrr_Int = 4159, + X86_VCVTSS2SI64Zrm_Int = 4160, + X86_VCVTSS2SI64Zrr_Int = 4161, + X86_VCVTSS2SI64Zrrb_Int = 4162, + X86_VCVTSS2SI64rm_Int = 4163, + X86_VCVTSS2SI64rr_Int = 4164, + X86_VCVTSS2SIZrm_Int = 4165, + X86_VCVTSS2SIZrr_Int = 4166, + X86_VCVTSS2SIZrrb_Int = 4167, + X86_VCVTSS2SIrm_Int = 4168, + X86_VCVTSS2SIrr_Int = 4169, + X86_VCVTSS2USI64Zrm_Int = 4170, + X86_VCVTSS2USI64Zrr_Int = 4171, + X86_VCVTSS2USI64Zrrb_Int = 4172, + X86_VCVTSS2USIZrm_Int = 4173, + X86_VCVTSS2USIZrr_Int = 4174, + X86_VCVTSS2USIZrrb_Int = 4175, + X86_VCVTTPD2DQYrm = 4176, + X86_VCVTTPD2DQYrr = 4177, + X86_VCVTTPD2DQZ128rm = 4178, + X86_VCVTTPD2DQZ128rmb = 4179, + X86_VCVTTPD2DQZ128rmbk = 4180, + X86_VCVTTPD2DQZ128rmbkz = 4181, + X86_VCVTTPD2DQZ128rmk = 4182, + X86_VCVTTPD2DQZ128rmkz = 4183, + X86_VCVTTPD2DQZ128rr = 4184, + X86_VCVTTPD2DQZ128rrk = 4185, + X86_VCVTTPD2DQZ128rrkz = 4186, + X86_VCVTTPD2DQZ256rm = 4187, + X86_VCVTTPD2DQZ256rmb = 4188, + X86_VCVTTPD2DQZ256rmbk = 4189, + X86_VCVTTPD2DQZ256rmbkz = 4190, + X86_VCVTTPD2DQZ256rmk = 4191, + X86_VCVTTPD2DQZ256rmkz = 4192, + X86_VCVTTPD2DQZ256rr = 4193, + X86_VCVTTPD2DQZ256rrk = 4194, + X86_VCVTTPD2DQZ256rrkz = 4195, + X86_VCVTTPD2DQZrm = 4196, + X86_VCVTTPD2DQZrmb = 4197, + X86_VCVTTPD2DQZrmbk = 4198, + X86_VCVTTPD2DQZrmbkz = 4199, + X86_VCVTTPD2DQZrmk = 4200, + X86_VCVTTPD2DQZrmkz = 4201, + X86_VCVTTPD2DQZrr = 4202, + X86_VCVTTPD2DQZrrb = 4203, + X86_VCVTTPD2DQZrrbk = 4204, + X86_VCVTTPD2DQZrrbkz = 4205, + X86_VCVTTPD2DQZrrk = 4206, + X86_VCVTTPD2DQZrrkz = 4207, + X86_VCVTTPD2DQrm = 4208, + X86_VCVTTPD2DQrr = 4209, + X86_VCVTTPD2QQZ128rm = 4210, + X86_VCVTTPD2QQZ128rmb = 4211, + X86_VCVTTPD2QQZ128rmbk = 4212, + X86_VCVTTPD2QQZ128rmbkz = 4213, + X86_VCVTTPD2QQZ128rmk = 4214, + X86_VCVTTPD2QQZ128rmkz = 4215, + X86_VCVTTPD2QQZ128rr = 4216, + X86_VCVTTPD2QQZ128rrk = 4217, + X86_VCVTTPD2QQZ128rrkz = 4218, + X86_VCVTTPD2QQZ256rm = 4219, + X86_VCVTTPD2QQZ256rmb = 4220, + X86_VCVTTPD2QQZ256rmbk = 4221, + X86_VCVTTPD2QQZ256rmbkz = 4222, + X86_VCVTTPD2QQZ256rmk = 4223, + X86_VCVTTPD2QQZ256rmkz = 4224, + X86_VCVTTPD2QQZ256rr = 4225, + X86_VCVTTPD2QQZ256rrk = 4226, + X86_VCVTTPD2QQZ256rrkz = 4227, + X86_VCVTTPD2QQZrm = 4228, + X86_VCVTTPD2QQZrmb = 4229, + X86_VCVTTPD2QQZrmbk = 4230, + X86_VCVTTPD2QQZrmbkz = 4231, + X86_VCVTTPD2QQZrmk = 4232, + X86_VCVTTPD2QQZrmkz = 4233, + X86_VCVTTPD2QQZrr = 4234, + X86_VCVTTPD2QQZrrb = 4235, + X86_VCVTTPD2QQZrrbk = 4236, + X86_VCVTTPD2QQZrrbkz = 4237, + X86_VCVTTPD2QQZrrk = 4238, + X86_VCVTTPD2QQZrrkz = 4239, + X86_VCVTTPD2UDQZ128rm = 4240, + X86_VCVTTPD2UDQZ128rmb = 4241, + X86_VCVTTPD2UDQZ128rmbk = 4242, + X86_VCVTTPD2UDQZ128rmbkz = 4243, + X86_VCVTTPD2UDQZ128rmk = 4244, + X86_VCVTTPD2UDQZ128rmkz = 4245, + X86_VCVTTPD2UDQZ128rr = 4246, + X86_VCVTTPD2UDQZ128rrk = 4247, + X86_VCVTTPD2UDQZ128rrkz = 4248, + X86_VCVTTPD2UDQZ256rm = 4249, + X86_VCVTTPD2UDQZ256rmb = 4250, + X86_VCVTTPD2UDQZ256rmbk = 4251, + X86_VCVTTPD2UDQZ256rmbkz = 4252, + X86_VCVTTPD2UDQZ256rmk = 4253, + X86_VCVTTPD2UDQZ256rmkz = 4254, + X86_VCVTTPD2UDQZ256rr = 4255, + X86_VCVTTPD2UDQZ256rrk = 4256, + X86_VCVTTPD2UDQZ256rrkz = 4257, + X86_VCVTTPD2UDQZrm = 4258, + X86_VCVTTPD2UDQZrmb = 4259, + X86_VCVTTPD2UDQZrmbk = 4260, + X86_VCVTTPD2UDQZrmbkz = 4261, + X86_VCVTTPD2UDQZrmk = 4262, + X86_VCVTTPD2UDQZrmkz = 4263, + X86_VCVTTPD2UDQZrr = 4264, + X86_VCVTTPD2UDQZrrb = 4265, + X86_VCVTTPD2UDQZrrbk = 4266, + X86_VCVTTPD2UDQZrrbkz = 4267, + X86_VCVTTPD2UDQZrrk = 4268, + X86_VCVTTPD2UDQZrrkz = 4269, + X86_VCVTTPD2UQQZ128rm = 4270, + X86_VCVTTPD2UQQZ128rmb = 4271, + X86_VCVTTPD2UQQZ128rmbk = 4272, + X86_VCVTTPD2UQQZ128rmbkz = 4273, + X86_VCVTTPD2UQQZ128rmk = 4274, + X86_VCVTTPD2UQQZ128rmkz = 4275, + X86_VCVTTPD2UQQZ128rr = 4276, + X86_VCVTTPD2UQQZ128rrk = 4277, + X86_VCVTTPD2UQQZ128rrkz = 4278, + X86_VCVTTPD2UQQZ256rm = 4279, + X86_VCVTTPD2UQQZ256rmb = 4280, + X86_VCVTTPD2UQQZ256rmbk = 4281, + X86_VCVTTPD2UQQZ256rmbkz = 4282, + X86_VCVTTPD2UQQZ256rmk = 4283, + X86_VCVTTPD2UQQZ256rmkz = 4284, + X86_VCVTTPD2UQQZ256rr = 4285, + X86_VCVTTPD2UQQZ256rrk = 4286, + X86_VCVTTPD2UQQZ256rrkz = 4287, + X86_VCVTTPD2UQQZrm = 4288, + X86_VCVTTPD2UQQZrmb = 4289, + X86_VCVTTPD2UQQZrmbk = 4290, + X86_VCVTTPD2UQQZrmbkz = 4291, + X86_VCVTTPD2UQQZrmk = 4292, + X86_VCVTTPD2UQQZrmkz = 4293, + X86_VCVTTPD2UQQZrr = 4294, + X86_VCVTTPD2UQQZrrb = 4295, + X86_VCVTTPD2UQQZrrbk = 4296, + X86_VCVTTPD2UQQZrrbkz = 4297, + X86_VCVTTPD2UQQZrrk = 4298, + X86_VCVTTPD2UQQZrrkz = 4299, + X86_VCVTTPS2DQYrm = 4300, + X86_VCVTTPS2DQYrr = 4301, + X86_VCVTTPS2DQZ128rm = 4302, + X86_VCVTTPS2DQZ128rmb = 4303, + X86_VCVTTPS2DQZ128rmbk = 4304, + X86_VCVTTPS2DQZ128rmbkz = 4305, + X86_VCVTTPS2DQZ128rmk = 4306, + X86_VCVTTPS2DQZ128rmkz = 4307, + X86_VCVTTPS2DQZ128rr = 4308, + X86_VCVTTPS2DQZ128rrk = 4309, + X86_VCVTTPS2DQZ128rrkz = 4310, + X86_VCVTTPS2DQZ256rm = 4311, + X86_VCVTTPS2DQZ256rmb = 4312, + X86_VCVTTPS2DQZ256rmbk = 4313, + X86_VCVTTPS2DQZ256rmbkz = 4314, + X86_VCVTTPS2DQZ256rmk = 4315, + X86_VCVTTPS2DQZ256rmkz = 4316, + X86_VCVTTPS2DQZ256rr = 4317, + X86_VCVTTPS2DQZ256rrk = 4318, + X86_VCVTTPS2DQZ256rrkz = 4319, + X86_VCVTTPS2DQZrm = 4320, + X86_VCVTTPS2DQZrmb = 4321, + X86_VCVTTPS2DQZrmbk = 4322, + X86_VCVTTPS2DQZrmbkz = 4323, + X86_VCVTTPS2DQZrmk = 4324, + X86_VCVTTPS2DQZrmkz = 4325, + X86_VCVTTPS2DQZrr = 4326, + X86_VCVTTPS2DQZrrb = 4327, + X86_VCVTTPS2DQZrrbk = 4328, + X86_VCVTTPS2DQZrrbkz = 4329, + X86_VCVTTPS2DQZrrk = 4330, + X86_VCVTTPS2DQZrrkz = 4331, + X86_VCVTTPS2DQrm = 4332, + X86_VCVTTPS2DQrr = 4333, + X86_VCVTTPS2QQZ128rm = 4334, + X86_VCVTTPS2QQZ128rmb = 4335, + X86_VCVTTPS2QQZ128rmbk = 4336, + X86_VCVTTPS2QQZ128rmbkz = 4337, + X86_VCVTTPS2QQZ128rmk = 4338, + X86_VCVTTPS2QQZ128rmkz = 4339, + X86_VCVTTPS2QQZ128rr = 4340, + X86_VCVTTPS2QQZ128rrk = 4341, + X86_VCVTTPS2QQZ128rrkz = 4342, + X86_VCVTTPS2QQZ256rm = 4343, + X86_VCVTTPS2QQZ256rmb = 4344, + X86_VCVTTPS2QQZ256rmbk = 4345, + X86_VCVTTPS2QQZ256rmbkz = 4346, + X86_VCVTTPS2QQZ256rmk = 4347, + X86_VCVTTPS2QQZ256rmkz = 4348, + X86_VCVTTPS2QQZ256rr = 4349, + X86_VCVTTPS2QQZ256rrk = 4350, + X86_VCVTTPS2QQZ256rrkz = 4351, + X86_VCVTTPS2QQZrm = 4352, + X86_VCVTTPS2QQZrmb = 4353, + X86_VCVTTPS2QQZrmbk = 4354, + X86_VCVTTPS2QQZrmbkz = 4355, + X86_VCVTTPS2QQZrmk = 4356, + X86_VCVTTPS2QQZrmkz = 4357, + X86_VCVTTPS2QQZrr = 4358, + X86_VCVTTPS2QQZrrb = 4359, + X86_VCVTTPS2QQZrrbk = 4360, + X86_VCVTTPS2QQZrrbkz = 4361, + X86_VCVTTPS2QQZrrk = 4362, + X86_VCVTTPS2QQZrrkz = 4363, + X86_VCVTTPS2UDQZ128rm = 4364, + X86_VCVTTPS2UDQZ128rmb = 4365, + X86_VCVTTPS2UDQZ128rmbk = 4366, + X86_VCVTTPS2UDQZ128rmbkz = 4367, + X86_VCVTTPS2UDQZ128rmk = 4368, + X86_VCVTTPS2UDQZ128rmkz = 4369, + X86_VCVTTPS2UDQZ128rr = 4370, + X86_VCVTTPS2UDQZ128rrk = 4371, + X86_VCVTTPS2UDQZ128rrkz = 4372, + X86_VCVTTPS2UDQZ256rm = 4373, + X86_VCVTTPS2UDQZ256rmb = 4374, + X86_VCVTTPS2UDQZ256rmbk = 4375, + X86_VCVTTPS2UDQZ256rmbkz = 4376, + X86_VCVTTPS2UDQZ256rmk = 4377, + X86_VCVTTPS2UDQZ256rmkz = 4378, + X86_VCVTTPS2UDQZ256rr = 4379, + X86_VCVTTPS2UDQZ256rrk = 4380, + X86_VCVTTPS2UDQZ256rrkz = 4381, + X86_VCVTTPS2UDQZrm = 4382, + X86_VCVTTPS2UDQZrmb = 4383, + X86_VCVTTPS2UDQZrmbk = 4384, + X86_VCVTTPS2UDQZrmbkz = 4385, + X86_VCVTTPS2UDQZrmk = 4386, + X86_VCVTTPS2UDQZrmkz = 4387, + X86_VCVTTPS2UDQZrr = 4388, + X86_VCVTTPS2UDQZrrb = 4389, + X86_VCVTTPS2UDQZrrbk = 4390, + X86_VCVTTPS2UDQZrrbkz = 4391, + X86_VCVTTPS2UDQZrrk = 4392, + X86_VCVTTPS2UDQZrrkz = 4393, + X86_VCVTTPS2UQQZ128rm = 4394, + X86_VCVTTPS2UQQZ128rmb = 4395, + X86_VCVTTPS2UQQZ128rmbk = 4396, + X86_VCVTTPS2UQQZ128rmbkz = 4397, + X86_VCVTTPS2UQQZ128rmk = 4398, + X86_VCVTTPS2UQQZ128rmkz = 4399, + X86_VCVTTPS2UQQZ128rr = 4400, + X86_VCVTTPS2UQQZ128rrk = 4401, + X86_VCVTTPS2UQQZ128rrkz = 4402, + X86_VCVTTPS2UQQZ256rm = 4403, + X86_VCVTTPS2UQQZ256rmb = 4404, + X86_VCVTTPS2UQQZ256rmbk = 4405, + X86_VCVTTPS2UQQZ256rmbkz = 4406, + X86_VCVTTPS2UQQZ256rmk = 4407, + X86_VCVTTPS2UQQZ256rmkz = 4408, + X86_VCVTTPS2UQQZ256rr = 4409, + X86_VCVTTPS2UQQZ256rrk = 4410, + X86_VCVTTPS2UQQZ256rrkz = 4411, + X86_VCVTTPS2UQQZrm = 4412, + X86_VCVTTPS2UQQZrmb = 4413, + X86_VCVTTPS2UQQZrmbk = 4414, + X86_VCVTTPS2UQQZrmbkz = 4415, + X86_VCVTTPS2UQQZrmk = 4416, + X86_VCVTTPS2UQQZrmkz = 4417, + X86_VCVTTPS2UQQZrr = 4418, + X86_VCVTTPS2UQQZrrb = 4419, + X86_VCVTTPS2UQQZrrbk = 4420, + X86_VCVTTPS2UQQZrrbkz = 4421, + X86_VCVTTPS2UQQZrrk = 4422, + X86_VCVTTPS2UQQZrrkz = 4423, + X86_VCVTTSD2SI64Zrm = 4424, + X86_VCVTTSD2SI64Zrm_Int = 4425, + X86_VCVTTSD2SI64Zrr = 4426, + X86_VCVTTSD2SI64Zrr_Int = 4427, + X86_VCVTTSD2SI64Zrrb_Int = 4428, + X86_VCVTTSD2SI64rm = 4429, + X86_VCVTTSD2SI64rm_Int = 4430, + X86_VCVTTSD2SI64rr = 4431, + X86_VCVTTSD2SI64rr_Int = 4432, + X86_VCVTTSD2SIZrm = 4433, + X86_VCVTTSD2SIZrm_Int = 4434, + X86_VCVTTSD2SIZrr = 4435, + X86_VCVTTSD2SIZrr_Int = 4436, + X86_VCVTTSD2SIZrrb_Int = 4437, + X86_VCVTTSD2SIrm = 4438, + X86_VCVTTSD2SIrm_Int = 4439, + X86_VCVTTSD2SIrr = 4440, + X86_VCVTTSD2SIrr_Int = 4441, + X86_VCVTTSD2USI64Zrm = 4442, + X86_VCVTTSD2USI64Zrm_Int = 4443, + X86_VCVTTSD2USI64Zrr = 4444, + X86_VCVTTSD2USI64Zrr_Int = 4445, + X86_VCVTTSD2USI64Zrrb_Int = 4446, + X86_VCVTTSD2USIZrm = 4447, + X86_VCVTTSD2USIZrm_Int = 4448, + X86_VCVTTSD2USIZrr = 4449, + X86_VCVTTSD2USIZrr_Int = 4450, + X86_VCVTTSD2USIZrrb_Int = 4451, + X86_VCVTTSS2SI64Zrm = 4452, + X86_VCVTTSS2SI64Zrm_Int = 4453, + X86_VCVTTSS2SI64Zrr = 4454, + X86_VCVTTSS2SI64Zrr_Int = 4455, + X86_VCVTTSS2SI64Zrrb_Int = 4456, + X86_VCVTTSS2SI64rm = 4457, + X86_VCVTTSS2SI64rm_Int = 4458, + X86_VCVTTSS2SI64rr = 4459, + X86_VCVTTSS2SI64rr_Int = 4460, + X86_VCVTTSS2SIZrm = 4461, + X86_VCVTTSS2SIZrm_Int = 4462, + X86_VCVTTSS2SIZrr = 4463, + X86_VCVTTSS2SIZrr_Int = 4464, + X86_VCVTTSS2SIZrrb_Int = 4465, + X86_VCVTTSS2SIrm = 4466, + X86_VCVTTSS2SIrm_Int = 4467, + X86_VCVTTSS2SIrr = 4468, + X86_VCVTTSS2SIrr_Int = 4469, + X86_VCVTTSS2USI64Zrm = 4470, + X86_VCVTTSS2USI64Zrm_Int = 4471, + X86_VCVTTSS2USI64Zrr = 4472, + X86_VCVTTSS2USI64Zrr_Int = 4473, + X86_VCVTTSS2USI64Zrrb_Int = 4474, + X86_VCVTTSS2USIZrm = 4475, + X86_VCVTTSS2USIZrm_Int = 4476, + X86_VCVTTSS2USIZrr = 4477, + X86_VCVTTSS2USIZrr_Int = 4478, + X86_VCVTTSS2USIZrrb_Int = 4479, + X86_VCVTUDQ2PDZ128rm = 4480, + X86_VCVTUDQ2PDZ128rmb = 4481, + X86_VCVTUDQ2PDZ128rmbk = 4482, + X86_VCVTUDQ2PDZ128rmbkz = 4483, + X86_VCVTUDQ2PDZ128rmk = 4484, + X86_VCVTUDQ2PDZ128rmkz = 4485, + X86_VCVTUDQ2PDZ128rr = 4486, + X86_VCVTUDQ2PDZ128rrk = 4487, + X86_VCVTUDQ2PDZ128rrkz = 4488, + X86_VCVTUDQ2PDZ256rm = 4489, + X86_VCVTUDQ2PDZ256rmb = 4490, + X86_VCVTUDQ2PDZ256rmbk = 4491, + X86_VCVTUDQ2PDZ256rmbkz = 4492, + X86_VCVTUDQ2PDZ256rmk = 4493, + X86_VCVTUDQ2PDZ256rmkz = 4494, + X86_VCVTUDQ2PDZ256rr = 4495, + X86_VCVTUDQ2PDZ256rrk = 4496, + X86_VCVTUDQ2PDZ256rrkz = 4497, + X86_VCVTUDQ2PDZrm = 4498, + X86_VCVTUDQ2PDZrmb = 4499, + X86_VCVTUDQ2PDZrmbk = 4500, + X86_VCVTUDQ2PDZrmbkz = 4501, + X86_VCVTUDQ2PDZrmk = 4502, + X86_VCVTUDQ2PDZrmkz = 4503, + X86_VCVTUDQ2PDZrr = 4504, + X86_VCVTUDQ2PDZrrk = 4505, + X86_VCVTUDQ2PDZrrkz = 4506, + X86_VCVTUDQ2PSZ128rm = 4507, + X86_VCVTUDQ2PSZ128rmb = 4508, + X86_VCVTUDQ2PSZ128rmbk = 4509, + X86_VCVTUDQ2PSZ128rmbkz = 4510, + X86_VCVTUDQ2PSZ128rmk = 4511, + X86_VCVTUDQ2PSZ128rmkz = 4512, + X86_VCVTUDQ2PSZ128rr = 4513, + X86_VCVTUDQ2PSZ128rrk = 4514, + X86_VCVTUDQ2PSZ128rrkz = 4515, + X86_VCVTUDQ2PSZ256rm = 4516, + X86_VCVTUDQ2PSZ256rmb = 4517, + X86_VCVTUDQ2PSZ256rmbk = 4518, + X86_VCVTUDQ2PSZ256rmbkz = 4519, + X86_VCVTUDQ2PSZ256rmk = 4520, + X86_VCVTUDQ2PSZ256rmkz = 4521, + X86_VCVTUDQ2PSZ256rr = 4522, + X86_VCVTUDQ2PSZ256rrk = 4523, + X86_VCVTUDQ2PSZ256rrkz = 4524, + X86_VCVTUDQ2PSZrm = 4525, + X86_VCVTUDQ2PSZrmb = 4526, + X86_VCVTUDQ2PSZrmbk = 4527, + X86_VCVTUDQ2PSZrmbkz = 4528, + X86_VCVTUDQ2PSZrmk = 4529, + X86_VCVTUDQ2PSZrmkz = 4530, + X86_VCVTUDQ2PSZrr = 4531, + X86_VCVTUDQ2PSZrrb = 4532, + X86_VCVTUDQ2PSZrrbk = 4533, + X86_VCVTUDQ2PSZrrbkz = 4534, + X86_VCVTUDQ2PSZrrk = 4535, + X86_VCVTUDQ2PSZrrkz = 4536, + X86_VCVTUQQ2PDZ128rm = 4537, + X86_VCVTUQQ2PDZ128rmb = 4538, + X86_VCVTUQQ2PDZ128rmbk = 4539, + X86_VCVTUQQ2PDZ128rmbkz = 4540, + X86_VCVTUQQ2PDZ128rmk = 4541, + X86_VCVTUQQ2PDZ128rmkz = 4542, + X86_VCVTUQQ2PDZ128rr = 4543, + X86_VCVTUQQ2PDZ128rrk = 4544, + X86_VCVTUQQ2PDZ128rrkz = 4545, + X86_VCVTUQQ2PDZ256rm = 4546, + X86_VCVTUQQ2PDZ256rmb = 4547, + X86_VCVTUQQ2PDZ256rmbk = 4548, + X86_VCVTUQQ2PDZ256rmbkz = 4549, + X86_VCVTUQQ2PDZ256rmk = 4550, + X86_VCVTUQQ2PDZ256rmkz = 4551, + X86_VCVTUQQ2PDZ256rr = 4552, + X86_VCVTUQQ2PDZ256rrk = 4553, + X86_VCVTUQQ2PDZ256rrkz = 4554, + X86_VCVTUQQ2PDZrm = 4555, + X86_VCVTUQQ2PDZrmb = 4556, + X86_VCVTUQQ2PDZrmbk = 4557, + X86_VCVTUQQ2PDZrmbkz = 4558, + X86_VCVTUQQ2PDZrmk = 4559, + X86_VCVTUQQ2PDZrmkz = 4560, + X86_VCVTUQQ2PDZrr = 4561, + X86_VCVTUQQ2PDZrrb = 4562, + X86_VCVTUQQ2PDZrrbk = 4563, + X86_VCVTUQQ2PDZrrbkz = 4564, + X86_VCVTUQQ2PDZrrk = 4565, + X86_VCVTUQQ2PDZrrkz = 4566, + X86_VCVTUQQ2PSZ128rm = 4567, + X86_VCVTUQQ2PSZ128rmb = 4568, + X86_VCVTUQQ2PSZ128rmbk = 4569, + X86_VCVTUQQ2PSZ128rmbkz = 4570, + X86_VCVTUQQ2PSZ128rmk = 4571, + X86_VCVTUQQ2PSZ128rmkz = 4572, + X86_VCVTUQQ2PSZ128rr = 4573, + X86_VCVTUQQ2PSZ128rrk = 4574, + X86_VCVTUQQ2PSZ128rrkz = 4575, + X86_VCVTUQQ2PSZ256rm = 4576, + X86_VCVTUQQ2PSZ256rmb = 4577, + X86_VCVTUQQ2PSZ256rmbk = 4578, + X86_VCVTUQQ2PSZ256rmbkz = 4579, + X86_VCVTUQQ2PSZ256rmk = 4580, + X86_VCVTUQQ2PSZ256rmkz = 4581, + X86_VCVTUQQ2PSZ256rr = 4582, + X86_VCVTUQQ2PSZ256rrk = 4583, + X86_VCVTUQQ2PSZ256rrkz = 4584, + X86_VCVTUQQ2PSZrm = 4585, + X86_VCVTUQQ2PSZrmb = 4586, + X86_VCVTUQQ2PSZrmbk = 4587, + X86_VCVTUQQ2PSZrmbkz = 4588, + X86_VCVTUQQ2PSZrmk = 4589, + X86_VCVTUQQ2PSZrmkz = 4590, + X86_VCVTUQQ2PSZrr = 4591, + X86_VCVTUQQ2PSZrrb = 4592, + X86_VCVTUQQ2PSZrrbk = 4593, + X86_VCVTUQQ2PSZrrbkz = 4594, + X86_VCVTUQQ2PSZrrk = 4595, + X86_VCVTUQQ2PSZrrkz = 4596, + X86_VCVTUSI2SDZrm = 4597, + X86_VCVTUSI2SDZrm_Int = 4598, + X86_VCVTUSI2SDZrr = 4599, + X86_VCVTUSI2SDZrr_Int = 4600, + X86_VCVTUSI2SSZrm = 4601, + X86_VCVTUSI2SSZrm_Int = 4602, + X86_VCVTUSI2SSZrr = 4603, + X86_VCVTUSI2SSZrr_Int = 4604, + X86_VCVTUSI2SSZrrb_Int = 4605, + X86_VCVTUSI642SDZrm = 4606, + X86_VCVTUSI642SDZrm_Int = 4607, + X86_VCVTUSI642SDZrr = 4608, + X86_VCVTUSI642SDZrr_Int = 4609, + X86_VCVTUSI642SDZrrb_Int = 4610, + X86_VCVTUSI642SSZrm = 4611, + X86_VCVTUSI642SSZrm_Int = 4612, + X86_VCVTUSI642SSZrr = 4613, + X86_VCVTUSI642SSZrr_Int = 4614, + X86_VCVTUSI642SSZrrb_Int = 4615, + X86_VDBPSADBWZ128rmi = 4616, + X86_VDBPSADBWZ128rmik = 4617, + X86_VDBPSADBWZ128rmikz = 4618, + X86_VDBPSADBWZ128rri = 4619, + X86_VDBPSADBWZ128rrik = 4620, + X86_VDBPSADBWZ128rrikz = 4621, + X86_VDBPSADBWZ256rmi = 4622, + X86_VDBPSADBWZ256rmik = 4623, + X86_VDBPSADBWZ256rmikz = 4624, + X86_VDBPSADBWZ256rri = 4625, + X86_VDBPSADBWZ256rrik = 4626, + X86_VDBPSADBWZ256rrikz = 4627, + X86_VDBPSADBWZrmi = 4628, + X86_VDBPSADBWZrmik = 4629, + X86_VDBPSADBWZrmikz = 4630, + X86_VDBPSADBWZrri = 4631, + X86_VDBPSADBWZrrik = 4632, + X86_VDBPSADBWZrrikz = 4633, + X86_VDIVPDYrm = 4634, + X86_VDIVPDYrr = 4635, + X86_VDIVPDZ128rm = 4636, + X86_VDIVPDZ128rmb = 4637, + X86_VDIVPDZ128rmbk = 4638, + X86_VDIVPDZ128rmbkz = 4639, + X86_VDIVPDZ128rmk = 4640, + X86_VDIVPDZ128rmkz = 4641, + X86_VDIVPDZ128rr = 4642, + X86_VDIVPDZ128rrk = 4643, + X86_VDIVPDZ128rrkz = 4644, + X86_VDIVPDZ256rm = 4645, + X86_VDIVPDZ256rmb = 4646, + X86_VDIVPDZ256rmbk = 4647, + X86_VDIVPDZ256rmbkz = 4648, + X86_VDIVPDZ256rmk = 4649, + X86_VDIVPDZ256rmkz = 4650, + X86_VDIVPDZ256rr = 4651, + X86_VDIVPDZ256rrk = 4652, + X86_VDIVPDZ256rrkz = 4653, + X86_VDIVPDZrm = 4654, + X86_VDIVPDZrmb = 4655, + X86_VDIVPDZrmbk = 4656, + X86_VDIVPDZrmbkz = 4657, + X86_VDIVPDZrmk = 4658, + X86_VDIVPDZrmkz = 4659, + X86_VDIVPDZrr = 4660, + X86_VDIVPDZrrb = 4661, + X86_VDIVPDZrrbk = 4662, + X86_VDIVPDZrrbkz = 4663, + X86_VDIVPDZrrk = 4664, + X86_VDIVPDZrrkz = 4665, + X86_VDIVPDrm = 4666, + X86_VDIVPDrr = 4667, + X86_VDIVPSYrm = 4668, + X86_VDIVPSYrr = 4669, + X86_VDIVPSZ128rm = 4670, + X86_VDIVPSZ128rmb = 4671, + X86_VDIVPSZ128rmbk = 4672, + X86_VDIVPSZ128rmbkz = 4673, + X86_VDIVPSZ128rmk = 4674, + X86_VDIVPSZ128rmkz = 4675, + X86_VDIVPSZ128rr = 4676, + X86_VDIVPSZ128rrk = 4677, + X86_VDIVPSZ128rrkz = 4678, + X86_VDIVPSZ256rm = 4679, + X86_VDIVPSZ256rmb = 4680, + X86_VDIVPSZ256rmbk = 4681, + X86_VDIVPSZ256rmbkz = 4682, + X86_VDIVPSZ256rmk = 4683, + X86_VDIVPSZ256rmkz = 4684, + X86_VDIVPSZ256rr = 4685, + X86_VDIVPSZ256rrk = 4686, + X86_VDIVPSZ256rrkz = 4687, + X86_VDIVPSZrm = 4688, + X86_VDIVPSZrmb = 4689, + X86_VDIVPSZrmbk = 4690, + X86_VDIVPSZrmbkz = 4691, + X86_VDIVPSZrmk = 4692, + X86_VDIVPSZrmkz = 4693, + X86_VDIVPSZrr = 4694, + X86_VDIVPSZrrb = 4695, + X86_VDIVPSZrrbk = 4696, + X86_VDIVPSZrrbkz = 4697, + X86_VDIVPSZrrk = 4698, + X86_VDIVPSZrrkz = 4699, + X86_VDIVPSrm = 4700, + X86_VDIVPSrr = 4701, + X86_VDIVSDZrm = 4702, + X86_VDIVSDZrm_Int = 4703, + X86_VDIVSDZrm_Intk = 4704, + X86_VDIVSDZrm_Intkz = 4705, + X86_VDIVSDZrr = 4706, + X86_VDIVSDZrr_Int = 4707, + X86_VDIVSDZrr_Intk = 4708, + X86_VDIVSDZrr_Intkz = 4709, + X86_VDIVSDZrrb_Int = 4710, + X86_VDIVSDZrrb_Intk = 4711, + X86_VDIVSDZrrb_Intkz = 4712, + X86_VDIVSDrm = 4713, + X86_VDIVSDrm_Int = 4714, + X86_VDIVSDrr = 4715, + X86_VDIVSDrr_Int = 4716, + X86_VDIVSSZrm = 4717, + X86_VDIVSSZrm_Int = 4718, + X86_VDIVSSZrm_Intk = 4719, + X86_VDIVSSZrm_Intkz = 4720, + X86_VDIVSSZrr = 4721, + X86_VDIVSSZrr_Int = 4722, + X86_VDIVSSZrr_Intk = 4723, + X86_VDIVSSZrr_Intkz = 4724, + X86_VDIVSSZrrb_Int = 4725, + X86_VDIVSSZrrb_Intk = 4726, + X86_VDIVSSZrrb_Intkz = 4727, + X86_VDIVSSrm = 4728, + X86_VDIVSSrm_Int = 4729, + X86_VDIVSSrr = 4730, + X86_VDIVSSrr_Int = 4731, + X86_VDPPDrmi = 4732, + X86_VDPPDrri = 4733, + X86_VDPPSYrmi = 4734, + X86_VDPPSYrri = 4735, + X86_VDPPSrmi = 4736, + X86_VDPPSrri = 4737, + X86_VERRm = 4738, + X86_VERRr = 4739, + X86_VERWm = 4740, + X86_VERWr = 4741, + X86_VEXP2PDZm = 4742, + X86_VEXP2PDZmb = 4743, + X86_VEXP2PDZmbk = 4744, + X86_VEXP2PDZmbkz = 4745, + X86_VEXP2PDZmk = 4746, + X86_VEXP2PDZmkz = 4747, + X86_VEXP2PDZr = 4748, + X86_VEXP2PDZrb = 4749, + X86_VEXP2PDZrbk = 4750, + X86_VEXP2PDZrbkz = 4751, + X86_VEXP2PDZrk = 4752, + X86_VEXP2PDZrkz = 4753, + X86_VEXP2PSZm = 4754, + X86_VEXP2PSZmb = 4755, + X86_VEXP2PSZmbk = 4756, + X86_VEXP2PSZmbkz = 4757, + X86_VEXP2PSZmk = 4758, + X86_VEXP2PSZmkz = 4759, + X86_VEXP2PSZr = 4760, + X86_VEXP2PSZrb = 4761, + X86_VEXP2PSZrbk = 4762, + X86_VEXP2PSZrbkz = 4763, + X86_VEXP2PSZrk = 4764, + X86_VEXP2PSZrkz = 4765, + X86_VEXPANDPDZ128rm = 4766, + X86_VEXPANDPDZ128rmk = 4767, + X86_VEXPANDPDZ128rmkz = 4768, + X86_VEXPANDPDZ128rr = 4769, + X86_VEXPANDPDZ128rrk = 4770, + X86_VEXPANDPDZ128rrkz = 4771, + X86_VEXPANDPDZ256rm = 4772, + X86_VEXPANDPDZ256rmk = 4773, + X86_VEXPANDPDZ256rmkz = 4774, + X86_VEXPANDPDZ256rr = 4775, + X86_VEXPANDPDZ256rrk = 4776, + X86_VEXPANDPDZ256rrkz = 4777, + X86_VEXPANDPDZrm = 4778, + X86_VEXPANDPDZrmk = 4779, + X86_VEXPANDPDZrmkz = 4780, + X86_VEXPANDPDZrr = 4781, + X86_VEXPANDPDZrrk = 4782, + X86_VEXPANDPDZrrkz = 4783, + X86_VEXPANDPSZ128rm = 4784, + X86_VEXPANDPSZ128rmk = 4785, + X86_VEXPANDPSZ128rmkz = 4786, + X86_VEXPANDPSZ128rr = 4787, + X86_VEXPANDPSZ128rrk = 4788, + X86_VEXPANDPSZ128rrkz = 4789, + X86_VEXPANDPSZ256rm = 4790, + X86_VEXPANDPSZ256rmk = 4791, + X86_VEXPANDPSZ256rmkz = 4792, + X86_VEXPANDPSZ256rr = 4793, + X86_VEXPANDPSZ256rrk = 4794, + X86_VEXPANDPSZ256rrkz = 4795, + X86_VEXPANDPSZrm = 4796, + X86_VEXPANDPSZrmk = 4797, + X86_VEXPANDPSZrmkz = 4798, + X86_VEXPANDPSZrr = 4799, + X86_VEXPANDPSZrrk = 4800, + X86_VEXPANDPSZrrkz = 4801, + X86_VEXTRACTF128mr = 4802, + X86_VEXTRACTF128rr = 4803, + X86_VEXTRACTF32x4Z256mr = 4804, + X86_VEXTRACTF32x4Z256mrk = 4805, + X86_VEXTRACTF32x4Z256rr = 4806, + X86_VEXTRACTF32x4Z256rrk = 4807, + X86_VEXTRACTF32x4Z256rrkz = 4808, + X86_VEXTRACTF32x4Zmr = 4809, + X86_VEXTRACTF32x4Zmrk = 4810, + X86_VEXTRACTF32x4Zrr = 4811, + X86_VEXTRACTF32x4Zrrk = 4812, + X86_VEXTRACTF32x4Zrrkz = 4813, + X86_VEXTRACTF32x8Zmr = 4814, + X86_VEXTRACTF32x8Zmrk = 4815, + X86_VEXTRACTF32x8Zrr = 4816, + X86_VEXTRACTF32x8Zrrk = 4817, + X86_VEXTRACTF32x8Zrrkz = 4818, + X86_VEXTRACTF64x2Z256mr = 4819, + X86_VEXTRACTF64x2Z256mrk = 4820, + X86_VEXTRACTF64x2Z256rr = 4821, + X86_VEXTRACTF64x2Z256rrk = 4822, + X86_VEXTRACTF64x2Z256rrkz = 4823, + X86_VEXTRACTF64x2Zmr = 4824, + X86_VEXTRACTF64x2Zmrk = 4825, + X86_VEXTRACTF64x2Zrr = 4826, + X86_VEXTRACTF64x2Zrrk = 4827, + X86_VEXTRACTF64x2Zrrkz = 4828, + X86_VEXTRACTF64x4Zmr = 4829, + X86_VEXTRACTF64x4Zmrk = 4830, + X86_VEXTRACTF64x4Zrr = 4831, + X86_VEXTRACTF64x4Zrrk = 4832, + X86_VEXTRACTF64x4Zrrkz = 4833, + X86_VEXTRACTI128mr = 4834, + X86_VEXTRACTI128rr = 4835, + X86_VEXTRACTI32x4Z256mr = 4836, + X86_VEXTRACTI32x4Z256mrk = 4837, + X86_VEXTRACTI32x4Z256rr = 4838, + X86_VEXTRACTI32x4Z256rrk = 4839, + X86_VEXTRACTI32x4Z256rrkz = 4840, + X86_VEXTRACTI32x4Zmr = 4841, + X86_VEXTRACTI32x4Zmrk = 4842, + X86_VEXTRACTI32x4Zrr = 4843, + X86_VEXTRACTI32x4Zrrk = 4844, + X86_VEXTRACTI32x4Zrrkz = 4845, + X86_VEXTRACTI32x8Zmr = 4846, + X86_VEXTRACTI32x8Zmrk = 4847, + X86_VEXTRACTI32x8Zrr = 4848, + X86_VEXTRACTI32x8Zrrk = 4849, + X86_VEXTRACTI32x8Zrrkz = 4850, + X86_VEXTRACTI64x2Z256mr = 4851, + X86_VEXTRACTI64x2Z256mrk = 4852, + X86_VEXTRACTI64x2Z256rr = 4853, + X86_VEXTRACTI64x2Z256rrk = 4854, + X86_VEXTRACTI64x2Z256rrkz = 4855, + X86_VEXTRACTI64x2Zmr = 4856, + X86_VEXTRACTI64x2Zmrk = 4857, + X86_VEXTRACTI64x2Zrr = 4858, + X86_VEXTRACTI64x2Zrrk = 4859, + X86_VEXTRACTI64x2Zrrkz = 4860, + X86_VEXTRACTI64x4Zmr = 4861, + X86_VEXTRACTI64x4Zmrk = 4862, + X86_VEXTRACTI64x4Zrr = 4863, + X86_VEXTRACTI64x4Zrrk = 4864, + X86_VEXTRACTI64x4Zrrkz = 4865, + X86_VEXTRACTPSZmr = 4866, + X86_VEXTRACTPSZrr = 4867, + X86_VEXTRACTPSmr = 4868, + X86_VEXTRACTPSrr = 4869, + X86_VFIXUPIMMPDZ128rmbi = 4870, + X86_VFIXUPIMMPDZ128rmbik = 4871, + X86_VFIXUPIMMPDZ128rmbikz = 4872, + X86_VFIXUPIMMPDZ128rmi = 4873, + X86_VFIXUPIMMPDZ128rmik = 4874, + X86_VFIXUPIMMPDZ128rmikz = 4875, + X86_VFIXUPIMMPDZ128rri = 4876, + X86_VFIXUPIMMPDZ128rrik = 4877, + X86_VFIXUPIMMPDZ128rrikz = 4878, + X86_VFIXUPIMMPDZ256rmbi = 4879, + X86_VFIXUPIMMPDZ256rmbik = 4880, + X86_VFIXUPIMMPDZ256rmbikz = 4881, + X86_VFIXUPIMMPDZ256rmi = 4882, + X86_VFIXUPIMMPDZ256rmik = 4883, + X86_VFIXUPIMMPDZ256rmikz = 4884, + X86_VFIXUPIMMPDZ256rri = 4885, + X86_VFIXUPIMMPDZ256rrik = 4886, + X86_VFIXUPIMMPDZ256rrikz = 4887, + X86_VFIXUPIMMPDZrmbi = 4888, + X86_VFIXUPIMMPDZrmbik = 4889, + X86_VFIXUPIMMPDZrmbikz = 4890, + X86_VFIXUPIMMPDZrmi = 4891, + X86_VFIXUPIMMPDZrmik = 4892, + X86_VFIXUPIMMPDZrmikz = 4893, + X86_VFIXUPIMMPDZrri = 4894, + X86_VFIXUPIMMPDZrrib = 4895, + X86_VFIXUPIMMPDZrribk = 4896, + X86_VFIXUPIMMPDZrribkz = 4897, + X86_VFIXUPIMMPDZrrik = 4898, + X86_VFIXUPIMMPDZrrikz = 4899, + X86_VFIXUPIMMPSZ128rmbi = 4900, + X86_VFIXUPIMMPSZ128rmbik = 4901, + X86_VFIXUPIMMPSZ128rmbikz = 4902, + X86_VFIXUPIMMPSZ128rmi = 4903, + X86_VFIXUPIMMPSZ128rmik = 4904, + X86_VFIXUPIMMPSZ128rmikz = 4905, + X86_VFIXUPIMMPSZ128rri = 4906, + X86_VFIXUPIMMPSZ128rrik = 4907, + X86_VFIXUPIMMPSZ128rrikz = 4908, + X86_VFIXUPIMMPSZ256rmbi = 4909, + X86_VFIXUPIMMPSZ256rmbik = 4910, + X86_VFIXUPIMMPSZ256rmbikz = 4911, + X86_VFIXUPIMMPSZ256rmi = 4912, + X86_VFIXUPIMMPSZ256rmik = 4913, + X86_VFIXUPIMMPSZ256rmikz = 4914, + X86_VFIXUPIMMPSZ256rri = 4915, + X86_VFIXUPIMMPSZ256rrik = 4916, + X86_VFIXUPIMMPSZ256rrikz = 4917, + X86_VFIXUPIMMPSZrmbi = 4918, + X86_VFIXUPIMMPSZrmbik = 4919, + X86_VFIXUPIMMPSZrmbikz = 4920, + X86_VFIXUPIMMPSZrmi = 4921, + X86_VFIXUPIMMPSZrmik = 4922, + X86_VFIXUPIMMPSZrmikz = 4923, + X86_VFIXUPIMMPSZrri = 4924, + X86_VFIXUPIMMPSZrrib = 4925, + X86_VFIXUPIMMPSZrribk = 4926, + X86_VFIXUPIMMPSZrribkz = 4927, + X86_VFIXUPIMMPSZrrik = 4928, + X86_VFIXUPIMMPSZrrikz = 4929, + X86_VFIXUPIMMSDZrmi = 4930, + X86_VFIXUPIMMSDZrmik = 4931, + X86_VFIXUPIMMSDZrmikz = 4932, + X86_VFIXUPIMMSDZrri = 4933, + X86_VFIXUPIMMSDZrrib = 4934, + X86_VFIXUPIMMSDZrribk = 4935, + X86_VFIXUPIMMSDZrribkz = 4936, + X86_VFIXUPIMMSDZrrik = 4937, + X86_VFIXUPIMMSDZrrikz = 4938, + X86_VFIXUPIMMSSZrmi = 4939, + X86_VFIXUPIMMSSZrmik = 4940, + X86_VFIXUPIMMSSZrmikz = 4941, + X86_VFIXUPIMMSSZrri = 4942, + X86_VFIXUPIMMSSZrrib = 4943, + X86_VFIXUPIMMSSZrribk = 4944, + X86_VFIXUPIMMSSZrribkz = 4945, + X86_VFIXUPIMMSSZrrik = 4946, + X86_VFIXUPIMMSSZrrikz = 4947, + X86_VFMADD132PDYm = 4948, + X86_VFMADD132PDYr = 4949, + X86_VFMADD132PDZ128m = 4950, + X86_VFMADD132PDZ128mb = 4951, + X86_VFMADD132PDZ128mbk = 4952, + X86_VFMADD132PDZ128mbkz = 4953, + X86_VFMADD132PDZ128mk = 4954, + X86_VFMADD132PDZ128mkz = 4955, + X86_VFMADD132PDZ128r = 4956, + X86_VFMADD132PDZ128rk = 4957, + X86_VFMADD132PDZ128rkz = 4958, + X86_VFMADD132PDZ256m = 4959, + X86_VFMADD132PDZ256mb = 4960, + X86_VFMADD132PDZ256mbk = 4961, + X86_VFMADD132PDZ256mbkz = 4962, + X86_VFMADD132PDZ256mk = 4963, + X86_VFMADD132PDZ256mkz = 4964, + X86_VFMADD132PDZ256r = 4965, + X86_VFMADD132PDZ256rk = 4966, + X86_VFMADD132PDZ256rkz = 4967, + X86_VFMADD132PDZm = 4968, + X86_VFMADD132PDZmb = 4969, + X86_VFMADD132PDZmbk = 4970, + X86_VFMADD132PDZmbkz = 4971, + X86_VFMADD132PDZmk = 4972, + X86_VFMADD132PDZmkz = 4973, + X86_VFMADD132PDZr = 4974, + X86_VFMADD132PDZrb = 4975, + X86_VFMADD132PDZrbk = 4976, + X86_VFMADD132PDZrbkz = 4977, + X86_VFMADD132PDZrk = 4978, + X86_VFMADD132PDZrkz = 4979, + X86_VFMADD132PDm = 4980, + X86_VFMADD132PDr = 4981, + X86_VFMADD132PSYm = 4982, + X86_VFMADD132PSYr = 4983, + X86_VFMADD132PSZ128m = 4984, + X86_VFMADD132PSZ128mb = 4985, + X86_VFMADD132PSZ128mbk = 4986, + X86_VFMADD132PSZ128mbkz = 4987, + X86_VFMADD132PSZ128mk = 4988, + X86_VFMADD132PSZ128mkz = 4989, + X86_VFMADD132PSZ128r = 4990, + X86_VFMADD132PSZ128rk = 4991, + X86_VFMADD132PSZ128rkz = 4992, + X86_VFMADD132PSZ256m = 4993, + X86_VFMADD132PSZ256mb = 4994, + X86_VFMADD132PSZ256mbk = 4995, + X86_VFMADD132PSZ256mbkz = 4996, + X86_VFMADD132PSZ256mk = 4997, + X86_VFMADD132PSZ256mkz = 4998, + X86_VFMADD132PSZ256r = 4999, + X86_VFMADD132PSZ256rk = 5000, + X86_VFMADD132PSZ256rkz = 5001, + X86_VFMADD132PSZm = 5002, + X86_VFMADD132PSZmb = 5003, + X86_VFMADD132PSZmbk = 5004, + X86_VFMADD132PSZmbkz = 5005, + X86_VFMADD132PSZmk = 5006, + X86_VFMADD132PSZmkz = 5007, + X86_VFMADD132PSZr = 5008, + X86_VFMADD132PSZrb = 5009, + X86_VFMADD132PSZrbk = 5010, + X86_VFMADD132PSZrbkz = 5011, + X86_VFMADD132PSZrk = 5012, + X86_VFMADD132PSZrkz = 5013, + X86_VFMADD132PSm = 5014, + X86_VFMADD132PSr = 5015, + X86_VFMADD132SDZm = 5016, + X86_VFMADD132SDZm_Int = 5017, + X86_VFMADD132SDZm_Intk = 5018, + X86_VFMADD132SDZm_Intkz = 5019, + X86_VFMADD132SDZr = 5020, + X86_VFMADD132SDZr_Int = 5021, + X86_VFMADD132SDZr_Intk = 5022, + X86_VFMADD132SDZr_Intkz = 5023, + X86_VFMADD132SDZrb = 5024, + X86_VFMADD132SDZrb_Int = 5025, + X86_VFMADD132SDZrb_Intk = 5026, + X86_VFMADD132SDZrb_Intkz = 5027, + X86_VFMADD132SDm = 5028, + X86_VFMADD132SDm_Int = 5029, + X86_VFMADD132SDr = 5030, + X86_VFMADD132SDr_Int = 5031, + X86_VFMADD132SSZm = 5032, + X86_VFMADD132SSZm_Int = 5033, + X86_VFMADD132SSZm_Intk = 5034, + X86_VFMADD132SSZm_Intkz = 5035, + X86_VFMADD132SSZr = 5036, + X86_VFMADD132SSZr_Int = 5037, + X86_VFMADD132SSZr_Intk = 5038, + X86_VFMADD132SSZr_Intkz = 5039, + X86_VFMADD132SSZrb = 5040, + X86_VFMADD132SSZrb_Int = 5041, + X86_VFMADD132SSZrb_Intk = 5042, + X86_VFMADD132SSZrb_Intkz = 5043, + X86_VFMADD132SSm = 5044, + X86_VFMADD132SSm_Int = 5045, + X86_VFMADD132SSr = 5046, + X86_VFMADD132SSr_Int = 5047, + X86_VFMADD213PDYm = 5048, + X86_VFMADD213PDYr = 5049, + X86_VFMADD213PDZ128m = 5050, + X86_VFMADD213PDZ128mb = 5051, + X86_VFMADD213PDZ128mbk = 5052, + X86_VFMADD213PDZ128mbkz = 5053, + X86_VFMADD213PDZ128mk = 5054, + X86_VFMADD213PDZ128mkz = 5055, + X86_VFMADD213PDZ128r = 5056, + X86_VFMADD213PDZ128rk = 5057, + X86_VFMADD213PDZ128rkz = 5058, + X86_VFMADD213PDZ256m = 5059, + X86_VFMADD213PDZ256mb = 5060, + X86_VFMADD213PDZ256mbk = 5061, + X86_VFMADD213PDZ256mbkz = 5062, + X86_VFMADD213PDZ256mk = 5063, + X86_VFMADD213PDZ256mkz = 5064, + X86_VFMADD213PDZ256r = 5065, + X86_VFMADD213PDZ256rk = 5066, + X86_VFMADD213PDZ256rkz = 5067, + X86_VFMADD213PDZm = 5068, + X86_VFMADD213PDZmb = 5069, + X86_VFMADD213PDZmbk = 5070, + X86_VFMADD213PDZmbkz = 5071, + X86_VFMADD213PDZmk = 5072, + X86_VFMADD213PDZmkz = 5073, + X86_VFMADD213PDZr = 5074, + X86_VFMADD213PDZrb = 5075, + X86_VFMADD213PDZrbk = 5076, + X86_VFMADD213PDZrbkz = 5077, + X86_VFMADD213PDZrk = 5078, + X86_VFMADD213PDZrkz = 5079, + X86_VFMADD213PDm = 5080, + X86_VFMADD213PDr = 5081, + X86_VFMADD213PSYm = 5082, + X86_VFMADD213PSYr = 5083, + X86_VFMADD213PSZ128m = 5084, + X86_VFMADD213PSZ128mb = 5085, + X86_VFMADD213PSZ128mbk = 5086, + X86_VFMADD213PSZ128mbkz = 5087, + X86_VFMADD213PSZ128mk = 5088, + X86_VFMADD213PSZ128mkz = 5089, + X86_VFMADD213PSZ128r = 5090, + X86_VFMADD213PSZ128rk = 5091, + X86_VFMADD213PSZ128rkz = 5092, + X86_VFMADD213PSZ256m = 5093, + X86_VFMADD213PSZ256mb = 5094, + X86_VFMADD213PSZ256mbk = 5095, + X86_VFMADD213PSZ256mbkz = 5096, + X86_VFMADD213PSZ256mk = 5097, + X86_VFMADD213PSZ256mkz = 5098, + X86_VFMADD213PSZ256r = 5099, + X86_VFMADD213PSZ256rk = 5100, + X86_VFMADD213PSZ256rkz = 5101, + X86_VFMADD213PSZm = 5102, + X86_VFMADD213PSZmb = 5103, + X86_VFMADD213PSZmbk = 5104, + X86_VFMADD213PSZmbkz = 5105, + X86_VFMADD213PSZmk = 5106, + X86_VFMADD213PSZmkz = 5107, + X86_VFMADD213PSZr = 5108, + X86_VFMADD213PSZrb = 5109, + X86_VFMADD213PSZrbk = 5110, + X86_VFMADD213PSZrbkz = 5111, + X86_VFMADD213PSZrk = 5112, + X86_VFMADD213PSZrkz = 5113, + X86_VFMADD213PSm = 5114, + X86_VFMADD213PSr = 5115, + X86_VFMADD213SDZm = 5116, + X86_VFMADD213SDZm_Int = 5117, + X86_VFMADD213SDZm_Intk = 5118, + X86_VFMADD213SDZm_Intkz = 5119, + X86_VFMADD213SDZr = 5120, + X86_VFMADD213SDZr_Int = 5121, + X86_VFMADD213SDZr_Intk = 5122, + X86_VFMADD213SDZr_Intkz = 5123, + X86_VFMADD213SDZrb = 5124, + X86_VFMADD213SDZrb_Int = 5125, + X86_VFMADD213SDZrb_Intk = 5126, + X86_VFMADD213SDZrb_Intkz = 5127, + X86_VFMADD213SDm = 5128, + X86_VFMADD213SDm_Int = 5129, + X86_VFMADD213SDr = 5130, + X86_VFMADD213SDr_Int = 5131, + X86_VFMADD213SSZm = 5132, + X86_VFMADD213SSZm_Int = 5133, + X86_VFMADD213SSZm_Intk = 5134, + X86_VFMADD213SSZm_Intkz = 5135, + X86_VFMADD213SSZr = 5136, + X86_VFMADD213SSZr_Int = 5137, + X86_VFMADD213SSZr_Intk = 5138, + X86_VFMADD213SSZr_Intkz = 5139, + X86_VFMADD213SSZrb = 5140, + X86_VFMADD213SSZrb_Int = 5141, + X86_VFMADD213SSZrb_Intk = 5142, + X86_VFMADD213SSZrb_Intkz = 5143, + X86_VFMADD213SSm = 5144, + X86_VFMADD213SSm_Int = 5145, + X86_VFMADD213SSr = 5146, + X86_VFMADD213SSr_Int = 5147, + X86_VFMADD231PDYm = 5148, + X86_VFMADD231PDYr = 5149, + X86_VFMADD231PDZ128m = 5150, + X86_VFMADD231PDZ128mb = 5151, + X86_VFMADD231PDZ128mbk = 5152, + X86_VFMADD231PDZ128mbkz = 5153, + X86_VFMADD231PDZ128mk = 5154, + X86_VFMADD231PDZ128mkz = 5155, + X86_VFMADD231PDZ128r = 5156, + X86_VFMADD231PDZ128rk = 5157, + X86_VFMADD231PDZ128rkz = 5158, + X86_VFMADD231PDZ256m = 5159, + X86_VFMADD231PDZ256mb = 5160, + X86_VFMADD231PDZ256mbk = 5161, + X86_VFMADD231PDZ256mbkz = 5162, + X86_VFMADD231PDZ256mk = 5163, + X86_VFMADD231PDZ256mkz = 5164, + X86_VFMADD231PDZ256r = 5165, + X86_VFMADD231PDZ256rk = 5166, + X86_VFMADD231PDZ256rkz = 5167, + X86_VFMADD231PDZm = 5168, + X86_VFMADD231PDZmb = 5169, + X86_VFMADD231PDZmbk = 5170, + X86_VFMADD231PDZmbkz = 5171, + X86_VFMADD231PDZmk = 5172, + X86_VFMADD231PDZmkz = 5173, + X86_VFMADD231PDZr = 5174, + X86_VFMADD231PDZrb = 5175, + X86_VFMADD231PDZrbk = 5176, + X86_VFMADD231PDZrbkz = 5177, + X86_VFMADD231PDZrk = 5178, + X86_VFMADD231PDZrkz = 5179, + X86_VFMADD231PDm = 5180, + X86_VFMADD231PDr = 5181, + X86_VFMADD231PSYm = 5182, + X86_VFMADD231PSYr = 5183, + X86_VFMADD231PSZ128m = 5184, + X86_VFMADD231PSZ128mb = 5185, + X86_VFMADD231PSZ128mbk = 5186, + X86_VFMADD231PSZ128mbkz = 5187, + X86_VFMADD231PSZ128mk = 5188, + X86_VFMADD231PSZ128mkz = 5189, + X86_VFMADD231PSZ128r = 5190, + X86_VFMADD231PSZ128rk = 5191, + X86_VFMADD231PSZ128rkz = 5192, + X86_VFMADD231PSZ256m = 5193, + X86_VFMADD231PSZ256mb = 5194, + X86_VFMADD231PSZ256mbk = 5195, + X86_VFMADD231PSZ256mbkz = 5196, + X86_VFMADD231PSZ256mk = 5197, + X86_VFMADD231PSZ256mkz = 5198, + X86_VFMADD231PSZ256r = 5199, + X86_VFMADD231PSZ256rk = 5200, + X86_VFMADD231PSZ256rkz = 5201, + X86_VFMADD231PSZm = 5202, + X86_VFMADD231PSZmb = 5203, + X86_VFMADD231PSZmbk = 5204, + X86_VFMADD231PSZmbkz = 5205, + X86_VFMADD231PSZmk = 5206, + X86_VFMADD231PSZmkz = 5207, + X86_VFMADD231PSZr = 5208, + X86_VFMADD231PSZrb = 5209, + X86_VFMADD231PSZrbk = 5210, + X86_VFMADD231PSZrbkz = 5211, + X86_VFMADD231PSZrk = 5212, + X86_VFMADD231PSZrkz = 5213, + X86_VFMADD231PSm = 5214, + X86_VFMADD231PSr = 5215, + X86_VFMADD231SDZm = 5216, + X86_VFMADD231SDZm_Int = 5217, + X86_VFMADD231SDZm_Intk = 5218, + X86_VFMADD231SDZm_Intkz = 5219, + X86_VFMADD231SDZr = 5220, + X86_VFMADD231SDZr_Int = 5221, + X86_VFMADD231SDZr_Intk = 5222, + X86_VFMADD231SDZr_Intkz = 5223, + X86_VFMADD231SDZrb = 5224, + X86_VFMADD231SDZrb_Int = 5225, + X86_VFMADD231SDZrb_Intk = 5226, + X86_VFMADD231SDZrb_Intkz = 5227, + X86_VFMADD231SDm = 5228, + X86_VFMADD231SDm_Int = 5229, + X86_VFMADD231SDr = 5230, + X86_VFMADD231SDr_Int = 5231, + X86_VFMADD231SSZm = 5232, + X86_VFMADD231SSZm_Int = 5233, + X86_VFMADD231SSZm_Intk = 5234, + X86_VFMADD231SSZm_Intkz = 5235, + X86_VFMADD231SSZr = 5236, + X86_VFMADD231SSZr_Int = 5237, + X86_VFMADD231SSZr_Intk = 5238, + X86_VFMADD231SSZr_Intkz = 5239, + X86_VFMADD231SSZrb = 5240, + X86_VFMADD231SSZrb_Int = 5241, + X86_VFMADD231SSZrb_Intk = 5242, + X86_VFMADD231SSZrb_Intkz = 5243, + X86_VFMADD231SSm = 5244, + X86_VFMADD231SSm_Int = 5245, + X86_VFMADD231SSr = 5246, + X86_VFMADD231SSr_Int = 5247, + X86_VFMADDPD4Ymr = 5248, + X86_VFMADDPD4Yrm = 5249, + X86_VFMADDPD4Yrr = 5250, + X86_VFMADDPD4Yrr_REV = 5251, + X86_VFMADDPD4mr = 5252, + X86_VFMADDPD4rm = 5253, + X86_VFMADDPD4rr = 5254, + X86_VFMADDPD4rr_REV = 5255, + X86_VFMADDPS4Ymr = 5256, + X86_VFMADDPS4Yrm = 5257, + X86_VFMADDPS4Yrr = 5258, + X86_VFMADDPS4Yrr_REV = 5259, + X86_VFMADDPS4mr = 5260, + X86_VFMADDPS4rm = 5261, + X86_VFMADDPS4rr = 5262, + X86_VFMADDPS4rr_REV = 5263, + X86_VFMADDSD4mr = 5264, + X86_VFMADDSD4mr_Int = 5265, + X86_VFMADDSD4rm = 5266, + X86_VFMADDSD4rm_Int = 5267, + X86_VFMADDSD4rr = 5268, + X86_VFMADDSD4rr_Int = 5269, + X86_VFMADDSD4rr_Int_REV = 5270, + X86_VFMADDSD4rr_REV = 5271, + X86_VFMADDSS4mr = 5272, + X86_VFMADDSS4mr_Int = 5273, + X86_VFMADDSS4rm = 5274, + X86_VFMADDSS4rm_Int = 5275, + X86_VFMADDSS4rr = 5276, + X86_VFMADDSS4rr_Int = 5277, + X86_VFMADDSS4rr_Int_REV = 5278, + X86_VFMADDSS4rr_REV = 5279, + X86_VFMADDSUB132PDYm = 5280, + X86_VFMADDSUB132PDYr = 5281, + X86_VFMADDSUB132PDZ128m = 5282, + X86_VFMADDSUB132PDZ128mb = 5283, + X86_VFMADDSUB132PDZ128mbk = 5284, + X86_VFMADDSUB132PDZ128mbkz = 5285, + X86_VFMADDSUB132PDZ128mk = 5286, + X86_VFMADDSUB132PDZ128mkz = 5287, + X86_VFMADDSUB132PDZ128r = 5288, + X86_VFMADDSUB132PDZ128rk = 5289, + X86_VFMADDSUB132PDZ128rkz = 5290, + X86_VFMADDSUB132PDZ256m = 5291, + X86_VFMADDSUB132PDZ256mb = 5292, + X86_VFMADDSUB132PDZ256mbk = 5293, + X86_VFMADDSUB132PDZ256mbkz = 5294, + X86_VFMADDSUB132PDZ256mk = 5295, + X86_VFMADDSUB132PDZ256mkz = 5296, + X86_VFMADDSUB132PDZ256r = 5297, + X86_VFMADDSUB132PDZ256rk = 5298, + X86_VFMADDSUB132PDZ256rkz = 5299, + X86_VFMADDSUB132PDZm = 5300, + X86_VFMADDSUB132PDZmb = 5301, + X86_VFMADDSUB132PDZmbk = 5302, + X86_VFMADDSUB132PDZmbkz = 5303, + X86_VFMADDSUB132PDZmk = 5304, + X86_VFMADDSUB132PDZmkz = 5305, + X86_VFMADDSUB132PDZr = 5306, + X86_VFMADDSUB132PDZrb = 5307, + X86_VFMADDSUB132PDZrbk = 5308, + X86_VFMADDSUB132PDZrbkz = 5309, + X86_VFMADDSUB132PDZrk = 5310, + X86_VFMADDSUB132PDZrkz = 5311, + X86_VFMADDSUB132PDm = 5312, + X86_VFMADDSUB132PDr = 5313, + X86_VFMADDSUB132PSYm = 5314, + X86_VFMADDSUB132PSYr = 5315, + X86_VFMADDSUB132PSZ128m = 5316, + X86_VFMADDSUB132PSZ128mb = 5317, + X86_VFMADDSUB132PSZ128mbk = 5318, + X86_VFMADDSUB132PSZ128mbkz = 5319, + X86_VFMADDSUB132PSZ128mk = 5320, + X86_VFMADDSUB132PSZ128mkz = 5321, + X86_VFMADDSUB132PSZ128r = 5322, + X86_VFMADDSUB132PSZ128rk = 5323, + X86_VFMADDSUB132PSZ128rkz = 5324, + X86_VFMADDSUB132PSZ256m = 5325, + X86_VFMADDSUB132PSZ256mb = 5326, + X86_VFMADDSUB132PSZ256mbk = 5327, + X86_VFMADDSUB132PSZ256mbkz = 5328, + X86_VFMADDSUB132PSZ256mk = 5329, + X86_VFMADDSUB132PSZ256mkz = 5330, + X86_VFMADDSUB132PSZ256r = 5331, + X86_VFMADDSUB132PSZ256rk = 5332, + X86_VFMADDSUB132PSZ256rkz = 5333, + X86_VFMADDSUB132PSZm = 5334, + X86_VFMADDSUB132PSZmb = 5335, + X86_VFMADDSUB132PSZmbk = 5336, + X86_VFMADDSUB132PSZmbkz = 5337, + X86_VFMADDSUB132PSZmk = 5338, + X86_VFMADDSUB132PSZmkz = 5339, + X86_VFMADDSUB132PSZr = 5340, + X86_VFMADDSUB132PSZrb = 5341, + X86_VFMADDSUB132PSZrbk = 5342, + X86_VFMADDSUB132PSZrbkz = 5343, + X86_VFMADDSUB132PSZrk = 5344, + X86_VFMADDSUB132PSZrkz = 5345, + X86_VFMADDSUB132PSm = 5346, + X86_VFMADDSUB132PSr = 5347, + X86_VFMADDSUB213PDYm = 5348, + X86_VFMADDSUB213PDYr = 5349, + X86_VFMADDSUB213PDZ128m = 5350, + X86_VFMADDSUB213PDZ128mb = 5351, + X86_VFMADDSUB213PDZ128mbk = 5352, + X86_VFMADDSUB213PDZ128mbkz = 5353, + X86_VFMADDSUB213PDZ128mk = 5354, + X86_VFMADDSUB213PDZ128mkz = 5355, + X86_VFMADDSUB213PDZ128r = 5356, + X86_VFMADDSUB213PDZ128rk = 5357, + X86_VFMADDSUB213PDZ128rkz = 5358, + X86_VFMADDSUB213PDZ256m = 5359, + X86_VFMADDSUB213PDZ256mb = 5360, + X86_VFMADDSUB213PDZ256mbk = 5361, + X86_VFMADDSUB213PDZ256mbkz = 5362, + X86_VFMADDSUB213PDZ256mk = 5363, + X86_VFMADDSUB213PDZ256mkz = 5364, + X86_VFMADDSUB213PDZ256r = 5365, + X86_VFMADDSUB213PDZ256rk = 5366, + X86_VFMADDSUB213PDZ256rkz = 5367, + X86_VFMADDSUB213PDZm = 5368, + X86_VFMADDSUB213PDZmb = 5369, + X86_VFMADDSUB213PDZmbk = 5370, + X86_VFMADDSUB213PDZmbkz = 5371, + X86_VFMADDSUB213PDZmk = 5372, + X86_VFMADDSUB213PDZmkz = 5373, + X86_VFMADDSUB213PDZr = 5374, + X86_VFMADDSUB213PDZrb = 5375, + X86_VFMADDSUB213PDZrbk = 5376, + X86_VFMADDSUB213PDZrbkz = 5377, + X86_VFMADDSUB213PDZrk = 5378, + X86_VFMADDSUB213PDZrkz = 5379, + X86_VFMADDSUB213PDm = 5380, + X86_VFMADDSUB213PDr = 5381, + X86_VFMADDSUB213PSYm = 5382, + X86_VFMADDSUB213PSYr = 5383, + X86_VFMADDSUB213PSZ128m = 5384, + X86_VFMADDSUB213PSZ128mb = 5385, + X86_VFMADDSUB213PSZ128mbk = 5386, + X86_VFMADDSUB213PSZ128mbkz = 5387, + X86_VFMADDSUB213PSZ128mk = 5388, + X86_VFMADDSUB213PSZ128mkz = 5389, + X86_VFMADDSUB213PSZ128r = 5390, + X86_VFMADDSUB213PSZ128rk = 5391, + X86_VFMADDSUB213PSZ128rkz = 5392, + X86_VFMADDSUB213PSZ256m = 5393, + X86_VFMADDSUB213PSZ256mb = 5394, + X86_VFMADDSUB213PSZ256mbk = 5395, + X86_VFMADDSUB213PSZ256mbkz = 5396, + X86_VFMADDSUB213PSZ256mk = 5397, + X86_VFMADDSUB213PSZ256mkz = 5398, + X86_VFMADDSUB213PSZ256r = 5399, + X86_VFMADDSUB213PSZ256rk = 5400, + X86_VFMADDSUB213PSZ256rkz = 5401, + X86_VFMADDSUB213PSZm = 5402, + X86_VFMADDSUB213PSZmb = 5403, + X86_VFMADDSUB213PSZmbk = 5404, + X86_VFMADDSUB213PSZmbkz = 5405, + X86_VFMADDSUB213PSZmk = 5406, + X86_VFMADDSUB213PSZmkz = 5407, + X86_VFMADDSUB213PSZr = 5408, + X86_VFMADDSUB213PSZrb = 5409, + X86_VFMADDSUB213PSZrbk = 5410, + X86_VFMADDSUB213PSZrbkz = 5411, + X86_VFMADDSUB213PSZrk = 5412, + X86_VFMADDSUB213PSZrkz = 5413, + X86_VFMADDSUB213PSm = 5414, + X86_VFMADDSUB213PSr = 5415, + X86_VFMADDSUB231PDYm = 5416, + X86_VFMADDSUB231PDYr = 5417, + X86_VFMADDSUB231PDZ128m = 5418, + X86_VFMADDSUB231PDZ128mb = 5419, + X86_VFMADDSUB231PDZ128mbk = 5420, + X86_VFMADDSUB231PDZ128mbkz = 5421, + X86_VFMADDSUB231PDZ128mk = 5422, + X86_VFMADDSUB231PDZ128mkz = 5423, + X86_VFMADDSUB231PDZ128r = 5424, + X86_VFMADDSUB231PDZ128rk = 5425, + X86_VFMADDSUB231PDZ128rkz = 5426, + X86_VFMADDSUB231PDZ256m = 5427, + X86_VFMADDSUB231PDZ256mb = 5428, + X86_VFMADDSUB231PDZ256mbk = 5429, + X86_VFMADDSUB231PDZ256mbkz = 5430, + X86_VFMADDSUB231PDZ256mk = 5431, + X86_VFMADDSUB231PDZ256mkz = 5432, + X86_VFMADDSUB231PDZ256r = 5433, + X86_VFMADDSUB231PDZ256rk = 5434, + X86_VFMADDSUB231PDZ256rkz = 5435, + X86_VFMADDSUB231PDZm = 5436, + X86_VFMADDSUB231PDZmb = 5437, + X86_VFMADDSUB231PDZmbk = 5438, + X86_VFMADDSUB231PDZmbkz = 5439, + X86_VFMADDSUB231PDZmk = 5440, + X86_VFMADDSUB231PDZmkz = 5441, + X86_VFMADDSUB231PDZr = 5442, + X86_VFMADDSUB231PDZrb = 5443, + X86_VFMADDSUB231PDZrbk = 5444, + X86_VFMADDSUB231PDZrbkz = 5445, + X86_VFMADDSUB231PDZrk = 5446, + X86_VFMADDSUB231PDZrkz = 5447, + X86_VFMADDSUB231PDm = 5448, + X86_VFMADDSUB231PDr = 5449, + X86_VFMADDSUB231PSYm = 5450, + X86_VFMADDSUB231PSYr = 5451, + X86_VFMADDSUB231PSZ128m = 5452, + X86_VFMADDSUB231PSZ128mb = 5453, + X86_VFMADDSUB231PSZ128mbk = 5454, + X86_VFMADDSUB231PSZ128mbkz = 5455, + X86_VFMADDSUB231PSZ128mk = 5456, + X86_VFMADDSUB231PSZ128mkz = 5457, + X86_VFMADDSUB231PSZ128r = 5458, + X86_VFMADDSUB231PSZ128rk = 5459, + X86_VFMADDSUB231PSZ128rkz = 5460, + X86_VFMADDSUB231PSZ256m = 5461, + X86_VFMADDSUB231PSZ256mb = 5462, + X86_VFMADDSUB231PSZ256mbk = 5463, + X86_VFMADDSUB231PSZ256mbkz = 5464, + X86_VFMADDSUB231PSZ256mk = 5465, + X86_VFMADDSUB231PSZ256mkz = 5466, + X86_VFMADDSUB231PSZ256r = 5467, + X86_VFMADDSUB231PSZ256rk = 5468, + X86_VFMADDSUB231PSZ256rkz = 5469, + X86_VFMADDSUB231PSZm = 5470, + X86_VFMADDSUB231PSZmb = 5471, + X86_VFMADDSUB231PSZmbk = 5472, + X86_VFMADDSUB231PSZmbkz = 5473, + X86_VFMADDSUB231PSZmk = 5474, + X86_VFMADDSUB231PSZmkz = 5475, + X86_VFMADDSUB231PSZr = 5476, + X86_VFMADDSUB231PSZrb = 5477, + X86_VFMADDSUB231PSZrbk = 5478, + X86_VFMADDSUB231PSZrbkz = 5479, + X86_VFMADDSUB231PSZrk = 5480, + X86_VFMADDSUB231PSZrkz = 5481, + X86_VFMADDSUB231PSm = 5482, + X86_VFMADDSUB231PSr = 5483, + X86_VFMADDSUBPD4Ymr = 5484, + X86_VFMADDSUBPD4Yrm = 5485, + X86_VFMADDSUBPD4Yrr = 5486, + X86_VFMADDSUBPD4Yrr_REV = 5487, + X86_VFMADDSUBPD4mr = 5488, + X86_VFMADDSUBPD4rm = 5489, + X86_VFMADDSUBPD4rr = 5490, + X86_VFMADDSUBPD4rr_REV = 5491, + X86_VFMADDSUBPS4Ymr = 5492, + X86_VFMADDSUBPS4Yrm = 5493, + X86_VFMADDSUBPS4Yrr = 5494, + X86_VFMADDSUBPS4Yrr_REV = 5495, + X86_VFMADDSUBPS4mr = 5496, + X86_VFMADDSUBPS4rm = 5497, + X86_VFMADDSUBPS4rr = 5498, + X86_VFMADDSUBPS4rr_REV = 5499, + X86_VFMSUB132PDYm = 5500, + X86_VFMSUB132PDYr = 5501, + X86_VFMSUB132PDZ128m = 5502, + X86_VFMSUB132PDZ128mb = 5503, + X86_VFMSUB132PDZ128mbk = 5504, + X86_VFMSUB132PDZ128mbkz = 5505, + X86_VFMSUB132PDZ128mk = 5506, + X86_VFMSUB132PDZ128mkz = 5507, + X86_VFMSUB132PDZ128r = 5508, + X86_VFMSUB132PDZ128rk = 5509, + X86_VFMSUB132PDZ128rkz = 5510, + X86_VFMSUB132PDZ256m = 5511, + X86_VFMSUB132PDZ256mb = 5512, + X86_VFMSUB132PDZ256mbk = 5513, + X86_VFMSUB132PDZ256mbkz = 5514, + X86_VFMSUB132PDZ256mk = 5515, + X86_VFMSUB132PDZ256mkz = 5516, + X86_VFMSUB132PDZ256r = 5517, + X86_VFMSUB132PDZ256rk = 5518, + X86_VFMSUB132PDZ256rkz = 5519, + X86_VFMSUB132PDZm = 5520, + X86_VFMSUB132PDZmb = 5521, + X86_VFMSUB132PDZmbk = 5522, + X86_VFMSUB132PDZmbkz = 5523, + X86_VFMSUB132PDZmk = 5524, + X86_VFMSUB132PDZmkz = 5525, + X86_VFMSUB132PDZr = 5526, + X86_VFMSUB132PDZrb = 5527, + X86_VFMSUB132PDZrbk = 5528, + X86_VFMSUB132PDZrbkz = 5529, + X86_VFMSUB132PDZrk = 5530, + X86_VFMSUB132PDZrkz = 5531, + X86_VFMSUB132PDm = 5532, + X86_VFMSUB132PDr = 5533, + X86_VFMSUB132PSYm = 5534, + X86_VFMSUB132PSYr = 5535, + X86_VFMSUB132PSZ128m = 5536, + X86_VFMSUB132PSZ128mb = 5537, + X86_VFMSUB132PSZ128mbk = 5538, + X86_VFMSUB132PSZ128mbkz = 5539, + X86_VFMSUB132PSZ128mk = 5540, + X86_VFMSUB132PSZ128mkz = 5541, + X86_VFMSUB132PSZ128r = 5542, + X86_VFMSUB132PSZ128rk = 5543, + X86_VFMSUB132PSZ128rkz = 5544, + X86_VFMSUB132PSZ256m = 5545, + X86_VFMSUB132PSZ256mb = 5546, + X86_VFMSUB132PSZ256mbk = 5547, + X86_VFMSUB132PSZ256mbkz = 5548, + X86_VFMSUB132PSZ256mk = 5549, + X86_VFMSUB132PSZ256mkz = 5550, + X86_VFMSUB132PSZ256r = 5551, + X86_VFMSUB132PSZ256rk = 5552, + X86_VFMSUB132PSZ256rkz = 5553, + X86_VFMSUB132PSZm = 5554, + X86_VFMSUB132PSZmb = 5555, + X86_VFMSUB132PSZmbk = 5556, + X86_VFMSUB132PSZmbkz = 5557, + X86_VFMSUB132PSZmk = 5558, + X86_VFMSUB132PSZmkz = 5559, + X86_VFMSUB132PSZr = 5560, + X86_VFMSUB132PSZrb = 5561, + X86_VFMSUB132PSZrbk = 5562, + X86_VFMSUB132PSZrbkz = 5563, + X86_VFMSUB132PSZrk = 5564, + X86_VFMSUB132PSZrkz = 5565, + X86_VFMSUB132PSm = 5566, + X86_VFMSUB132PSr = 5567, + X86_VFMSUB132SDZm = 5568, + X86_VFMSUB132SDZm_Int = 5569, + X86_VFMSUB132SDZm_Intk = 5570, + X86_VFMSUB132SDZm_Intkz = 5571, + X86_VFMSUB132SDZr = 5572, + X86_VFMSUB132SDZr_Int = 5573, + X86_VFMSUB132SDZr_Intk = 5574, + X86_VFMSUB132SDZr_Intkz = 5575, + X86_VFMSUB132SDZrb = 5576, + X86_VFMSUB132SDZrb_Int = 5577, + X86_VFMSUB132SDZrb_Intk = 5578, + X86_VFMSUB132SDZrb_Intkz = 5579, + X86_VFMSUB132SDm = 5580, + X86_VFMSUB132SDm_Int = 5581, + X86_VFMSUB132SDr = 5582, + X86_VFMSUB132SDr_Int = 5583, + X86_VFMSUB132SSZm = 5584, + X86_VFMSUB132SSZm_Int = 5585, + X86_VFMSUB132SSZm_Intk = 5586, + X86_VFMSUB132SSZm_Intkz = 5587, + X86_VFMSUB132SSZr = 5588, + X86_VFMSUB132SSZr_Int = 5589, + X86_VFMSUB132SSZr_Intk = 5590, + X86_VFMSUB132SSZr_Intkz = 5591, + X86_VFMSUB132SSZrb = 5592, + X86_VFMSUB132SSZrb_Int = 5593, + X86_VFMSUB132SSZrb_Intk = 5594, + X86_VFMSUB132SSZrb_Intkz = 5595, + X86_VFMSUB132SSm = 5596, + X86_VFMSUB132SSm_Int = 5597, + X86_VFMSUB132SSr = 5598, + X86_VFMSUB132SSr_Int = 5599, + X86_VFMSUB213PDYm = 5600, + X86_VFMSUB213PDYr = 5601, + X86_VFMSUB213PDZ128m = 5602, + X86_VFMSUB213PDZ128mb = 5603, + X86_VFMSUB213PDZ128mbk = 5604, + X86_VFMSUB213PDZ128mbkz = 5605, + X86_VFMSUB213PDZ128mk = 5606, + X86_VFMSUB213PDZ128mkz = 5607, + X86_VFMSUB213PDZ128r = 5608, + X86_VFMSUB213PDZ128rk = 5609, + X86_VFMSUB213PDZ128rkz = 5610, + X86_VFMSUB213PDZ256m = 5611, + X86_VFMSUB213PDZ256mb = 5612, + X86_VFMSUB213PDZ256mbk = 5613, + X86_VFMSUB213PDZ256mbkz = 5614, + X86_VFMSUB213PDZ256mk = 5615, + X86_VFMSUB213PDZ256mkz = 5616, + X86_VFMSUB213PDZ256r = 5617, + X86_VFMSUB213PDZ256rk = 5618, + X86_VFMSUB213PDZ256rkz = 5619, + X86_VFMSUB213PDZm = 5620, + X86_VFMSUB213PDZmb = 5621, + X86_VFMSUB213PDZmbk = 5622, + X86_VFMSUB213PDZmbkz = 5623, + X86_VFMSUB213PDZmk = 5624, + X86_VFMSUB213PDZmkz = 5625, + X86_VFMSUB213PDZr = 5626, + X86_VFMSUB213PDZrb = 5627, + X86_VFMSUB213PDZrbk = 5628, + X86_VFMSUB213PDZrbkz = 5629, + X86_VFMSUB213PDZrk = 5630, + X86_VFMSUB213PDZrkz = 5631, + X86_VFMSUB213PDm = 5632, + X86_VFMSUB213PDr = 5633, + X86_VFMSUB213PSYm = 5634, + X86_VFMSUB213PSYr = 5635, + X86_VFMSUB213PSZ128m = 5636, + X86_VFMSUB213PSZ128mb = 5637, + X86_VFMSUB213PSZ128mbk = 5638, + X86_VFMSUB213PSZ128mbkz = 5639, + X86_VFMSUB213PSZ128mk = 5640, + X86_VFMSUB213PSZ128mkz = 5641, + X86_VFMSUB213PSZ128r = 5642, + X86_VFMSUB213PSZ128rk = 5643, + X86_VFMSUB213PSZ128rkz = 5644, + X86_VFMSUB213PSZ256m = 5645, + X86_VFMSUB213PSZ256mb = 5646, + X86_VFMSUB213PSZ256mbk = 5647, + X86_VFMSUB213PSZ256mbkz = 5648, + X86_VFMSUB213PSZ256mk = 5649, + X86_VFMSUB213PSZ256mkz = 5650, + X86_VFMSUB213PSZ256r = 5651, + X86_VFMSUB213PSZ256rk = 5652, + X86_VFMSUB213PSZ256rkz = 5653, + X86_VFMSUB213PSZm = 5654, + X86_VFMSUB213PSZmb = 5655, + X86_VFMSUB213PSZmbk = 5656, + X86_VFMSUB213PSZmbkz = 5657, + X86_VFMSUB213PSZmk = 5658, + X86_VFMSUB213PSZmkz = 5659, + X86_VFMSUB213PSZr = 5660, + X86_VFMSUB213PSZrb = 5661, + X86_VFMSUB213PSZrbk = 5662, + X86_VFMSUB213PSZrbkz = 5663, + X86_VFMSUB213PSZrk = 5664, + X86_VFMSUB213PSZrkz = 5665, + X86_VFMSUB213PSm = 5666, + X86_VFMSUB213PSr = 5667, + X86_VFMSUB213SDZm = 5668, + X86_VFMSUB213SDZm_Int = 5669, + X86_VFMSUB213SDZm_Intk = 5670, + X86_VFMSUB213SDZm_Intkz = 5671, + X86_VFMSUB213SDZr = 5672, + X86_VFMSUB213SDZr_Int = 5673, + X86_VFMSUB213SDZr_Intk = 5674, + X86_VFMSUB213SDZr_Intkz = 5675, + X86_VFMSUB213SDZrb = 5676, + X86_VFMSUB213SDZrb_Int = 5677, + X86_VFMSUB213SDZrb_Intk = 5678, + X86_VFMSUB213SDZrb_Intkz = 5679, + X86_VFMSUB213SDm = 5680, + X86_VFMSUB213SDm_Int = 5681, + X86_VFMSUB213SDr = 5682, + X86_VFMSUB213SDr_Int = 5683, + X86_VFMSUB213SSZm = 5684, + X86_VFMSUB213SSZm_Int = 5685, + X86_VFMSUB213SSZm_Intk = 5686, + X86_VFMSUB213SSZm_Intkz = 5687, + X86_VFMSUB213SSZr = 5688, + X86_VFMSUB213SSZr_Int = 5689, + X86_VFMSUB213SSZr_Intk = 5690, + X86_VFMSUB213SSZr_Intkz = 5691, + X86_VFMSUB213SSZrb = 5692, + X86_VFMSUB213SSZrb_Int = 5693, + X86_VFMSUB213SSZrb_Intk = 5694, + X86_VFMSUB213SSZrb_Intkz = 5695, + X86_VFMSUB213SSm = 5696, + X86_VFMSUB213SSm_Int = 5697, + X86_VFMSUB213SSr = 5698, + X86_VFMSUB213SSr_Int = 5699, + X86_VFMSUB231PDYm = 5700, + X86_VFMSUB231PDYr = 5701, + X86_VFMSUB231PDZ128m = 5702, + X86_VFMSUB231PDZ128mb = 5703, + X86_VFMSUB231PDZ128mbk = 5704, + X86_VFMSUB231PDZ128mbkz = 5705, + X86_VFMSUB231PDZ128mk = 5706, + X86_VFMSUB231PDZ128mkz = 5707, + X86_VFMSUB231PDZ128r = 5708, + X86_VFMSUB231PDZ128rk = 5709, + X86_VFMSUB231PDZ128rkz = 5710, + X86_VFMSUB231PDZ256m = 5711, + X86_VFMSUB231PDZ256mb = 5712, + X86_VFMSUB231PDZ256mbk = 5713, + X86_VFMSUB231PDZ256mbkz = 5714, + X86_VFMSUB231PDZ256mk = 5715, + X86_VFMSUB231PDZ256mkz = 5716, + X86_VFMSUB231PDZ256r = 5717, + X86_VFMSUB231PDZ256rk = 5718, + X86_VFMSUB231PDZ256rkz = 5719, + X86_VFMSUB231PDZm = 5720, + X86_VFMSUB231PDZmb = 5721, + X86_VFMSUB231PDZmbk = 5722, + X86_VFMSUB231PDZmbkz = 5723, + X86_VFMSUB231PDZmk = 5724, + X86_VFMSUB231PDZmkz = 5725, + X86_VFMSUB231PDZr = 5726, + X86_VFMSUB231PDZrb = 5727, + X86_VFMSUB231PDZrbk = 5728, + X86_VFMSUB231PDZrbkz = 5729, + X86_VFMSUB231PDZrk = 5730, + X86_VFMSUB231PDZrkz = 5731, + X86_VFMSUB231PDm = 5732, + X86_VFMSUB231PDr = 5733, + X86_VFMSUB231PSYm = 5734, + X86_VFMSUB231PSYr = 5735, + X86_VFMSUB231PSZ128m = 5736, + X86_VFMSUB231PSZ128mb = 5737, + X86_VFMSUB231PSZ128mbk = 5738, + X86_VFMSUB231PSZ128mbkz = 5739, + X86_VFMSUB231PSZ128mk = 5740, + X86_VFMSUB231PSZ128mkz = 5741, + X86_VFMSUB231PSZ128r = 5742, + X86_VFMSUB231PSZ128rk = 5743, + X86_VFMSUB231PSZ128rkz = 5744, + X86_VFMSUB231PSZ256m = 5745, + X86_VFMSUB231PSZ256mb = 5746, + X86_VFMSUB231PSZ256mbk = 5747, + X86_VFMSUB231PSZ256mbkz = 5748, + X86_VFMSUB231PSZ256mk = 5749, + X86_VFMSUB231PSZ256mkz = 5750, + X86_VFMSUB231PSZ256r = 5751, + X86_VFMSUB231PSZ256rk = 5752, + X86_VFMSUB231PSZ256rkz = 5753, + X86_VFMSUB231PSZm = 5754, + X86_VFMSUB231PSZmb = 5755, + X86_VFMSUB231PSZmbk = 5756, + X86_VFMSUB231PSZmbkz = 5757, + X86_VFMSUB231PSZmk = 5758, + X86_VFMSUB231PSZmkz = 5759, + X86_VFMSUB231PSZr = 5760, + X86_VFMSUB231PSZrb = 5761, + X86_VFMSUB231PSZrbk = 5762, + X86_VFMSUB231PSZrbkz = 5763, + X86_VFMSUB231PSZrk = 5764, + X86_VFMSUB231PSZrkz = 5765, + X86_VFMSUB231PSm = 5766, + X86_VFMSUB231PSr = 5767, + X86_VFMSUB231SDZm = 5768, + X86_VFMSUB231SDZm_Int = 5769, + X86_VFMSUB231SDZm_Intk = 5770, + X86_VFMSUB231SDZm_Intkz = 5771, + X86_VFMSUB231SDZr = 5772, + X86_VFMSUB231SDZr_Int = 5773, + X86_VFMSUB231SDZr_Intk = 5774, + X86_VFMSUB231SDZr_Intkz = 5775, + X86_VFMSUB231SDZrb = 5776, + X86_VFMSUB231SDZrb_Int = 5777, + X86_VFMSUB231SDZrb_Intk = 5778, + X86_VFMSUB231SDZrb_Intkz = 5779, + X86_VFMSUB231SDm = 5780, + X86_VFMSUB231SDm_Int = 5781, + X86_VFMSUB231SDr = 5782, + X86_VFMSUB231SDr_Int = 5783, + X86_VFMSUB231SSZm = 5784, + X86_VFMSUB231SSZm_Int = 5785, + X86_VFMSUB231SSZm_Intk = 5786, + X86_VFMSUB231SSZm_Intkz = 5787, + X86_VFMSUB231SSZr = 5788, + X86_VFMSUB231SSZr_Int = 5789, + X86_VFMSUB231SSZr_Intk = 5790, + X86_VFMSUB231SSZr_Intkz = 5791, + X86_VFMSUB231SSZrb = 5792, + X86_VFMSUB231SSZrb_Int = 5793, + X86_VFMSUB231SSZrb_Intk = 5794, + X86_VFMSUB231SSZrb_Intkz = 5795, + X86_VFMSUB231SSm = 5796, + X86_VFMSUB231SSm_Int = 5797, + X86_VFMSUB231SSr = 5798, + X86_VFMSUB231SSr_Int = 5799, + X86_VFMSUBADD132PDYm = 5800, + X86_VFMSUBADD132PDYr = 5801, + X86_VFMSUBADD132PDZ128m = 5802, + X86_VFMSUBADD132PDZ128mb = 5803, + X86_VFMSUBADD132PDZ128mbk = 5804, + X86_VFMSUBADD132PDZ128mbkz = 5805, + X86_VFMSUBADD132PDZ128mk = 5806, + X86_VFMSUBADD132PDZ128mkz = 5807, + X86_VFMSUBADD132PDZ128r = 5808, + X86_VFMSUBADD132PDZ128rk = 5809, + X86_VFMSUBADD132PDZ128rkz = 5810, + X86_VFMSUBADD132PDZ256m = 5811, + X86_VFMSUBADD132PDZ256mb = 5812, + X86_VFMSUBADD132PDZ256mbk = 5813, + X86_VFMSUBADD132PDZ256mbkz = 5814, + X86_VFMSUBADD132PDZ256mk = 5815, + X86_VFMSUBADD132PDZ256mkz = 5816, + X86_VFMSUBADD132PDZ256r = 5817, + X86_VFMSUBADD132PDZ256rk = 5818, + X86_VFMSUBADD132PDZ256rkz = 5819, + X86_VFMSUBADD132PDZm = 5820, + X86_VFMSUBADD132PDZmb = 5821, + X86_VFMSUBADD132PDZmbk = 5822, + X86_VFMSUBADD132PDZmbkz = 5823, + X86_VFMSUBADD132PDZmk = 5824, + X86_VFMSUBADD132PDZmkz = 5825, + X86_VFMSUBADD132PDZr = 5826, + X86_VFMSUBADD132PDZrb = 5827, + X86_VFMSUBADD132PDZrbk = 5828, + X86_VFMSUBADD132PDZrbkz = 5829, + X86_VFMSUBADD132PDZrk = 5830, + X86_VFMSUBADD132PDZrkz = 5831, + X86_VFMSUBADD132PDm = 5832, + X86_VFMSUBADD132PDr = 5833, + X86_VFMSUBADD132PSYm = 5834, + X86_VFMSUBADD132PSYr = 5835, + X86_VFMSUBADD132PSZ128m = 5836, + X86_VFMSUBADD132PSZ128mb = 5837, + X86_VFMSUBADD132PSZ128mbk = 5838, + X86_VFMSUBADD132PSZ128mbkz = 5839, + X86_VFMSUBADD132PSZ128mk = 5840, + X86_VFMSUBADD132PSZ128mkz = 5841, + X86_VFMSUBADD132PSZ128r = 5842, + X86_VFMSUBADD132PSZ128rk = 5843, + X86_VFMSUBADD132PSZ128rkz = 5844, + X86_VFMSUBADD132PSZ256m = 5845, + X86_VFMSUBADD132PSZ256mb = 5846, + X86_VFMSUBADD132PSZ256mbk = 5847, + X86_VFMSUBADD132PSZ256mbkz = 5848, + X86_VFMSUBADD132PSZ256mk = 5849, + X86_VFMSUBADD132PSZ256mkz = 5850, + X86_VFMSUBADD132PSZ256r = 5851, + X86_VFMSUBADD132PSZ256rk = 5852, + X86_VFMSUBADD132PSZ256rkz = 5853, + X86_VFMSUBADD132PSZm = 5854, + X86_VFMSUBADD132PSZmb = 5855, + X86_VFMSUBADD132PSZmbk = 5856, + X86_VFMSUBADD132PSZmbkz = 5857, + X86_VFMSUBADD132PSZmk = 5858, + X86_VFMSUBADD132PSZmkz = 5859, + X86_VFMSUBADD132PSZr = 5860, + X86_VFMSUBADD132PSZrb = 5861, + X86_VFMSUBADD132PSZrbk = 5862, + X86_VFMSUBADD132PSZrbkz = 5863, + X86_VFMSUBADD132PSZrk = 5864, + X86_VFMSUBADD132PSZrkz = 5865, + X86_VFMSUBADD132PSm = 5866, + X86_VFMSUBADD132PSr = 5867, + X86_VFMSUBADD213PDYm = 5868, + X86_VFMSUBADD213PDYr = 5869, + X86_VFMSUBADD213PDZ128m = 5870, + X86_VFMSUBADD213PDZ128mb = 5871, + X86_VFMSUBADD213PDZ128mbk = 5872, + X86_VFMSUBADD213PDZ128mbkz = 5873, + X86_VFMSUBADD213PDZ128mk = 5874, + X86_VFMSUBADD213PDZ128mkz = 5875, + X86_VFMSUBADD213PDZ128r = 5876, + X86_VFMSUBADD213PDZ128rk = 5877, + X86_VFMSUBADD213PDZ128rkz = 5878, + X86_VFMSUBADD213PDZ256m = 5879, + X86_VFMSUBADD213PDZ256mb = 5880, + X86_VFMSUBADD213PDZ256mbk = 5881, + X86_VFMSUBADD213PDZ256mbkz = 5882, + X86_VFMSUBADD213PDZ256mk = 5883, + X86_VFMSUBADD213PDZ256mkz = 5884, + X86_VFMSUBADD213PDZ256r = 5885, + X86_VFMSUBADD213PDZ256rk = 5886, + X86_VFMSUBADD213PDZ256rkz = 5887, + X86_VFMSUBADD213PDZm = 5888, + X86_VFMSUBADD213PDZmb = 5889, + X86_VFMSUBADD213PDZmbk = 5890, + X86_VFMSUBADD213PDZmbkz = 5891, + X86_VFMSUBADD213PDZmk = 5892, + X86_VFMSUBADD213PDZmkz = 5893, + X86_VFMSUBADD213PDZr = 5894, + X86_VFMSUBADD213PDZrb = 5895, + X86_VFMSUBADD213PDZrbk = 5896, + X86_VFMSUBADD213PDZrbkz = 5897, + X86_VFMSUBADD213PDZrk = 5898, + X86_VFMSUBADD213PDZrkz = 5899, + X86_VFMSUBADD213PDm = 5900, + X86_VFMSUBADD213PDr = 5901, + X86_VFMSUBADD213PSYm = 5902, + X86_VFMSUBADD213PSYr = 5903, + X86_VFMSUBADD213PSZ128m = 5904, + X86_VFMSUBADD213PSZ128mb = 5905, + X86_VFMSUBADD213PSZ128mbk = 5906, + X86_VFMSUBADD213PSZ128mbkz = 5907, + X86_VFMSUBADD213PSZ128mk = 5908, + X86_VFMSUBADD213PSZ128mkz = 5909, + X86_VFMSUBADD213PSZ128r = 5910, + X86_VFMSUBADD213PSZ128rk = 5911, + X86_VFMSUBADD213PSZ128rkz = 5912, + X86_VFMSUBADD213PSZ256m = 5913, + X86_VFMSUBADD213PSZ256mb = 5914, + X86_VFMSUBADD213PSZ256mbk = 5915, + X86_VFMSUBADD213PSZ256mbkz = 5916, + X86_VFMSUBADD213PSZ256mk = 5917, + X86_VFMSUBADD213PSZ256mkz = 5918, + X86_VFMSUBADD213PSZ256r = 5919, + X86_VFMSUBADD213PSZ256rk = 5920, + X86_VFMSUBADD213PSZ256rkz = 5921, + X86_VFMSUBADD213PSZm = 5922, + X86_VFMSUBADD213PSZmb = 5923, + X86_VFMSUBADD213PSZmbk = 5924, + X86_VFMSUBADD213PSZmbkz = 5925, + X86_VFMSUBADD213PSZmk = 5926, + X86_VFMSUBADD213PSZmkz = 5927, + X86_VFMSUBADD213PSZr = 5928, + X86_VFMSUBADD213PSZrb = 5929, + X86_VFMSUBADD213PSZrbk = 5930, + X86_VFMSUBADD213PSZrbkz = 5931, + X86_VFMSUBADD213PSZrk = 5932, + X86_VFMSUBADD213PSZrkz = 5933, + X86_VFMSUBADD213PSm = 5934, + X86_VFMSUBADD213PSr = 5935, + X86_VFMSUBADD231PDYm = 5936, + X86_VFMSUBADD231PDYr = 5937, + X86_VFMSUBADD231PDZ128m = 5938, + X86_VFMSUBADD231PDZ128mb = 5939, + X86_VFMSUBADD231PDZ128mbk = 5940, + X86_VFMSUBADD231PDZ128mbkz = 5941, + X86_VFMSUBADD231PDZ128mk = 5942, + X86_VFMSUBADD231PDZ128mkz = 5943, + X86_VFMSUBADD231PDZ128r = 5944, + X86_VFMSUBADD231PDZ128rk = 5945, + X86_VFMSUBADD231PDZ128rkz = 5946, + X86_VFMSUBADD231PDZ256m = 5947, + X86_VFMSUBADD231PDZ256mb = 5948, + X86_VFMSUBADD231PDZ256mbk = 5949, + X86_VFMSUBADD231PDZ256mbkz = 5950, + X86_VFMSUBADD231PDZ256mk = 5951, + X86_VFMSUBADD231PDZ256mkz = 5952, + X86_VFMSUBADD231PDZ256r = 5953, + X86_VFMSUBADD231PDZ256rk = 5954, + X86_VFMSUBADD231PDZ256rkz = 5955, + X86_VFMSUBADD231PDZm = 5956, + X86_VFMSUBADD231PDZmb = 5957, + X86_VFMSUBADD231PDZmbk = 5958, + X86_VFMSUBADD231PDZmbkz = 5959, + X86_VFMSUBADD231PDZmk = 5960, + X86_VFMSUBADD231PDZmkz = 5961, + X86_VFMSUBADD231PDZr = 5962, + X86_VFMSUBADD231PDZrb = 5963, + X86_VFMSUBADD231PDZrbk = 5964, + X86_VFMSUBADD231PDZrbkz = 5965, + X86_VFMSUBADD231PDZrk = 5966, + X86_VFMSUBADD231PDZrkz = 5967, + X86_VFMSUBADD231PDm = 5968, + X86_VFMSUBADD231PDr = 5969, + X86_VFMSUBADD231PSYm = 5970, + X86_VFMSUBADD231PSYr = 5971, + X86_VFMSUBADD231PSZ128m = 5972, + X86_VFMSUBADD231PSZ128mb = 5973, + X86_VFMSUBADD231PSZ128mbk = 5974, + X86_VFMSUBADD231PSZ128mbkz = 5975, + X86_VFMSUBADD231PSZ128mk = 5976, + X86_VFMSUBADD231PSZ128mkz = 5977, + X86_VFMSUBADD231PSZ128r = 5978, + X86_VFMSUBADD231PSZ128rk = 5979, + X86_VFMSUBADD231PSZ128rkz = 5980, + X86_VFMSUBADD231PSZ256m = 5981, + X86_VFMSUBADD231PSZ256mb = 5982, + X86_VFMSUBADD231PSZ256mbk = 5983, + X86_VFMSUBADD231PSZ256mbkz = 5984, + X86_VFMSUBADD231PSZ256mk = 5985, + X86_VFMSUBADD231PSZ256mkz = 5986, + X86_VFMSUBADD231PSZ256r = 5987, + X86_VFMSUBADD231PSZ256rk = 5988, + X86_VFMSUBADD231PSZ256rkz = 5989, + X86_VFMSUBADD231PSZm = 5990, + X86_VFMSUBADD231PSZmb = 5991, + X86_VFMSUBADD231PSZmbk = 5992, + X86_VFMSUBADD231PSZmbkz = 5993, + X86_VFMSUBADD231PSZmk = 5994, + X86_VFMSUBADD231PSZmkz = 5995, + X86_VFMSUBADD231PSZr = 5996, + X86_VFMSUBADD231PSZrb = 5997, + X86_VFMSUBADD231PSZrbk = 5998, + X86_VFMSUBADD231PSZrbkz = 5999, + X86_VFMSUBADD231PSZrk = 6000, + X86_VFMSUBADD231PSZrkz = 6001, + X86_VFMSUBADD231PSm = 6002, + X86_VFMSUBADD231PSr = 6003, + X86_VFMSUBADDPD4Ymr = 6004, + X86_VFMSUBADDPD4Yrm = 6005, + X86_VFMSUBADDPD4Yrr = 6006, + X86_VFMSUBADDPD4Yrr_REV = 6007, + X86_VFMSUBADDPD4mr = 6008, + X86_VFMSUBADDPD4rm = 6009, + X86_VFMSUBADDPD4rr = 6010, + X86_VFMSUBADDPD4rr_REV = 6011, + X86_VFMSUBADDPS4Ymr = 6012, + X86_VFMSUBADDPS4Yrm = 6013, + X86_VFMSUBADDPS4Yrr = 6014, + X86_VFMSUBADDPS4Yrr_REV = 6015, + X86_VFMSUBADDPS4mr = 6016, + X86_VFMSUBADDPS4rm = 6017, + X86_VFMSUBADDPS4rr = 6018, + X86_VFMSUBADDPS4rr_REV = 6019, + X86_VFMSUBPD4Ymr = 6020, + X86_VFMSUBPD4Yrm = 6021, + X86_VFMSUBPD4Yrr = 6022, + X86_VFMSUBPD4Yrr_REV = 6023, + X86_VFMSUBPD4mr = 6024, + X86_VFMSUBPD4rm = 6025, + X86_VFMSUBPD4rr = 6026, + X86_VFMSUBPD4rr_REV = 6027, + X86_VFMSUBPS4Ymr = 6028, + X86_VFMSUBPS4Yrm = 6029, + X86_VFMSUBPS4Yrr = 6030, + X86_VFMSUBPS4Yrr_REV = 6031, + X86_VFMSUBPS4mr = 6032, + X86_VFMSUBPS4rm = 6033, + X86_VFMSUBPS4rr = 6034, + X86_VFMSUBPS4rr_REV = 6035, + X86_VFMSUBSD4mr = 6036, + X86_VFMSUBSD4mr_Int = 6037, + X86_VFMSUBSD4rm = 6038, + X86_VFMSUBSD4rm_Int = 6039, + X86_VFMSUBSD4rr = 6040, + X86_VFMSUBSD4rr_Int = 6041, + X86_VFMSUBSD4rr_Int_REV = 6042, + X86_VFMSUBSD4rr_REV = 6043, + X86_VFMSUBSS4mr = 6044, + X86_VFMSUBSS4mr_Int = 6045, + X86_VFMSUBSS4rm = 6046, + X86_VFMSUBSS4rm_Int = 6047, + X86_VFMSUBSS4rr = 6048, + X86_VFMSUBSS4rr_Int = 6049, + X86_VFMSUBSS4rr_Int_REV = 6050, + X86_VFMSUBSS4rr_REV = 6051, + X86_VFNMADD132PDYm = 6052, + X86_VFNMADD132PDYr = 6053, + X86_VFNMADD132PDZ128m = 6054, + X86_VFNMADD132PDZ128mb = 6055, + X86_VFNMADD132PDZ128mbk = 6056, + X86_VFNMADD132PDZ128mbkz = 6057, + X86_VFNMADD132PDZ128mk = 6058, + X86_VFNMADD132PDZ128mkz = 6059, + X86_VFNMADD132PDZ128r = 6060, + X86_VFNMADD132PDZ128rk = 6061, + X86_VFNMADD132PDZ128rkz = 6062, + X86_VFNMADD132PDZ256m = 6063, + X86_VFNMADD132PDZ256mb = 6064, + X86_VFNMADD132PDZ256mbk = 6065, + X86_VFNMADD132PDZ256mbkz = 6066, + X86_VFNMADD132PDZ256mk = 6067, + X86_VFNMADD132PDZ256mkz = 6068, + X86_VFNMADD132PDZ256r = 6069, + X86_VFNMADD132PDZ256rk = 6070, + X86_VFNMADD132PDZ256rkz = 6071, + X86_VFNMADD132PDZm = 6072, + X86_VFNMADD132PDZmb = 6073, + X86_VFNMADD132PDZmbk = 6074, + X86_VFNMADD132PDZmbkz = 6075, + X86_VFNMADD132PDZmk = 6076, + X86_VFNMADD132PDZmkz = 6077, + X86_VFNMADD132PDZr = 6078, + X86_VFNMADD132PDZrb = 6079, + X86_VFNMADD132PDZrbk = 6080, + X86_VFNMADD132PDZrbkz = 6081, + X86_VFNMADD132PDZrk = 6082, + X86_VFNMADD132PDZrkz = 6083, + X86_VFNMADD132PDm = 6084, + X86_VFNMADD132PDr = 6085, + X86_VFNMADD132PSYm = 6086, + X86_VFNMADD132PSYr = 6087, + X86_VFNMADD132PSZ128m = 6088, + X86_VFNMADD132PSZ128mb = 6089, + X86_VFNMADD132PSZ128mbk = 6090, + X86_VFNMADD132PSZ128mbkz = 6091, + X86_VFNMADD132PSZ128mk = 6092, + X86_VFNMADD132PSZ128mkz = 6093, + X86_VFNMADD132PSZ128r = 6094, + X86_VFNMADD132PSZ128rk = 6095, + X86_VFNMADD132PSZ128rkz = 6096, + X86_VFNMADD132PSZ256m = 6097, + X86_VFNMADD132PSZ256mb = 6098, + X86_VFNMADD132PSZ256mbk = 6099, + X86_VFNMADD132PSZ256mbkz = 6100, + X86_VFNMADD132PSZ256mk = 6101, + X86_VFNMADD132PSZ256mkz = 6102, + X86_VFNMADD132PSZ256r = 6103, + X86_VFNMADD132PSZ256rk = 6104, + X86_VFNMADD132PSZ256rkz = 6105, + X86_VFNMADD132PSZm = 6106, + X86_VFNMADD132PSZmb = 6107, + X86_VFNMADD132PSZmbk = 6108, + X86_VFNMADD132PSZmbkz = 6109, + X86_VFNMADD132PSZmk = 6110, + X86_VFNMADD132PSZmkz = 6111, + X86_VFNMADD132PSZr = 6112, + X86_VFNMADD132PSZrb = 6113, + X86_VFNMADD132PSZrbk = 6114, + X86_VFNMADD132PSZrbkz = 6115, + X86_VFNMADD132PSZrk = 6116, + X86_VFNMADD132PSZrkz = 6117, + X86_VFNMADD132PSm = 6118, + X86_VFNMADD132PSr = 6119, + X86_VFNMADD132SDZm = 6120, + X86_VFNMADD132SDZm_Int = 6121, + X86_VFNMADD132SDZm_Intk = 6122, + X86_VFNMADD132SDZm_Intkz = 6123, + X86_VFNMADD132SDZr = 6124, + X86_VFNMADD132SDZr_Int = 6125, + X86_VFNMADD132SDZr_Intk = 6126, + X86_VFNMADD132SDZr_Intkz = 6127, + X86_VFNMADD132SDZrb = 6128, + X86_VFNMADD132SDZrb_Int = 6129, + X86_VFNMADD132SDZrb_Intk = 6130, + X86_VFNMADD132SDZrb_Intkz = 6131, + X86_VFNMADD132SDm = 6132, + X86_VFNMADD132SDm_Int = 6133, + X86_VFNMADD132SDr = 6134, + X86_VFNMADD132SDr_Int = 6135, + X86_VFNMADD132SSZm = 6136, + X86_VFNMADD132SSZm_Int = 6137, + X86_VFNMADD132SSZm_Intk = 6138, + X86_VFNMADD132SSZm_Intkz = 6139, + X86_VFNMADD132SSZr = 6140, + X86_VFNMADD132SSZr_Int = 6141, + X86_VFNMADD132SSZr_Intk = 6142, + X86_VFNMADD132SSZr_Intkz = 6143, + X86_VFNMADD132SSZrb = 6144, + X86_VFNMADD132SSZrb_Int = 6145, + X86_VFNMADD132SSZrb_Intk = 6146, + X86_VFNMADD132SSZrb_Intkz = 6147, + X86_VFNMADD132SSm = 6148, + X86_VFNMADD132SSm_Int = 6149, + X86_VFNMADD132SSr = 6150, + X86_VFNMADD132SSr_Int = 6151, + X86_VFNMADD213PDYm = 6152, + X86_VFNMADD213PDYr = 6153, + X86_VFNMADD213PDZ128m = 6154, + X86_VFNMADD213PDZ128mb = 6155, + X86_VFNMADD213PDZ128mbk = 6156, + X86_VFNMADD213PDZ128mbkz = 6157, + X86_VFNMADD213PDZ128mk = 6158, + X86_VFNMADD213PDZ128mkz = 6159, + X86_VFNMADD213PDZ128r = 6160, + X86_VFNMADD213PDZ128rk = 6161, + X86_VFNMADD213PDZ128rkz = 6162, + X86_VFNMADD213PDZ256m = 6163, + X86_VFNMADD213PDZ256mb = 6164, + X86_VFNMADD213PDZ256mbk = 6165, + X86_VFNMADD213PDZ256mbkz = 6166, + X86_VFNMADD213PDZ256mk = 6167, + X86_VFNMADD213PDZ256mkz = 6168, + X86_VFNMADD213PDZ256r = 6169, + X86_VFNMADD213PDZ256rk = 6170, + X86_VFNMADD213PDZ256rkz = 6171, + X86_VFNMADD213PDZm = 6172, + X86_VFNMADD213PDZmb = 6173, + X86_VFNMADD213PDZmbk = 6174, + X86_VFNMADD213PDZmbkz = 6175, + X86_VFNMADD213PDZmk = 6176, + X86_VFNMADD213PDZmkz = 6177, + X86_VFNMADD213PDZr = 6178, + X86_VFNMADD213PDZrb = 6179, + X86_VFNMADD213PDZrbk = 6180, + X86_VFNMADD213PDZrbkz = 6181, + X86_VFNMADD213PDZrk = 6182, + X86_VFNMADD213PDZrkz = 6183, + X86_VFNMADD213PDm = 6184, + X86_VFNMADD213PDr = 6185, + X86_VFNMADD213PSYm = 6186, + X86_VFNMADD213PSYr = 6187, + X86_VFNMADD213PSZ128m = 6188, + X86_VFNMADD213PSZ128mb = 6189, + X86_VFNMADD213PSZ128mbk = 6190, + X86_VFNMADD213PSZ128mbkz = 6191, + X86_VFNMADD213PSZ128mk = 6192, + X86_VFNMADD213PSZ128mkz = 6193, + X86_VFNMADD213PSZ128r = 6194, + X86_VFNMADD213PSZ128rk = 6195, + X86_VFNMADD213PSZ128rkz = 6196, + X86_VFNMADD213PSZ256m = 6197, + X86_VFNMADD213PSZ256mb = 6198, + X86_VFNMADD213PSZ256mbk = 6199, + X86_VFNMADD213PSZ256mbkz = 6200, + X86_VFNMADD213PSZ256mk = 6201, + X86_VFNMADD213PSZ256mkz = 6202, + X86_VFNMADD213PSZ256r = 6203, + X86_VFNMADD213PSZ256rk = 6204, + X86_VFNMADD213PSZ256rkz = 6205, + X86_VFNMADD213PSZm = 6206, + X86_VFNMADD213PSZmb = 6207, + X86_VFNMADD213PSZmbk = 6208, + X86_VFNMADD213PSZmbkz = 6209, + X86_VFNMADD213PSZmk = 6210, + X86_VFNMADD213PSZmkz = 6211, + X86_VFNMADD213PSZr = 6212, + X86_VFNMADD213PSZrb = 6213, + X86_VFNMADD213PSZrbk = 6214, + X86_VFNMADD213PSZrbkz = 6215, + X86_VFNMADD213PSZrk = 6216, + X86_VFNMADD213PSZrkz = 6217, + X86_VFNMADD213PSm = 6218, + X86_VFNMADD213PSr = 6219, + X86_VFNMADD213SDZm = 6220, + X86_VFNMADD213SDZm_Int = 6221, + X86_VFNMADD213SDZm_Intk = 6222, + X86_VFNMADD213SDZm_Intkz = 6223, + X86_VFNMADD213SDZr = 6224, + X86_VFNMADD213SDZr_Int = 6225, + X86_VFNMADD213SDZr_Intk = 6226, + X86_VFNMADD213SDZr_Intkz = 6227, + X86_VFNMADD213SDZrb = 6228, + X86_VFNMADD213SDZrb_Int = 6229, + X86_VFNMADD213SDZrb_Intk = 6230, + X86_VFNMADD213SDZrb_Intkz = 6231, + X86_VFNMADD213SDm = 6232, + X86_VFNMADD213SDm_Int = 6233, + X86_VFNMADD213SDr = 6234, + X86_VFNMADD213SDr_Int = 6235, + X86_VFNMADD213SSZm = 6236, + X86_VFNMADD213SSZm_Int = 6237, + X86_VFNMADD213SSZm_Intk = 6238, + X86_VFNMADD213SSZm_Intkz = 6239, + X86_VFNMADD213SSZr = 6240, + X86_VFNMADD213SSZr_Int = 6241, + X86_VFNMADD213SSZr_Intk = 6242, + X86_VFNMADD213SSZr_Intkz = 6243, + X86_VFNMADD213SSZrb = 6244, + X86_VFNMADD213SSZrb_Int = 6245, + X86_VFNMADD213SSZrb_Intk = 6246, + X86_VFNMADD213SSZrb_Intkz = 6247, + X86_VFNMADD213SSm = 6248, + X86_VFNMADD213SSm_Int = 6249, + X86_VFNMADD213SSr = 6250, + X86_VFNMADD213SSr_Int = 6251, + X86_VFNMADD231PDYm = 6252, + X86_VFNMADD231PDYr = 6253, + X86_VFNMADD231PDZ128m = 6254, + X86_VFNMADD231PDZ128mb = 6255, + X86_VFNMADD231PDZ128mbk = 6256, + X86_VFNMADD231PDZ128mbkz = 6257, + X86_VFNMADD231PDZ128mk = 6258, + X86_VFNMADD231PDZ128mkz = 6259, + X86_VFNMADD231PDZ128r = 6260, + X86_VFNMADD231PDZ128rk = 6261, + X86_VFNMADD231PDZ128rkz = 6262, + X86_VFNMADD231PDZ256m = 6263, + X86_VFNMADD231PDZ256mb = 6264, + X86_VFNMADD231PDZ256mbk = 6265, + X86_VFNMADD231PDZ256mbkz = 6266, + X86_VFNMADD231PDZ256mk = 6267, + X86_VFNMADD231PDZ256mkz = 6268, + X86_VFNMADD231PDZ256r = 6269, + X86_VFNMADD231PDZ256rk = 6270, + X86_VFNMADD231PDZ256rkz = 6271, + X86_VFNMADD231PDZm = 6272, + X86_VFNMADD231PDZmb = 6273, + X86_VFNMADD231PDZmbk = 6274, + X86_VFNMADD231PDZmbkz = 6275, + X86_VFNMADD231PDZmk = 6276, + X86_VFNMADD231PDZmkz = 6277, + X86_VFNMADD231PDZr = 6278, + X86_VFNMADD231PDZrb = 6279, + X86_VFNMADD231PDZrbk = 6280, + X86_VFNMADD231PDZrbkz = 6281, + X86_VFNMADD231PDZrk = 6282, + X86_VFNMADD231PDZrkz = 6283, + X86_VFNMADD231PDm = 6284, + X86_VFNMADD231PDr = 6285, + X86_VFNMADD231PSYm = 6286, + X86_VFNMADD231PSYr = 6287, + X86_VFNMADD231PSZ128m = 6288, + X86_VFNMADD231PSZ128mb = 6289, + X86_VFNMADD231PSZ128mbk = 6290, + X86_VFNMADD231PSZ128mbkz = 6291, + X86_VFNMADD231PSZ128mk = 6292, + X86_VFNMADD231PSZ128mkz = 6293, + X86_VFNMADD231PSZ128r = 6294, + X86_VFNMADD231PSZ128rk = 6295, + X86_VFNMADD231PSZ128rkz = 6296, + X86_VFNMADD231PSZ256m = 6297, + X86_VFNMADD231PSZ256mb = 6298, + X86_VFNMADD231PSZ256mbk = 6299, + X86_VFNMADD231PSZ256mbkz = 6300, + X86_VFNMADD231PSZ256mk = 6301, + X86_VFNMADD231PSZ256mkz = 6302, + X86_VFNMADD231PSZ256r = 6303, + X86_VFNMADD231PSZ256rk = 6304, + X86_VFNMADD231PSZ256rkz = 6305, + X86_VFNMADD231PSZm = 6306, + X86_VFNMADD231PSZmb = 6307, + X86_VFNMADD231PSZmbk = 6308, + X86_VFNMADD231PSZmbkz = 6309, + X86_VFNMADD231PSZmk = 6310, + X86_VFNMADD231PSZmkz = 6311, + X86_VFNMADD231PSZr = 6312, + X86_VFNMADD231PSZrb = 6313, + X86_VFNMADD231PSZrbk = 6314, + X86_VFNMADD231PSZrbkz = 6315, + X86_VFNMADD231PSZrk = 6316, + X86_VFNMADD231PSZrkz = 6317, + X86_VFNMADD231PSm = 6318, + X86_VFNMADD231PSr = 6319, + X86_VFNMADD231SDZm = 6320, + X86_VFNMADD231SDZm_Int = 6321, + X86_VFNMADD231SDZm_Intk = 6322, + X86_VFNMADD231SDZm_Intkz = 6323, + X86_VFNMADD231SDZr = 6324, + X86_VFNMADD231SDZr_Int = 6325, + X86_VFNMADD231SDZr_Intk = 6326, + X86_VFNMADD231SDZr_Intkz = 6327, + X86_VFNMADD231SDZrb = 6328, + X86_VFNMADD231SDZrb_Int = 6329, + X86_VFNMADD231SDZrb_Intk = 6330, + X86_VFNMADD231SDZrb_Intkz = 6331, + X86_VFNMADD231SDm = 6332, + X86_VFNMADD231SDm_Int = 6333, + X86_VFNMADD231SDr = 6334, + X86_VFNMADD231SDr_Int = 6335, + X86_VFNMADD231SSZm = 6336, + X86_VFNMADD231SSZm_Int = 6337, + X86_VFNMADD231SSZm_Intk = 6338, + X86_VFNMADD231SSZm_Intkz = 6339, + X86_VFNMADD231SSZr = 6340, + X86_VFNMADD231SSZr_Int = 6341, + X86_VFNMADD231SSZr_Intk = 6342, + X86_VFNMADD231SSZr_Intkz = 6343, + X86_VFNMADD231SSZrb = 6344, + X86_VFNMADD231SSZrb_Int = 6345, + X86_VFNMADD231SSZrb_Intk = 6346, + X86_VFNMADD231SSZrb_Intkz = 6347, + X86_VFNMADD231SSm = 6348, + X86_VFNMADD231SSm_Int = 6349, + X86_VFNMADD231SSr = 6350, + X86_VFNMADD231SSr_Int = 6351, + X86_VFNMADDPD4Ymr = 6352, + X86_VFNMADDPD4Yrm = 6353, + X86_VFNMADDPD4Yrr = 6354, + X86_VFNMADDPD4Yrr_REV = 6355, + X86_VFNMADDPD4mr = 6356, + X86_VFNMADDPD4rm = 6357, + X86_VFNMADDPD4rr = 6358, + X86_VFNMADDPD4rr_REV = 6359, + X86_VFNMADDPS4Ymr = 6360, + X86_VFNMADDPS4Yrm = 6361, + X86_VFNMADDPS4Yrr = 6362, + X86_VFNMADDPS4Yrr_REV = 6363, + X86_VFNMADDPS4mr = 6364, + X86_VFNMADDPS4rm = 6365, + X86_VFNMADDPS4rr = 6366, + X86_VFNMADDPS4rr_REV = 6367, + X86_VFNMADDSD4mr = 6368, + X86_VFNMADDSD4mr_Int = 6369, + X86_VFNMADDSD4rm = 6370, + X86_VFNMADDSD4rm_Int = 6371, + X86_VFNMADDSD4rr = 6372, + X86_VFNMADDSD4rr_Int = 6373, + X86_VFNMADDSD4rr_Int_REV = 6374, + X86_VFNMADDSD4rr_REV = 6375, + X86_VFNMADDSS4mr = 6376, + X86_VFNMADDSS4mr_Int = 6377, + X86_VFNMADDSS4rm = 6378, + X86_VFNMADDSS4rm_Int = 6379, + X86_VFNMADDSS4rr = 6380, + X86_VFNMADDSS4rr_Int = 6381, + X86_VFNMADDSS4rr_Int_REV = 6382, + X86_VFNMADDSS4rr_REV = 6383, + X86_VFNMSUB132PDYm = 6384, + X86_VFNMSUB132PDYr = 6385, + X86_VFNMSUB132PDZ128m = 6386, + X86_VFNMSUB132PDZ128mb = 6387, + X86_VFNMSUB132PDZ128mbk = 6388, + X86_VFNMSUB132PDZ128mbkz = 6389, + X86_VFNMSUB132PDZ128mk = 6390, + X86_VFNMSUB132PDZ128mkz = 6391, + X86_VFNMSUB132PDZ128r = 6392, + X86_VFNMSUB132PDZ128rk = 6393, + X86_VFNMSUB132PDZ128rkz = 6394, + X86_VFNMSUB132PDZ256m = 6395, + X86_VFNMSUB132PDZ256mb = 6396, + X86_VFNMSUB132PDZ256mbk = 6397, + X86_VFNMSUB132PDZ256mbkz = 6398, + X86_VFNMSUB132PDZ256mk = 6399, + X86_VFNMSUB132PDZ256mkz = 6400, + X86_VFNMSUB132PDZ256r = 6401, + X86_VFNMSUB132PDZ256rk = 6402, + X86_VFNMSUB132PDZ256rkz = 6403, + X86_VFNMSUB132PDZm = 6404, + X86_VFNMSUB132PDZmb = 6405, + X86_VFNMSUB132PDZmbk = 6406, + X86_VFNMSUB132PDZmbkz = 6407, + X86_VFNMSUB132PDZmk = 6408, + X86_VFNMSUB132PDZmkz = 6409, + X86_VFNMSUB132PDZr = 6410, + X86_VFNMSUB132PDZrb = 6411, + X86_VFNMSUB132PDZrbk = 6412, + X86_VFNMSUB132PDZrbkz = 6413, + X86_VFNMSUB132PDZrk = 6414, + X86_VFNMSUB132PDZrkz = 6415, + X86_VFNMSUB132PDm = 6416, + X86_VFNMSUB132PDr = 6417, + X86_VFNMSUB132PSYm = 6418, + X86_VFNMSUB132PSYr = 6419, + X86_VFNMSUB132PSZ128m = 6420, + X86_VFNMSUB132PSZ128mb = 6421, + X86_VFNMSUB132PSZ128mbk = 6422, + X86_VFNMSUB132PSZ128mbkz = 6423, + X86_VFNMSUB132PSZ128mk = 6424, + X86_VFNMSUB132PSZ128mkz = 6425, + X86_VFNMSUB132PSZ128r = 6426, + X86_VFNMSUB132PSZ128rk = 6427, + X86_VFNMSUB132PSZ128rkz = 6428, + X86_VFNMSUB132PSZ256m = 6429, + X86_VFNMSUB132PSZ256mb = 6430, + X86_VFNMSUB132PSZ256mbk = 6431, + X86_VFNMSUB132PSZ256mbkz = 6432, + X86_VFNMSUB132PSZ256mk = 6433, + X86_VFNMSUB132PSZ256mkz = 6434, + X86_VFNMSUB132PSZ256r = 6435, + X86_VFNMSUB132PSZ256rk = 6436, + X86_VFNMSUB132PSZ256rkz = 6437, + X86_VFNMSUB132PSZm = 6438, + X86_VFNMSUB132PSZmb = 6439, + X86_VFNMSUB132PSZmbk = 6440, + X86_VFNMSUB132PSZmbkz = 6441, + X86_VFNMSUB132PSZmk = 6442, + X86_VFNMSUB132PSZmkz = 6443, + X86_VFNMSUB132PSZr = 6444, + X86_VFNMSUB132PSZrb = 6445, + X86_VFNMSUB132PSZrbk = 6446, + X86_VFNMSUB132PSZrbkz = 6447, + X86_VFNMSUB132PSZrk = 6448, + X86_VFNMSUB132PSZrkz = 6449, + X86_VFNMSUB132PSm = 6450, + X86_VFNMSUB132PSr = 6451, + X86_VFNMSUB132SDZm = 6452, + X86_VFNMSUB132SDZm_Int = 6453, + X86_VFNMSUB132SDZm_Intk = 6454, + X86_VFNMSUB132SDZm_Intkz = 6455, + X86_VFNMSUB132SDZr = 6456, + X86_VFNMSUB132SDZr_Int = 6457, + X86_VFNMSUB132SDZr_Intk = 6458, + X86_VFNMSUB132SDZr_Intkz = 6459, + X86_VFNMSUB132SDZrb = 6460, + X86_VFNMSUB132SDZrb_Int = 6461, + X86_VFNMSUB132SDZrb_Intk = 6462, + X86_VFNMSUB132SDZrb_Intkz = 6463, + X86_VFNMSUB132SDm = 6464, + X86_VFNMSUB132SDm_Int = 6465, + X86_VFNMSUB132SDr = 6466, + X86_VFNMSUB132SDr_Int = 6467, + X86_VFNMSUB132SSZm = 6468, + X86_VFNMSUB132SSZm_Int = 6469, + X86_VFNMSUB132SSZm_Intk = 6470, + X86_VFNMSUB132SSZm_Intkz = 6471, + X86_VFNMSUB132SSZr = 6472, + X86_VFNMSUB132SSZr_Int = 6473, + X86_VFNMSUB132SSZr_Intk = 6474, + X86_VFNMSUB132SSZr_Intkz = 6475, + X86_VFNMSUB132SSZrb = 6476, + X86_VFNMSUB132SSZrb_Int = 6477, + X86_VFNMSUB132SSZrb_Intk = 6478, + X86_VFNMSUB132SSZrb_Intkz = 6479, + X86_VFNMSUB132SSm = 6480, + X86_VFNMSUB132SSm_Int = 6481, + X86_VFNMSUB132SSr = 6482, + X86_VFNMSUB132SSr_Int = 6483, + X86_VFNMSUB213PDYm = 6484, + X86_VFNMSUB213PDYr = 6485, + X86_VFNMSUB213PDZ128m = 6486, + X86_VFNMSUB213PDZ128mb = 6487, + X86_VFNMSUB213PDZ128mbk = 6488, + X86_VFNMSUB213PDZ128mbkz = 6489, + X86_VFNMSUB213PDZ128mk = 6490, + X86_VFNMSUB213PDZ128mkz = 6491, + X86_VFNMSUB213PDZ128r = 6492, + X86_VFNMSUB213PDZ128rk = 6493, + X86_VFNMSUB213PDZ128rkz = 6494, + X86_VFNMSUB213PDZ256m = 6495, + X86_VFNMSUB213PDZ256mb = 6496, + X86_VFNMSUB213PDZ256mbk = 6497, + X86_VFNMSUB213PDZ256mbkz = 6498, + X86_VFNMSUB213PDZ256mk = 6499, + X86_VFNMSUB213PDZ256mkz = 6500, + X86_VFNMSUB213PDZ256r = 6501, + X86_VFNMSUB213PDZ256rk = 6502, + X86_VFNMSUB213PDZ256rkz = 6503, + X86_VFNMSUB213PDZm = 6504, + X86_VFNMSUB213PDZmb = 6505, + X86_VFNMSUB213PDZmbk = 6506, + X86_VFNMSUB213PDZmbkz = 6507, + X86_VFNMSUB213PDZmk = 6508, + X86_VFNMSUB213PDZmkz = 6509, + X86_VFNMSUB213PDZr = 6510, + X86_VFNMSUB213PDZrb = 6511, + X86_VFNMSUB213PDZrbk = 6512, + X86_VFNMSUB213PDZrbkz = 6513, + X86_VFNMSUB213PDZrk = 6514, + X86_VFNMSUB213PDZrkz = 6515, + X86_VFNMSUB213PDm = 6516, + X86_VFNMSUB213PDr = 6517, + X86_VFNMSUB213PSYm = 6518, + X86_VFNMSUB213PSYr = 6519, + X86_VFNMSUB213PSZ128m = 6520, + X86_VFNMSUB213PSZ128mb = 6521, + X86_VFNMSUB213PSZ128mbk = 6522, + X86_VFNMSUB213PSZ128mbkz = 6523, + X86_VFNMSUB213PSZ128mk = 6524, + X86_VFNMSUB213PSZ128mkz = 6525, + X86_VFNMSUB213PSZ128r = 6526, + X86_VFNMSUB213PSZ128rk = 6527, + X86_VFNMSUB213PSZ128rkz = 6528, + X86_VFNMSUB213PSZ256m = 6529, + X86_VFNMSUB213PSZ256mb = 6530, + X86_VFNMSUB213PSZ256mbk = 6531, + X86_VFNMSUB213PSZ256mbkz = 6532, + X86_VFNMSUB213PSZ256mk = 6533, + X86_VFNMSUB213PSZ256mkz = 6534, + X86_VFNMSUB213PSZ256r = 6535, + X86_VFNMSUB213PSZ256rk = 6536, + X86_VFNMSUB213PSZ256rkz = 6537, + X86_VFNMSUB213PSZm = 6538, + X86_VFNMSUB213PSZmb = 6539, + X86_VFNMSUB213PSZmbk = 6540, + X86_VFNMSUB213PSZmbkz = 6541, + X86_VFNMSUB213PSZmk = 6542, + X86_VFNMSUB213PSZmkz = 6543, + X86_VFNMSUB213PSZr = 6544, + X86_VFNMSUB213PSZrb = 6545, + X86_VFNMSUB213PSZrbk = 6546, + X86_VFNMSUB213PSZrbkz = 6547, + X86_VFNMSUB213PSZrk = 6548, + X86_VFNMSUB213PSZrkz = 6549, + X86_VFNMSUB213PSm = 6550, + X86_VFNMSUB213PSr = 6551, + X86_VFNMSUB213SDZm = 6552, + X86_VFNMSUB213SDZm_Int = 6553, + X86_VFNMSUB213SDZm_Intk = 6554, + X86_VFNMSUB213SDZm_Intkz = 6555, + X86_VFNMSUB213SDZr = 6556, + X86_VFNMSUB213SDZr_Int = 6557, + X86_VFNMSUB213SDZr_Intk = 6558, + X86_VFNMSUB213SDZr_Intkz = 6559, + X86_VFNMSUB213SDZrb = 6560, + X86_VFNMSUB213SDZrb_Int = 6561, + X86_VFNMSUB213SDZrb_Intk = 6562, + X86_VFNMSUB213SDZrb_Intkz = 6563, + X86_VFNMSUB213SDm = 6564, + X86_VFNMSUB213SDm_Int = 6565, + X86_VFNMSUB213SDr = 6566, + X86_VFNMSUB213SDr_Int = 6567, + X86_VFNMSUB213SSZm = 6568, + X86_VFNMSUB213SSZm_Int = 6569, + X86_VFNMSUB213SSZm_Intk = 6570, + X86_VFNMSUB213SSZm_Intkz = 6571, + X86_VFNMSUB213SSZr = 6572, + X86_VFNMSUB213SSZr_Int = 6573, + X86_VFNMSUB213SSZr_Intk = 6574, + X86_VFNMSUB213SSZr_Intkz = 6575, + X86_VFNMSUB213SSZrb = 6576, + X86_VFNMSUB213SSZrb_Int = 6577, + X86_VFNMSUB213SSZrb_Intk = 6578, + X86_VFNMSUB213SSZrb_Intkz = 6579, + X86_VFNMSUB213SSm = 6580, + X86_VFNMSUB213SSm_Int = 6581, + X86_VFNMSUB213SSr = 6582, + X86_VFNMSUB213SSr_Int = 6583, + X86_VFNMSUB231PDYm = 6584, + X86_VFNMSUB231PDYr = 6585, + X86_VFNMSUB231PDZ128m = 6586, + X86_VFNMSUB231PDZ128mb = 6587, + X86_VFNMSUB231PDZ128mbk = 6588, + X86_VFNMSUB231PDZ128mbkz = 6589, + X86_VFNMSUB231PDZ128mk = 6590, + X86_VFNMSUB231PDZ128mkz = 6591, + X86_VFNMSUB231PDZ128r = 6592, + X86_VFNMSUB231PDZ128rk = 6593, + X86_VFNMSUB231PDZ128rkz = 6594, + X86_VFNMSUB231PDZ256m = 6595, + X86_VFNMSUB231PDZ256mb = 6596, + X86_VFNMSUB231PDZ256mbk = 6597, + X86_VFNMSUB231PDZ256mbkz = 6598, + X86_VFNMSUB231PDZ256mk = 6599, + X86_VFNMSUB231PDZ256mkz = 6600, + X86_VFNMSUB231PDZ256r = 6601, + X86_VFNMSUB231PDZ256rk = 6602, + X86_VFNMSUB231PDZ256rkz = 6603, + X86_VFNMSUB231PDZm = 6604, + X86_VFNMSUB231PDZmb = 6605, + X86_VFNMSUB231PDZmbk = 6606, + X86_VFNMSUB231PDZmbkz = 6607, + X86_VFNMSUB231PDZmk = 6608, + X86_VFNMSUB231PDZmkz = 6609, + X86_VFNMSUB231PDZr = 6610, + X86_VFNMSUB231PDZrb = 6611, + X86_VFNMSUB231PDZrbk = 6612, + X86_VFNMSUB231PDZrbkz = 6613, + X86_VFNMSUB231PDZrk = 6614, + X86_VFNMSUB231PDZrkz = 6615, + X86_VFNMSUB231PDm = 6616, + X86_VFNMSUB231PDr = 6617, + X86_VFNMSUB231PSYm = 6618, + X86_VFNMSUB231PSYr = 6619, + X86_VFNMSUB231PSZ128m = 6620, + X86_VFNMSUB231PSZ128mb = 6621, + X86_VFNMSUB231PSZ128mbk = 6622, + X86_VFNMSUB231PSZ128mbkz = 6623, + X86_VFNMSUB231PSZ128mk = 6624, + X86_VFNMSUB231PSZ128mkz = 6625, + X86_VFNMSUB231PSZ128r = 6626, + X86_VFNMSUB231PSZ128rk = 6627, + X86_VFNMSUB231PSZ128rkz = 6628, + X86_VFNMSUB231PSZ256m = 6629, + X86_VFNMSUB231PSZ256mb = 6630, + X86_VFNMSUB231PSZ256mbk = 6631, + X86_VFNMSUB231PSZ256mbkz = 6632, + X86_VFNMSUB231PSZ256mk = 6633, + X86_VFNMSUB231PSZ256mkz = 6634, + X86_VFNMSUB231PSZ256r = 6635, + X86_VFNMSUB231PSZ256rk = 6636, + X86_VFNMSUB231PSZ256rkz = 6637, + X86_VFNMSUB231PSZm = 6638, + X86_VFNMSUB231PSZmb = 6639, + X86_VFNMSUB231PSZmbk = 6640, + X86_VFNMSUB231PSZmbkz = 6641, + X86_VFNMSUB231PSZmk = 6642, + X86_VFNMSUB231PSZmkz = 6643, + X86_VFNMSUB231PSZr = 6644, + X86_VFNMSUB231PSZrb = 6645, + X86_VFNMSUB231PSZrbk = 6646, + X86_VFNMSUB231PSZrbkz = 6647, + X86_VFNMSUB231PSZrk = 6648, + X86_VFNMSUB231PSZrkz = 6649, + X86_VFNMSUB231PSm = 6650, + X86_VFNMSUB231PSr = 6651, + X86_VFNMSUB231SDZm = 6652, + X86_VFNMSUB231SDZm_Int = 6653, + X86_VFNMSUB231SDZm_Intk = 6654, + X86_VFNMSUB231SDZm_Intkz = 6655, + X86_VFNMSUB231SDZr = 6656, + X86_VFNMSUB231SDZr_Int = 6657, + X86_VFNMSUB231SDZr_Intk = 6658, + X86_VFNMSUB231SDZr_Intkz = 6659, + X86_VFNMSUB231SDZrb = 6660, + X86_VFNMSUB231SDZrb_Int = 6661, + X86_VFNMSUB231SDZrb_Intk = 6662, + X86_VFNMSUB231SDZrb_Intkz = 6663, + X86_VFNMSUB231SDm = 6664, + X86_VFNMSUB231SDm_Int = 6665, + X86_VFNMSUB231SDr = 6666, + X86_VFNMSUB231SDr_Int = 6667, + X86_VFNMSUB231SSZm = 6668, + X86_VFNMSUB231SSZm_Int = 6669, + X86_VFNMSUB231SSZm_Intk = 6670, + X86_VFNMSUB231SSZm_Intkz = 6671, + X86_VFNMSUB231SSZr = 6672, + X86_VFNMSUB231SSZr_Int = 6673, + X86_VFNMSUB231SSZr_Intk = 6674, + X86_VFNMSUB231SSZr_Intkz = 6675, + X86_VFNMSUB231SSZrb = 6676, + X86_VFNMSUB231SSZrb_Int = 6677, + X86_VFNMSUB231SSZrb_Intk = 6678, + X86_VFNMSUB231SSZrb_Intkz = 6679, + X86_VFNMSUB231SSm = 6680, + X86_VFNMSUB231SSm_Int = 6681, + X86_VFNMSUB231SSr = 6682, + X86_VFNMSUB231SSr_Int = 6683, + X86_VFNMSUBPD4Ymr = 6684, + X86_VFNMSUBPD4Yrm = 6685, + X86_VFNMSUBPD4Yrr = 6686, + X86_VFNMSUBPD4Yrr_REV = 6687, + X86_VFNMSUBPD4mr = 6688, + X86_VFNMSUBPD4rm = 6689, + X86_VFNMSUBPD4rr = 6690, + X86_VFNMSUBPD4rr_REV = 6691, + X86_VFNMSUBPS4Ymr = 6692, + X86_VFNMSUBPS4Yrm = 6693, + X86_VFNMSUBPS4Yrr = 6694, + X86_VFNMSUBPS4Yrr_REV = 6695, + X86_VFNMSUBPS4mr = 6696, + X86_VFNMSUBPS4rm = 6697, + X86_VFNMSUBPS4rr = 6698, + X86_VFNMSUBPS4rr_REV = 6699, + X86_VFNMSUBSD4mr = 6700, + X86_VFNMSUBSD4mr_Int = 6701, + X86_VFNMSUBSD4rm = 6702, + X86_VFNMSUBSD4rm_Int = 6703, + X86_VFNMSUBSD4rr = 6704, + X86_VFNMSUBSD4rr_Int = 6705, + X86_VFNMSUBSD4rr_Int_REV = 6706, + X86_VFNMSUBSD4rr_REV = 6707, + X86_VFNMSUBSS4mr = 6708, + X86_VFNMSUBSS4mr_Int = 6709, + X86_VFNMSUBSS4rm = 6710, + X86_VFNMSUBSS4rm_Int = 6711, + X86_VFNMSUBSS4rr = 6712, + X86_VFNMSUBSS4rr_Int = 6713, + X86_VFNMSUBSS4rr_Int_REV = 6714, + X86_VFNMSUBSS4rr_REV = 6715, + X86_VFPCLASSPDZ128rm = 6716, + X86_VFPCLASSPDZ128rmb = 6717, + X86_VFPCLASSPDZ128rmbk = 6718, + X86_VFPCLASSPDZ128rmk = 6719, + X86_VFPCLASSPDZ128rr = 6720, + X86_VFPCLASSPDZ128rrk = 6721, + X86_VFPCLASSPDZ256rm = 6722, + X86_VFPCLASSPDZ256rmb = 6723, + X86_VFPCLASSPDZ256rmbk = 6724, + X86_VFPCLASSPDZ256rmk = 6725, + X86_VFPCLASSPDZ256rr = 6726, + X86_VFPCLASSPDZ256rrk = 6727, + X86_VFPCLASSPDZrm = 6728, + X86_VFPCLASSPDZrmb = 6729, + X86_VFPCLASSPDZrmbk = 6730, + X86_VFPCLASSPDZrmk = 6731, + X86_VFPCLASSPDZrr = 6732, + X86_VFPCLASSPDZrrk = 6733, + X86_VFPCLASSPSZ128rm = 6734, + X86_VFPCLASSPSZ128rmb = 6735, + X86_VFPCLASSPSZ128rmbk = 6736, + X86_VFPCLASSPSZ128rmk = 6737, + X86_VFPCLASSPSZ128rr = 6738, + X86_VFPCLASSPSZ128rrk = 6739, + X86_VFPCLASSPSZ256rm = 6740, + X86_VFPCLASSPSZ256rmb = 6741, + X86_VFPCLASSPSZ256rmbk = 6742, + X86_VFPCLASSPSZ256rmk = 6743, + X86_VFPCLASSPSZ256rr = 6744, + X86_VFPCLASSPSZ256rrk = 6745, + X86_VFPCLASSPSZrm = 6746, + X86_VFPCLASSPSZrmb = 6747, + X86_VFPCLASSPSZrmbk = 6748, + X86_VFPCLASSPSZrmk = 6749, + X86_VFPCLASSPSZrr = 6750, + X86_VFPCLASSPSZrrk = 6751, + X86_VFPCLASSSDZrm = 6752, + X86_VFPCLASSSDZrmk = 6753, + X86_VFPCLASSSDZrr = 6754, + X86_VFPCLASSSDZrrk = 6755, + X86_VFPCLASSSSZrm = 6756, + X86_VFPCLASSSSZrmk = 6757, + X86_VFPCLASSSSZrr = 6758, + X86_VFPCLASSSSZrrk = 6759, + X86_VFRCZPDYrm = 6760, + X86_VFRCZPDYrr = 6761, + X86_VFRCZPDrm = 6762, + X86_VFRCZPDrr = 6763, + X86_VFRCZPSYrm = 6764, + X86_VFRCZPSYrr = 6765, + X86_VFRCZPSrm = 6766, + X86_VFRCZPSrr = 6767, + X86_VFRCZSDrm = 6768, + X86_VFRCZSDrr = 6769, + X86_VFRCZSSrm = 6770, + X86_VFRCZSSrr = 6771, + X86_VGATHERDPDYrm = 6772, + X86_VGATHERDPDZ128rm = 6773, + X86_VGATHERDPDZ256rm = 6774, + X86_VGATHERDPDZrm = 6775, + X86_VGATHERDPDrm = 6776, + X86_VGATHERDPSYrm = 6777, + X86_VGATHERDPSZ128rm = 6778, + X86_VGATHERDPSZ256rm = 6779, + X86_VGATHERDPSZrm = 6780, + X86_VGATHERDPSrm = 6781, + X86_VGATHERPF0DPDm = 6782, + X86_VGATHERPF0DPSm = 6783, + X86_VGATHERPF0QPDm = 6784, + X86_VGATHERPF0QPSm = 6785, + X86_VGATHERPF1DPDm = 6786, + X86_VGATHERPF1DPSm = 6787, + X86_VGATHERPF1QPDm = 6788, + X86_VGATHERPF1QPSm = 6789, + X86_VGATHERQPDYrm = 6790, + X86_VGATHERQPDZ128rm = 6791, + X86_VGATHERQPDZ256rm = 6792, + X86_VGATHERQPDZrm = 6793, + X86_VGATHERQPDrm = 6794, + X86_VGATHERQPSYrm = 6795, + X86_VGATHERQPSZ128rm = 6796, + X86_VGATHERQPSZ256rm = 6797, + X86_VGATHERQPSZrm = 6798, + X86_VGATHERQPSrm = 6799, + X86_VGETEXPPDZ128m = 6800, + X86_VGETEXPPDZ128mb = 6801, + X86_VGETEXPPDZ128mbk = 6802, + X86_VGETEXPPDZ128mbkz = 6803, + X86_VGETEXPPDZ128mk = 6804, + X86_VGETEXPPDZ128mkz = 6805, + X86_VGETEXPPDZ128r = 6806, + X86_VGETEXPPDZ128rk = 6807, + X86_VGETEXPPDZ128rkz = 6808, + X86_VGETEXPPDZ256m = 6809, + X86_VGETEXPPDZ256mb = 6810, + X86_VGETEXPPDZ256mbk = 6811, + X86_VGETEXPPDZ256mbkz = 6812, + X86_VGETEXPPDZ256mk = 6813, + X86_VGETEXPPDZ256mkz = 6814, + X86_VGETEXPPDZ256r = 6815, + X86_VGETEXPPDZ256rk = 6816, + X86_VGETEXPPDZ256rkz = 6817, + X86_VGETEXPPDZm = 6818, + X86_VGETEXPPDZmb = 6819, + X86_VGETEXPPDZmbk = 6820, + X86_VGETEXPPDZmbkz = 6821, + X86_VGETEXPPDZmk = 6822, + X86_VGETEXPPDZmkz = 6823, + X86_VGETEXPPDZr = 6824, + X86_VGETEXPPDZrb = 6825, + X86_VGETEXPPDZrbk = 6826, + X86_VGETEXPPDZrbkz = 6827, + X86_VGETEXPPDZrk = 6828, + X86_VGETEXPPDZrkz = 6829, + X86_VGETEXPPSZ128m = 6830, + X86_VGETEXPPSZ128mb = 6831, + X86_VGETEXPPSZ128mbk = 6832, + X86_VGETEXPPSZ128mbkz = 6833, + X86_VGETEXPPSZ128mk = 6834, + X86_VGETEXPPSZ128mkz = 6835, + X86_VGETEXPPSZ128r = 6836, + X86_VGETEXPPSZ128rk = 6837, + X86_VGETEXPPSZ128rkz = 6838, + X86_VGETEXPPSZ256m = 6839, + X86_VGETEXPPSZ256mb = 6840, + X86_VGETEXPPSZ256mbk = 6841, + X86_VGETEXPPSZ256mbkz = 6842, + X86_VGETEXPPSZ256mk = 6843, + X86_VGETEXPPSZ256mkz = 6844, + X86_VGETEXPPSZ256r = 6845, + X86_VGETEXPPSZ256rk = 6846, + X86_VGETEXPPSZ256rkz = 6847, + X86_VGETEXPPSZm = 6848, + X86_VGETEXPPSZmb = 6849, + X86_VGETEXPPSZmbk = 6850, + X86_VGETEXPPSZmbkz = 6851, + X86_VGETEXPPSZmk = 6852, + X86_VGETEXPPSZmkz = 6853, + X86_VGETEXPPSZr = 6854, + X86_VGETEXPPSZrb = 6855, + X86_VGETEXPPSZrbk = 6856, + X86_VGETEXPPSZrbkz = 6857, + X86_VGETEXPPSZrk = 6858, + X86_VGETEXPPSZrkz = 6859, + X86_VGETEXPSDZm = 6860, + X86_VGETEXPSDZmk = 6861, + X86_VGETEXPSDZmkz = 6862, + X86_VGETEXPSDZr = 6863, + X86_VGETEXPSDZrb = 6864, + X86_VGETEXPSDZrbk = 6865, + X86_VGETEXPSDZrbkz = 6866, + X86_VGETEXPSDZrk = 6867, + X86_VGETEXPSDZrkz = 6868, + X86_VGETEXPSSZm = 6869, + X86_VGETEXPSSZmk = 6870, + X86_VGETEXPSSZmkz = 6871, + X86_VGETEXPSSZr = 6872, + X86_VGETEXPSSZrb = 6873, + X86_VGETEXPSSZrbk = 6874, + X86_VGETEXPSSZrbkz = 6875, + X86_VGETEXPSSZrk = 6876, + X86_VGETEXPSSZrkz = 6877, + X86_VGETMANTPDZ128rmbi = 6878, + X86_VGETMANTPDZ128rmbik = 6879, + X86_VGETMANTPDZ128rmbikz = 6880, + X86_VGETMANTPDZ128rmi = 6881, + X86_VGETMANTPDZ128rmik = 6882, + X86_VGETMANTPDZ128rmikz = 6883, + X86_VGETMANTPDZ128rri = 6884, + X86_VGETMANTPDZ128rrik = 6885, + X86_VGETMANTPDZ128rrikz = 6886, + X86_VGETMANTPDZ256rmbi = 6887, + X86_VGETMANTPDZ256rmbik = 6888, + X86_VGETMANTPDZ256rmbikz = 6889, + X86_VGETMANTPDZ256rmi = 6890, + X86_VGETMANTPDZ256rmik = 6891, + X86_VGETMANTPDZ256rmikz = 6892, + X86_VGETMANTPDZ256rri = 6893, + X86_VGETMANTPDZ256rrik = 6894, + X86_VGETMANTPDZ256rrikz = 6895, + X86_VGETMANTPDZrmbi = 6896, + X86_VGETMANTPDZrmbik = 6897, + X86_VGETMANTPDZrmbikz = 6898, + X86_VGETMANTPDZrmi = 6899, + X86_VGETMANTPDZrmik = 6900, + X86_VGETMANTPDZrmikz = 6901, + X86_VGETMANTPDZrri = 6902, + X86_VGETMANTPDZrrib = 6903, + X86_VGETMANTPDZrribk = 6904, + X86_VGETMANTPDZrribkz = 6905, + X86_VGETMANTPDZrrik = 6906, + X86_VGETMANTPDZrrikz = 6907, + X86_VGETMANTPSZ128rmbi = 6908, + X86_VGETMANTPSZ128rmbik = 6909, + X86_VGETMANTPSZ128rmbikz = 6910, + X86_VGETMANTPSZ128rmi = 6911, + X86_VGETMANTPSZ128rmik = 6912, + X86_VGETMANTPSZ128rmikz = 6913, + X86_VGETMANTPSZ128rri = 6914, + X86_VGETMANTPSZ128rrik = 6915, + X86_VGETMANTPSZ128rrikz = 6916, + X86_VGETMANTPSZ256rmbi = 6917, + X86_VGETMANTPSZ256rmbik = 6918, + X86_VGETMANTPSZ256rmbikz = 6919, + X86_VGETMANTPSZ256rmi = 6920, + X86_VGETMANTPSZ256rmik = 6921, + X86_VGETMANTPSZ256rmikz = 6922, + X86_VGETMANTPSZ256rri = 6923, + X86_VGETMANTPSZ256rrik = 6924, + X86_VGETMANTPSZ256rrikz = 6925, + X86_VGETMANTPSZrmbi = 6926, + X86_VGETMANTPSZrmbik = 6927, + X86_VGETMANTPSZrmbikz = 6928, + X86_VGETMANTPSZrmi = 6929, + X86_VGETMANTPSZrmik = 6930, + X86_VGETMANTPSZrmikz = 6931, + X86_VGETMANTPSZrri = 6932, + X86_VGETMANTPSZrrib = 6933, + X86_VGETMANTPSZrribk = 6934, + X86_VGETMANTPSZrribkz = 6935, + X86_VGETMANTPSZrrik = 6936, + X86_VGETMANTPSZrrikz = 6937, + X86_VGETMANTSDZrmi = 6938, + X86_VGETMANTSDZrmik = 6939, + X86_VGETMANTSDZrmikz = 6940, + X86_VGETMANTSDZrri = 6941, + X86_VGETMANTSDZrrib = 6942, + X86_VGETMANTSDZrribk = 6943, + X86_VGETMANTSDZrribkz = 6944, + X86_VGETMANTSDZrrik = 6945, + X86_VGETMANTSDZrrikz = 6946, + X86_VGETMANTSSZrmi = 6947, + X86_VGETMANTSSZrmik = 6948, + X86_VGETMANTSSZrmikz = 6949, + X86_VGETMANTSSZrri = 6950, + X86_VGETMANTSSZrrib = 6951, + X86_VGETMANTSSZrribk = 6952, + X86_VGETMANTSSZrribkz = 6953, + X86_VGETMANTSSZrrik = 6954, + X86_VGETMANTSSZrrikz = 6955, + X86_VGF2P8AFFINEINVQBYrmi = 6956, + X86_VGF2P8AFFINEINVQBYrri = 6957, + X86_VGF2P8AFFINEINVQBZ128rmbi = 6958, + X86_VGF2P8AFFINEINVQBZ128rmbik = 6959, + X86_VGF2P8AFFINEINVQBZ128rmbikz = 6960, + X86_VGF2P8AFFINEINVQBZ128rmi = 6961, + X86_VGF2P8AFFINEINVQBZ128rmik = 6962, + X86_VGF2P8AFFINEINVQBZ128rmikz = 6963, + X86_VGF2P8AFFINEINVQBZ128rri = 6964, + X86_VGF2P8AFFINEINVQBZ128rrik = 6965, + X86_VGF2P8AFFINEINVQBZ128rrikz = 6966, + X86_VGF2P8AFFINEINVQBZ256rmbi = 6967, + X86_VGF2P8AFFINEINVQBZ256rmbik = 6968, + X86_VGF2P8AFFINEINVQBZ256rmbikz = 6969, + X86_VGF2P8AFFINEINVQBZ256rmi = 6970, + X86_VGF2P8AFFINEINVQBZ256rmik = 6971, + X86_VGF2P8AFFINEINVQBZ256rmikz = 6972, + X86_VGF2P8AFFINEINVQBZ256rri = 6973, + X86_VGF2P8AFFINEINVQBZ256rrik = 6974, + X86_VGF2P8AFFINEINVQBZ256rrikz = 6975, + X86_VGF2P8AFFINEINVQBZrmbi = 6976, + X86_VGF2P8AFFINEINVQBZrmbik = 6977, + X86_VGF2P8AFFINEINVQBZrmbikz = 6978, + X86_VGF2P8AFFINEINVQBZrmi = 6979, + X86_VGF2P8AFFINEINVQBZrmik = 6980, + X86_VGF2P8AFFINEINVQBZrmikz = 6981, + X86_VGF2P8AFFINEINVQBZrri = 6982, + X86_VGF2P8AFFINEINVQBZrrik = 6983, + X86_VGF2P8AFFINEINVQBZrrikz = 6984, + X86_VGF2P8AFFINEINVQBrmi = 6985, + X86_VGF2P8AFFINEINVQBrri = 6986, + X86_VGF2P8AFFINEQBYrmi = 6987, + X86_VGF2P8AFFINEQBYrri = 6988, + X86_VGF2P8AFFINEQBZ128rmbi = 6989, + X86_VGF2P8AFFINEQBZ128rmbik = 6990, + X86_VGF2P8AFFINEQBZ128rmbikz = 6991, + X86_VGF2P8AFFINEQBZ128rmi = 6992, + X86_VGF2P8AFFINEQBZ128rmik = 6993, + X86_VGF2P8AFFINEQBZ128rmikz = 6994, + X86_VGF2P8AFFINEQBZ128rri = 6995, + X86_VGF2P8AFFINEQBZ128rrik = 6996, + X86_VGF2P8AFFINEQBZ128rrikz = 6997, + X86_VGF2P8AFFINEQBZ256rmbi = 6998, + X86_VGF2P8AFFINEQBZ256rmbik = 6999, + X86_VGF2P8AFFINEQBZ256rmbikz = 7000, + X86_VGF2P8AFFINEQBZ256rmi = 7001, + X86_VGF2P8AFFINEQBZ256rmik = 7002, + X86_VGF2P8AFFINEQBZ256rmikz = 7003, + X86_VGF2P8AFFINEQBZ256rri = 7004, + X86_VGF2P8AFFINEQBZ256rrik = 7005, + X86_VGF2P8AFFINEQBZ256rrikz = 7006, + X86_VGF2P8AFFINEQBZrmbi = 7007, + X86_VGF2P8AFFINEQBZrmbik = 7008, + X86_VGF2P8AFFINEQBZrmbikz = 7009, + X86_VGF2P8AFFINEQBZrmi = 7010, + X86_VGF2P8AFFINEQBZrmik = 7011, + X86_VGF2P8AFFINEQBZrmikz = 7012, + X86_VGF2P8AFFINEQBZrri = 7013, + X86_VGF2P8AFFINEQBZrrik = 7014, + X86_VGF2P8AFFINEQBZrrikz = 7015, + X86_VGF2P8AFFINEQBrmi = 7016, + X86_VGF2P8AFFINEQBrri = 7017, + X86_VGF2P8MULBYrm = 7018, + X86_VGF2P8MULBYrr = 7019, + X86_VGF2P8MULBZ128rm = 7020, + X86_VGF2P8MULBZ128rmk = 7021, + X86_VGF2P8MULBZ128rmkz = 7022, + X86_VGF2P8MULBZ128rr = 7023, + X86_VGF2P8MULBZ128rrk = 7024, + X86_VGF2P8MULBZ128rrkz = 7025, + X86_VGF2P8MULBZ256rm = 7026, + X86_VGF2P8MULBZ256rmk = 7027, + X86_VGF2P8MULBZ256rmkz = 7028, + X86_VGF2P8MULBZ256rr = 7029, + X86_VGF2P8MULBZ256rrk = 7030, + X86_VGF2P8MULBZ256rrkz = 7031, + X86_VGF2P8MULBZrm = 7032, + X86_VGF2P8MULBZrmk = 7033, + X86_VGF2P8MULBZrmkz = 7034, + X86_VGF2P8MULBZrr = 7035, + X86_VGF2P8MULBZrrk = 7036, + X86_VGF2P8MULBZrrkz = 7037, + X86_VGF2P8MULBrm = 7038, + X86_VGF2P8MULBrr = 7039, + X86_VHADDPDYrm = 7040, + X86_VHADDPDYrr = 7041, + X86_VHADDPDrm = 7042, + X86_VHADDPDrr = 7043, + X86_VHADDPSYrm = 7044, + X86_VHADDPSYrr = 7045, + X86_VHADDPSrm = 7046, + X86_VHADDPSrr = 7047, + X86_VHSUBPDYrm = 7048, + X86_VHSUBPDYrr = 7049, + X86_VHSUBPDrm = 7050, + X86_VHSUBPDrr = 7051, + X86_VHSUBPSYrm = 7052, + X86_VHSUBPSYrr = 7053, + X86_VHSUBPSrm = 7054, + X86_VHSUBPSrr = 7055, + X86_VINSERTF128rm = 7056, + X86_VINSERTF128rr = 7057, + X86_VINSERTF32x4Z256rm = 7058, + X86_VINSERTF32x4Z256rmk = 7059, + X86_VINSERTF32x4Z256rmkz = 7060, + X86_VINSERTF32x4Z256rr = 7061, + X86_VINSERTF32x4Z256rrk = 7062, + X86_VINSERTF32x4Z256rrkz = 7063, + X86_VINSERTF32x4Zrm = 7064, + X86_VINSERTF32x4Zrmk = 7065, + X86_VINSERTF32x4Zrmkz = 7066, + X86_VINSERTF32x4Zrr = 7067, + X86_VINSERTF32x4Zrrk = 7068, + X86_VINSERTF32x4Zrrkz = 7069, + X86_VINSERTF32x8Zrm = 7070, + X86_VINSERTF32x8Zrmk = 7071, + X86_VINSERTF32x8Zrmkz = 7072, + X86_VINSERTF32x8Zrr = 7073, + X86_VINSERTF32x8Zrrk = 7074, + X86_VINSERTF32x8Zrrkz = 7075, + X86_VINSERTF64x2Z256rm = 7076, + X86_VINSERTF64x2Z256rmk = 7077, + X86_VINSERTF64x2Z256rmkz = 7078, + X86_VINSERTF64x2Z256rr = 7079, + X86_VINSERTF64x2Z256rrk = 7080, + X86_VINSERTF64x2Z256rrkz = 7081, + X86_VINSERTF64x2Zrm = 7082, + X86_VINSERTF64x2Zrmk = 7083, + X86_VINSERTF64x2Zrmkz = 7084, + X86_VINSERTF64x2Zrr = 7085, + X86_VINSERTF64x2Zrrk = 7086, + X86_VINSERTF64x2Zrrkz = 7087, + X86_VINSERTF64x4Zrm = 7088, + X86_VINSERTF64x4Zrmk = 7089, + X86_VINSERTF64x4Zrmkz = 7090, + X86_VINSERTF64x4Zrr = 7091, + X86_VINSERTF64x4Zrrk = 7092, + X86_VINSERTF64x4Zrrkz = 7093, + X86_VINSERTI128rm = 7094, + X86_VINSERTI128rr = 7095, + X86_VINSERTI32x4Z256rm = 7096, + X86_VINSERTI32x4Z256rmk = 7097, + X86_VINSERTI32x4Z256rmkz = 7098, + X86_VINSERTI32x4Z256rr = 7099, + X86_VINSERTI32x4Z256rrk = 7100, + X86_VINSERTI32x4Z256rrkz = 7101, + X86_VINSERTI32x4Zrm = 7102, + X86_VINSERTI32x4Zrmk = 7103, + X86_VINSERTI32x4Zrmkz = 7104, + X86_VINSERTI32x4Zrr = 7105, + X86_VINSERTI32x4Zrrk = 7106, + X86_VINSERTI32x4Zrrkz = 7107, + X86_VINSERTI32x8Zrm = 7108, + X86_VINSERTI32x8Zrmk = 7109, + X86_VINSERTI32x8Zrmkz = 7110, + X86_VINSERTI32x8Zrr = 7111, + X86_VINSERTI32x8Zrrk = 7112, + X86_VINSERTI32x8Zrrkz = 7113, + X86_VINSERTI64x2Z256rm = 7114, + X86_VINSERTI64x2Z256rmk = 7115, + X86_VINSERTI64x2Z256rmkz = 7116, + X86_VINSERTI64x2Z256rr = 7117, + X86_VINSERTI64x2Z256rrk = 7118, + X86_VINSERTI64x2Z256rrkz = 7119, + X86_VINSERTI64x2Zrm = 7120, + X86_VINSERTI64x2Zrmk = 7121, + X86_VINSERTI64x2Zrmkz = 7122, + X86_VINSERTI64x2Zrr = 7123, + X86_VINSERTI64x2Zrrk = 7124, + X86_VINSERTI64x2Zrrkz = 7125, + X86_VINSERTI64x4Zrm = 7126, + X86_VINSERTI64x4Zrmk = 7127, + X86_VINSERTI64x4Zrmkz = 7128, + X86_VINSERTI64x4Zrr = 7129, + X86_VINSERTI64x4Zrrk = 7130, + X86_VINSERTI64x4Zrrkz = 7131, + X86_VINSERTPSZrm = 7132, + X86_VINSERTPSZrr = 7133, + X86_VINSERTPSrm = 7134, + X86_VINSERTPSrr = 7135, + X86_VLDDQUYrm = 7136, + X86_VLDDQUrm = 7137, + X86_VLDMXCSR = 7138, + X86_VMASKMOVDQU = 7139, + X86_VMASKMOVDQU64 = 7140, + X86_VMASKMOVPDYmr = 7141, + X86_VMASKMOVPDYrm = 7142, + X86_VMASKMOVPDmr = 7143, + X86_VMASKMOVPDrm = 7144, + X86_VMASKMOVPSYmr = 7145, + X86_VMASKMOVPSYrm = 7146, + X86_VMASKMOVPSmr = 7147, + X86_VMASKMOVPSrm = 7148, + X86_VMAXCPDYrm = 7149, + X86_VMAXCPDYrr = 7150, + X86_VMAXCPDZ128rm = 7151, + X86_VMAXCPDZ128rmb = 7152, + X86_VMAXCPDZ128rmbk = 7153, + X86_VMAXCPDZ128rmbkz = 7154, + X86_VMAXCPDZ128rmk = 7155, + X86_VMAXCPDZ128rmkz = 7156, + X86_VMAXCPDZ128rr = 7157, + X86_VMAXCPDZ128rrk = 7158, + X86_VMAXCPDZ128rrkz = 7159, + X86_VMAXCPDZ256rm = 7160, + X86_VMAXCPDZ256rmb = 7161, + X86_VMAXCPDZ256rmbk = 7162, + X86_VMAXCPDZ256rmbkz = 7163, + X86_VMAXCPDZ256rmk = 7164, + X86_VMAXCPDZ256rmkz = 7165, + X86_VMAXCPDZ256rr = 7166, + X86_VMAXCPDZ256rrk = 7167, + X86_VMAXCPDZ256rrkz = 7168, + X86_VMAXCPDZrm = 7169, + X86_VMAXCPDZrmb = 7170, + X86_VMAXCPDZrmbk = 7171, + X86_VMAXCPDZrmbkz = 7172, + X86_VMAXCPDZrmk = 7173, + X86_VMAXCPDZrmkz = 7174, + X86_VMAXCPDZrr = 7175, + X86_VMAXCPDZrrk = 7176, + X86_VMAXCPDZrrkz = 7177, + X86_VMAXCPDrm = 7178, + X86_VMAXCPDrr = 7179, + X86_VMAXCPSYrm = 7180, + X86_VMAXCPSYrr = 7181, + X86_VMAXCPSZ128rm = 7182, + X86_VMAXCPSZ128rmb = 7183, + X86_VMAXCPSZ128rmbk = 7184, + X86_VMAXCPSZ128rmbkz = 7185, + X86_VMAXCPSZ128rmk = 7186, + X86_VMAXCPSZ128rmkz = 7187, + X86_VMAXCPSZ128rr = 7188, + X86_VMAXCPSZ128rrk = 7189, + X86_VMAXCPSZ128rrkz = 7190, + X86_VMAXCPSZ256rm = 7191, + X86_VMAXCPSZ256rmb = 7192, + X86_VMAXCPSZ256rmbk = 7193, + X86_VMAXCPSZ256rmbkz = 7194, + X86_VMAXCPSZ256rmk = 7195, + X86_VMAXCPSZ256rmkz = 7196, + X86_VMAXCPSZ256rr = 7197, + X86_VMAXCPSZ256rrk = 7198, + X86_VMAXCPSZ256rrkz = 7199, + X86_VMAXCPSZrm = 7200, + X86_VMAXCPSZrmb = 7201, + X86_VMAXCPSZrmbk = 7202, + X86_VMAXCPSZrmbkz = 7203, + X86_VMAXCPSZrmk = 7204, + X86_VMAXCPSZrmkz = 7205, + X86_VMAXCPSZrr = 7206, + X86_VMAXCPSZrrk = 7207, + X86_VMAXCPSZrrkz = 7208, + X86_VMAXCPSrm = 7209, + X86_VMAXCPSrr = 7210, + X86_VMAXCSDZrm = 7211, + X86_VMAXCSDZrr = 7212, + X86_VMAXCSDrm = 7213, + X86_VMAXCSDrr = 7214, + X86_VMAXCSSZrm = 7215, + X86_VMAXCSSZrr = 7216, + X86_VMAXCSSrm = 7217, + X86_VMAXCSSrr = 7218, + X86_VMAXPDYrm = 7219, + X86_VMAXPDYrr = 7220, + X86_VMAXPDZ128rm = 7221, + X86_VMAXPDZ128rmb = 7222, + X86_VMAXPDZ128rmbk = 7223, + X86_VMAXPDZ128rmbkz = 7224, + X86_VMAXPDZ128rmk = 7225, + X86_VMAXPDZ128rmkz = 7226, + X86_VMAXPDZ128rr = 7227, + X86_VMAXPDZ128rrk = 7228, + X86_VMAXPDZ128rrkz = 7229, + X86_VMAXPDZ256rm = 7230, + X86_VMAXPDZ256rmb = 7231, + X86_VMAXPDZ256rmbk = 7232, + X86_VMAXPDZ256rmbkz = 7233, + X86_VMAXPDZ256rmk = 7234, + X86_VMAXPDZ256rmkz = 7235, + X86_VMAXPDZ256rr = 7236, + X86_VMAXPDZ256rrk = 7237, + X86_VMAXPDZ256rrkz = 7238, + X86_VMAXPDZrm = 7239, + X86_VMAXPDZrmb = 7240, + X86_VMAXPDZrmbk = 7241, + X86_VMAXPDZrmbkz = 7242, + X86_VMAXPDZrmk = 7243, + X86_VMAXPDZrmkz = 7244, + X86_VMAXPDZrr = 7245, + X86_VMAXPDZrrb = 7246, + X86_VMAXPDZrrbk = 7247, + X86_VMAXPDZrrbkz = 7248, + X86_VMAXPDZrrk = 7249, + X86_VMAXPDZrrkz = 7250, + X86_VMAXPDrm = 7251, + X86_VMAXPDrr = 7252, + X86_VMAXPSYrm = 7253, + X86_VMAXPSYrr = 7254, + X86_VMAXPSZ128rm = 7255, + X86_VMAXPSZ128rmb = 7256, + X86_VMAXPSZ128rmbk = 7257, + X86_VMAXPSZ128rmbkz = 7258, + X86_VMAXPSZ128rmk = 7259, + X86_VMAXPSZ128rmkz = 7260, + X86_VMAXPSZ128rr = 7261, + X86_VMAXPSZ128rrk = 7262, + X86_VMAXPSZ128rrkz = 7263, + X86_VMAXPSZ256rm = 7264, + X86_VMAXPSZ256rmb = 7265, + X86_VMAXPSZ256rmbk = 7266, + X86_VMAXPSZ256rmbkz = 7267, + X86_VMAXPSZ256rmk = 7268, + X86_VMAXPSZ256rmkz = 7269, + X86_VMAXPSZ256rr = 7270, + X86_VMAXPSZ256rrk = 7271, + X86_VMAXPSZ256rrkz = 7272, + X86_VMAXPSZrm = 7273, + X86_VMAXPSZrmb = 7274, + X86_VMAXPSZrmbk = 7275, + X86_VMAXPSZrmbkz = 7276, + X86_VMAXPSZrmk = 7277, + X86_VMAXPSZrmkz = 7278, + X86_VMAXPSZrr = 7279, + X86_VMAXPSZrrb = 7280, + X86_VMAXPSZrrbk = 7281, + X86_VMAXPSZrrbkz = 7282, + X86_VMAXPSZrrk = 7283, + X86_VMAXPSZrrkz = 7284, + X86_VMAXPSrm = 7285, + X86_VMAXPSrr = 7286, + X86_VMAXSDZrm = 7287, + X86_VMAXSDZrm_Int = 7288, + X86_VMAXSDZrm_Intk = 7289, + X86_VMAXSDZrm_Intkz = 7290, + X86_VMAXSDZrr = 7291, + X86_VMAXSDZrr_Int = 7292, + X86_VMAXSDZrr_Intk = 7293, + X86_VMAXSDZrr_Intkz = 7294, + X86_VMAXSDZrrb_Int = 7295, + X86_VMAXSDZrrb_Intk = 7296, + X86_VMAXSDZrrb_Intkz = 7297, + X86_VMAXSDrm = 7298, + X86_VMAXSDrm_Int = 7299, + X86_VMAXSDrr = 7300, + X86_VMAXSDrr_Int = 7301, + X86_VMAXSSZrm = 7302, + X86_VMAXSSZrm_Int = 7303, + X86_VMAXSSZrm_Intk = 7304, + X86_VMAXSSZrm_Intkz = 7305, + X86_VMAXSSZrr = 7306, + X86_VMAXSSZrr_Int = 7307, + X86_VMAXSSZrr_Intk = 7308, + X86_VMAXSSZrr_Intkz = 7309, + X86_VMAXSSZrrb_Int = 7310, + X86_VMAXSSZrrb_Intk = 7311, + X86_VMAXSSZrrb_Intkz = 7312, + X86_VMAXSSrm = 7313, + X86_VMAXSSrm_Int = 7314, + X86_VMAXSSrr = 7315, + X86_VMAXSSrr_Int = 7316, + X86_VMCALL = 7317, + X86_VMCLEARm = 7318, + X86_VMFUNC = 7319, + X86_VMINCPDYrm = 7320, + X86_VMINCPDYrr = 7321, + X86_VMINCPDZ128rm = 7322, + X86_VMINCPDZ128rmb = 7323, + X86_VMINCPDZ128rmbk = 7324, + X86_VMINCPDZ128rmbkz = 7325, + X86_VMINCPDZ128rmk = 7326, + X86_VMINCPDZ128rmkz = 7327, + X86_VMINCPDZ128rr = 7328, + X86_VMINCPDZ128rrk = 7329, + X86_VMINCPDZ128rrkz = 7330, + X86_VMINCPDZ256rm = 7331, + X86_VMINCPDZ256rmb = 7332, + X86_VMINCPDZ256rmbk = 7333, + X86_VMINCPDZ256rmbkz = 7334, + X86_VMINCPDZ256rmk = 7335, + X86_VMINCPDZ256rmkz = 7336, + X86_VMINCPDZ256rr = 7337, + X86_VMINCPDZ256rrk = 7338, + X86_VMINCPDZ256rrkz = 7339, + X86_VMINCPDZrm = 7340, + X86_VMINCPDZrmb = 7341, + X86_VMINCPDZrmbk = 7342, + X86_VMINCPDZrmbkz = 7343, + X86_VMINCPDZrmk = 7344, + X86_VMINCPDZrmkz = 7345, + X86_VMINCPDZrr = 7346, + X86_VMINCPDZrrk = 7347, + X86_VMINCPDZrrkz = 7348, + X86_VMINCPDrm = 7349, + X86_VMINCPDrr = 7350, + X86_VMINCPSYrm = 7351, + X86_VMINCPSYrr = 7352, + X86_VMINCPSZ128rm = 7353, + X86_VMINCPSZ128rmb = 7354, + X86_VMINCPSZ128rmbk = 7355, + X86_VMINCPSZ128rmbkz = 7356, + X86_VMINCPSZ128rmk = 7357, + X86_VMINCPSZ128rmkz = 7358, + X86_VMINCPSZ128rr = 7359, + X86_VMINCPSZ128rrk = 7360, + X86_VMINCPSZ128rrkz = 7361, + X86_VMINCPSZ256rm = 7362, + X86_VMINCPSZ256rmb = 7363, + X86_VMINCPSZ256rmbk = 7364, + X86_VMINCPSZ256rmbkz = 7365, + X86_VMINCPSZ256rmk = 7366, + X86_VMINCPSZ256rmkz = 7367, + X86_VMINCPSZ256rr = 7368, + X86_VMINCPSZ256rrk = 7369, + X86_VMINCPSZ256rrkz = 7370, + X86_VMINCPSZrm = 7371, + X86_VMINCPSZrmb = 7372, + X86_VMINCPSZrmbk = 7373, + X86_VMINCPSZrmbkz = 7374, + X86_VMINCPSZrmk = 7375, + X86_VMINCPSZrmkz = 7376, + X86_VMINCPSZrr = 7377, + X86_VMINCPSZrrk = 7378, + X86_VMINCPSZrrkz = 7379, + X86_VMINCPSrm = 7380, + X86_VMINCPSrr = 7381, + X86_VMINCSDZrm = 7382, + X86_VMINCSDZrr = 7383, + X86_VMINCSDrm = 7384, + X86_VMINCSDrr = 7385, + X86_VMINCSSZrm = 7386, + X86_VMINCSSZrr = 7387, + X86_VMINCSSrm = 7388, + X86_VMINCSSrr = 7389, + X86_VMINPDYrm = 7390, + X86_VMINPDYrr = 7391, + X86_VMINPDZ128rm = 7392, + X86_VMINPDZ128rmb = 7393, + X86_VMINPDZ128rmbk = 7394, + X86_VMINPDZ128rmbkz = 7395, + X86_VMINPDZ128rmk = 7396, + X86_VMINPDZ128rmkz = 7397, + X86_VMINPDZ128rr = 7398, + X86_VMINPDZ128rrk = 7399, + X86_VMINPDZ128rrkz = 7400, + X86_VMINPDZ256rm = 7401, + X86_VMINPDZ256rmb = 7402, + X86_VMINPDZ256rmbk = 7403, + X86_VMINPDZ256rmbkz = 7404, + X86_VMINPDZ256rmk = 7405, + X86_VMINPDZ256rmkz = 7406, + X86_VMINPDZ256rr = 7407, + X86_VMINPDZ256rrk = 7408, + X86_VMINPDZ256rrkz = 7409, + X86_VMINPDZrm = 7410, + X86_VMINPDZrmb = 7411, + X86_VMINPDZrmbk = 7412, + X86_VMINPDZrmbkz = 7413, + X86_VMINPDZrmk = 7414, + X86_VMINPDZrmkz = 7415, + X86_VMINPDZrr = 7416, + X86_VMINPDZrrb = 7417, + X86_VMINPDZrrbk = 7418, + X86_VMINPDZrrbkz = 7419, + X86_VMINPDZrrk = 7420, + X86_VMINPDZrrkz = 7421, + X86_VMINPDrm = 7422, + X86_VMINPDrr = 7423, + X86_VMINPSYrm = 7424, + X86_VMINPSYrr = 7425, + X86_VMINPSZ128rm = 7426, + X86_VMINPSZ128rmb = 7427, + X86_VMINPSZ128rmbk = 7428, + X86_VMINPSZ128rmbkz = 7429, + X86_VMINPSZ128rmk = 7430, + X86_VMINPSZ128rmkz = 7431, + X86_VMINPSZ128rr = 7432, + X86_VMINPSZ128rrk = 7433, + X86_VMINPSZ128rrkz = 7434, + X86_VMINPSZ256rm = 7435, + X86_VMINPSZ256rmb = 7436, + X86_VMINPSZ256rmbk = 7437, + X86_VMINPSZ256rmbkz = 7438, + X86_VMINPSZ256rmk = 7439, + X86_VMINPSZ256rmkz = 7440, + X86_VMINPSZ256rr = 7441, + X86_VMINPSZ256rrk = 7442, + X86_VMINPSZ256rrkz = 7443, + X86_VMINPSZrm = 7444, + X86_VMINPSZrmb = 7445, + X86_VMINPSZrmbk = 7446, + X86_VMINPSZrmbkz = 7447, + X86_VMINPSZrmk = 7448, + X86_VMINPSZrmkz = 7449, + X86_VMINPSZrr = 7450, + X86_VMINPSZrrb = 7451, + X86_VMINPSZrrbk = 7452, + X86_VMINPSZrrbkz = 7453, + X86_VMINPSZrrk = 7454, + X86_VMINPSZrrkz = 7455, + X86_VMINPSrm = 7456, + X86_VMINPSrr = 7457, + X86_VMINSDZrm = 7458, + X86_VMINSDZrm_Int = 7459, + X86_VMINSDZrm_Intk = 7460, + X86_VMINSDZrm_Intkz = 7461, + X86_VMINSDZrr = 7462, + X86_VMINSDZrr_Int = 7463, + X86_VMINSDZrr_Intk = 7464, + X86_VMINSDZrr_Intkz = 7465, + X86_VMINSDZrrb_Int = 7466, + X86_VMINSDZrrb_Intk = 7467, + X86_VMINSDZrrb_Intkz = 7468, + X86_VMINSDrm = 7469, + X86_VMINSDrm_Int = 7470, + X86_VMINSDrr = 7471, + X86_VMINSDrr_Int = 7472, + X86_VMINSSZrm = 7473, + X86_VMINSSZrm_Int = 7474, + X86_VMINSSZrm_Intk = 7475, + X86_VMINSSZrm_Intkz = 7476, + X86_VMINSSZrr = 7477, + X86_VMINSSZrr_Int = 7478, + X86_VMINSSZrr_Intk = 7479, + X86_VMINSSZrr_Intkz = 7480, + X86_VMINSSZrrb_Int = 7481, + X86_VMINSSZrrb_Intk = 7482, + X86_VMINSSZrrb_Intkz = 7483, + X86_VMINSSrm = 7484, + X86_VMINSSrm_Int = 7485, + X86_VMINSSrr = 7486, + X86_VMINSSrr_Int = 7487, + X86_VMLAUNCH = 7488, + X86_VMLOAD32 = 7489, + X86_VMLOAD64 = 7490, + X86_VMMCALL = 7491, + X86_VMOV64toPQIZrm = 7492, + X86_VMOV64toPQIZrr = 7493, + X86_VMOV64toPQIrm = 7494, + X86_VMOV64toPQIrr = 7495, + X86_VMOV64toSDZrm = 7496, + X86_VMOV64toSDZrr = 7497, + X86_VMOV64toSDrm = 7498, + X86_VMOV64toSDrr = 7499, + X86_VMOVAPDYmr = 7500, + X86_VMOVAPDYrm = 7501, + X86_VMOVAPDYrr = 7502, + X86_VMOVAPDYrr_REV = 7503, + X86_VMOVAPDZ128mr = 7504, + X86_VMOVAPDZ128mrk = 7505, + X86_VMOVAPDZ128rm = 7506, + X86_VMOVAPDZ128rmk = 7507, + X86_VMOVAPDZ128rmkz = 7508, + X86_VMOVAPDZ128rr = 7509, + X86_VMOVAPDZ128rr_REV = 7510, + X86_VMOVAPDZ128rrk = 7511, + X86_VMOVAPDZ128rrk_REV = 7512, + X86_VMOVAPDZ128rrkz = 7513, + X86_VMOVAPDZ128rrkz_REV = 7514, + X86_VMOVAPDZ256mr = 7515, + X86_VMOVAPDZ256mrk = 7516, + X86_VMOVAPDZ256rm = 7517, + X86_VMOVAPDZ256rmk = 7518, + X86_VMOVAPDZ256rmkz = 7519, + X86_VMOVAPDZ256rr = 7520, + X86_VMOVAPDZ256rr_REV = 7521, + X86_VMOVAPDZ256rrk = 7522, + X86_VMOVAPDZ256rrk_REV = 7523, + X86_VMOVAPDZ256rrkz = 7524, + X86_VMOVAPDZ256rrkz_REV = 7525, + X86_VMOVAPDZmr = 7526, + X86_VMOVAPDZmrk = 7527, + X86_VMOVAPDZrm = 7528, + X86_VMOVAPDZrmk = 7529, + X86_VMOVAPDZrmkz = 7530, + X86_VMOVAPDZrr = 7531, + X86_VMOVAPDZrr_REV = 7532, + X86_VMOVAPDZrrk = 7533, + X86_VMOVAPDZrrk_REV = 7534, + X86_VMOVAPDZrrkz = 7535, + X86_VMOVAPDZrrkz_REV = 7536, + X86_VMOVAPDmr = 7537, + X86_VMOVAPDrm = 7538, + X86_VMOVAPDrr = 7539, + X86_VMOVAPDrr_REV = 7540, + X86_VMOVAPSYmr = 7541, + X86_VMOVAPSYrm = 7542, + X86_VMOVAPSYrr = 7543, + X86_VMOVAPSYrr_REV = 7544, + X86_VMOVAPSZ128mr = 7545, + X86_VMOVAPSZ128mrk = 7546, + X86_VMOVAPSZ128rm = 7547, + X86_VMOVAPSZ128rmk = 7548, + X86_VMOVAPSZ128rmkz = 7549, + X86_VMOVAPSZ128rr = 7550, + X86_VMOVAPSZ128rr_REV = 7551, + X86_VMOVAPSZ128rrk = 7552, + X86_VMOVAPSZ128rrk_REV = 7553, + X86_VMOVAPSZ128rrkz = 7554, + X86_VMOVAPSZ128rrkz_REV = 7555, + X86_VMOVAPSZ256mr = 7556, + X86_VMOVAPSZ256mrk = 7557, + X86_VMOVAPSZ256rm = 7558, + X86_VMOVAPSZ256rmk = 7559, + X86_VMOVAPSZ256rmkz = 7560, + X86_VMOVAPSZ256rr = 7561, + X86_VMOVAPSZ256rr_REV = 7562, + X86_VMOVAPSZ256rrk = 7563, + X86_VMOVAPSZ256rrk_REV = 7564, + X86_VMOVAPSZ256rrkz = 7565, + X86_VMOVAPSZ256rrkz_REV = 7566, + X86_VMOVAPSZmr = 7567, + X86_VMOVAPSZmrk = 7568, + X86_VMOVAPSZrm = 7569, + X86_VMOVAPSZrmk = 7570, + X86_VMOVAPSZrmkz = 7571, + X86_VMOVAPSZrr = 7572, + X86_VMOVAPSZrr_REV = 7573, + X86_VMOVAPSZrrk = 7574, + X86_VMOVAPSZrrk_REV = 7575, + X86_VMOVAPSZrrkz = 7576, + X86_VMOVAPSZrrkz_REV = 7577, + X86_VMOVAPSmr = 7578, + X86_VMOVAPSrm = 7579, + X86_VMOVAPSrr = 7580, + X86_VMOVAPSrr_REV = 7581, + X86_VMOVDDUPYrm = 7582, + X86_VMOVDDUPYrr = 7583, + X86_VMOVDDUPZ128rm = 7584, + X86_VMOVDDUPZ128rmk = 7585, + X86_VMOVDDUPZ128rmkz = 7586, + X86_VMOVDDUPZ128rr = 7587, + X86_VMOVDDUPZ128rrk = 7588, + X86_VMOVDDUPZ128rrkz = 7589, + X86_VMOVDDUPZ256rm = 7590, + X86_VMOVDDUPZ256rmk = 7591, + X86_VMOVDDUPZ256rmkz = 7592, + X86_VMOVDDUPZ256rr = 7593, + X86_VMOVDDUPZ256rrk = 7594, + X86_VMOVDDUPZ256rrkz = 7595, + X86_VMOVDDUPZrm = 7596, + X86_VMOVDDUPZrmk = 7597, + X86_VMOVDDUPZrmkz = 7598, + X86_VMOVDDUPZrr = 7599, + X86_VMOVDDUPZrrk = 7600, + X86_VMOVDDUPZrrkz = 7601, + X86_VMOVDDUPrm = 7602, + X86_VMOVDDUPrr = 7603, + X86_VMOVDI2PDIZrm = 7604, + X86_VMOVDI2PDIZrr = 7605, + X86_VMOVDI2PDIrm = 7606, + X86_VMOVDI2PDIrr = 7607, + X86_VMOVDI2SSZrm = 7608, + X86_VMOVDI2SSZrr = 7609, + X86_VMOVDI2SSrm = 7610, + X86_VMOVDI2SSrr = 7611, + X86_VMOVDQA32Z128mr = 7612, + X86_VMOVDQA32Z128mrk = 7613, + X86_VMOVDQA32Z128rm = 7614, + X86_VMOVDQA32Z128rmk = 7615, + X86_VMOVDQA32Z128rmkz = 7616, + X86_VMOVDQA32Z128rr = 7617, + X86_VMOVDQA32Z128rr_REV = 7618, + X86_VMOVDQA32Z128rrk = 7619, + X86_VMOVDQA32Z128rrk_REV = 7620, + X86_VMOVDQA32Z128rrkz = 7621, + X86_VMOVDQA32Z128rrkz_REV = 7622, + X86_VMOVDQA32Z256mr = 7623, + X86_VMOVDQA32Z256mrk = 7624, + X86_VMOVDQA32Z256rm = 7625, + X86_VMOVDQA32Z256rmk = 7626, + X86_VMOVDQA32Z256rmkz = 7627, + X86_VMOVDQA32Z256rr = 7628, + X86_VMOVDQA32Z256rr_REV = 7629, + X86_VMOVDQA32Z256rrk = 7630, + X86_VMOVDQA32Z256rrk_REV = 7631, + X86_VMOVDQA32Z256rrkz = 7632, + X86_VMOVDQA32Z256rrkz_REV = 7633, + X86_VMOVDQA32Zmr = 7634, + X86_VMOVDQA32Zmrk = 7635, + X86_VMOVDQA32Zrm = 7636, + X86_VMOVDQA32Zrmk = 7637, + X86_VMOVDQA32Zrmkz = 7638, + X86_VMOVDQA32Zrr = 7639, + X86_VMOVDQA32Zrr_REV = 7640, + X86_VMOVDQA32Zrrk = 7641, + X86_VMOVDQA32Zrrk_REV = 7642, + X86_VMOVDQA32Zrrkz = 7643, + X86_VMOVDQA32Zrrkz_REV = 7644, + X86_VMOVDQA64Z128mr = 7645, + X86_VMOVDQA64Z128mrk = 7646, + X86_VMOVDQA64Z128rm = 7647, + X86_VMOVDQA64Z128rmk = 7648, + X86_VMOVDQA64Z128rmkz = 7649, + X86_VMOVDQA64Z128rr = 7650, + X86_VMOVDQA64Z128rr_REV = 7651, + X86_VMOVDQA64Z128rrk = 7652, + X86_VMOVDQA64Z128rrk_REV = 7653, + X86_VMOVDQA64Z128rrkz = 7654, + X86_VMOVDQA64Z128rrkz_REV = 7655, + X86_VMOVDQA64Z256mr = 7656, + X86_VMOVDQA64Z256mrk = 7657, + X86_VMOVDQA64Z256rm = 7658, + X86_VMOVDQA64Z256rmk = 7659, + X86_VMOVDQA64Z256rmkz = 7660, + X86_VMOVDQA64Z256rr = 7661, + X86_VMOVDQA64Z256rr_REV = 7662, + X86_VMOVDQA64Z256rrk = 7663, + X86_VMOVDQA64Z256rrk_REV = 7664, + X86_VMOVDQA64Z256rrkz = 7665, + X86_VMOVDQA64Z256rrkz_REV = 7666, + X86_VMOVDQA64Zmr = 7667, + X86_VMOVDQA64Zmrk = 7668, + X86_VMOVDQA64Zrm = 7669, + X86_VMOVDQA64Zrmk = 7670, + X86_VMOVDQA64Zrmkz = 7671, + X86_VMOVDQA64Zrr = 7672, + X86_VMOVDQA64Zrr_REV = 7673, + X86_VMOVDQA64Zrrk = 7674, + X86_VMOVDQA64Zrrk_REV = 7675, + X86_VMOVDQA64Zrrkz = 7676, + X86_VMOVDQA64Zrrkz_REV = 7677, + X86_VMOVDQAYmr = 7678, + X86_VMOVDQAYrm = 7679, + X86_VMOVDQAYrr = 7680, + X86_VMOVDQAYrr_REV = 7681, + X86_VMOVDQAmr = 7682, + X86_VMOVDQArm = 7683, + X86_VMOVDQArr = 7684, + X86_VMOVDQArr_REV = 7685, + X86_VMOVDQU16Z128mr = 7686, + X86_VMOVDQU16Z128mrk = 7687, + X86_VMOVDQU16Z128rm = 7688, + X86_VMOVDQU16Z128rmk = 7689, + X86_VMOVDQU16Z128rmkz = 7690, + X86_VMOVDQU16Z128rr = 7691, + X86_VMOVDQU16Z128rr_REV = 7692, + X86_VMOVDQU16Z128rrk = 7693, + X86_VMOVDQU16Z128rrk_REV = 7694, + X86_VMOVDQU16Z128rrkz = 7695, + X86_VMOVDQU16Z128rrkz_REV = 7696, + X86_VMOVDQU16Z256mr = 7697, + X86_VMOVDQU16Z256mrk = 7698, + X86_VMOVDQU16Z256rm = 7699, + X86_VMOVDQU16Z256rmk = 7700, + X86_VMOVDQU16Z256rmkz = 7701, + X86_VMOVDQU16Z256rr = 7702, + X86_VMOVDQU16Z256rr_REV = 7703, + X86_VMOVDQU16Z256rrk = 7704, + X86_VMOVDQU16Z256rrk_REV = 7705, + X86_VMOVDQU16Z256rrkz = 7706, + X86_VMOVDQU16Z256rrkz_REV = 7707, + X86_VMOVDQU16Zmr = 7708, + X86_VMOVDQU16Zmrk = 7709, + X86_VMOVDQU16Zrm = 7710, + X86_VMOVDQU16Zrmk = 7711, + X86_VMOVDQU16Zrmkz = 7712, + X86_VMOVDQU16Zrr = 7713, + X86_VMOVDQU16Zrr_REV = 7714, + X86_VMOVDQU16Zrrk = 7715, + X86_VMOVDQU16Zrrk_REV = 7716, + X86_VMOVDQU16Zrrkz = 7717, + X86_VMOVDQU16Zrrkz_REV = 7718, + X86_VMOVDQU32Z128mr = 7719, + X86_VMOVDQU32Z128mrk = 7720, + X86_VMOVDQU32Z128rm = 7721, + X86_VMOVDQU32Z128rmk = 7722, + X86_VMOVDQU32Z128rmkz = 7723, + X86_VMOVDQU32Z128rr = 7724, + X86_VMOVDQU32Z128rr_REV = 7725, + X86_VMOVDQU32Z128rrk = 7726, + X86_VMOVDQU32Z128rrk_REV = 7727, + X86_VMOVDQU32Z128rrkz = 7728, + X86_VMOVDQU32Z128rrkz_REV = 7729, + X86_VMOVDQU32Z256mr = 7730, + X86_VMOVDQU32Z256mrk = 7731, + X86_VMOVDQU32Z256rm = 7732, + X86_VMOVDQU32Z256rmk = 7733, + X86_VMOVDQU32Z256rmkz = 7734, + X86_VMOVDQU32Z256rr = 7735, + X86_VMOVDQU32Z256rr_REV = 7736, + X86_VMOVDQU32Z256rrk = 7737, + X86_VMOVDQU32Z256rrk_REV = 7738, + X86_VMOVDQU32Z256rrkz = 7739, + X86_VMOVDQU32Z256rrkz_REV = 7740, + X86_VMOVDQU32Zmr = 7741, + X86_VMOVDQU32Zmrk = 7742, + X86_VMOVDQU32Zrm = 7743, + X86_VMOVDQU32Zrmk = 7744, + X86_VMOVDQU32Zrmkz = 7745, + X86_VMOVDQU32Zrr = 7746, + X86_VMOVDQU32Zrr_REV = 7747, + X86_VMOVDQU32Zrrk = 7748, + X86_VMOVDQU32Zrrk_REV = 7749, + X86_VMOVDQU32Zrrkz = 7750, + X86_VMOVDQU32Zrrkz_REV = 7751, + X86_VMOVDQU64Z128mr = 7752, + X86_VMOVDQU64Z128mrk = 7753, + X86_VMOVDQU64Z128rm = 7754, + X86_VMOVDQU64Z128rmk = 7755, + X86_VMOVDQU64Z128rmkz = 7756, + X86_VMOVDQU64Z128rr = 7757, + X86_VMOVDQU64Z128rr_REV = 7758, + X86_VMOVDQU64Z128rrk = 7759, + X86_VMOVDQU64Z128rrk_REV = 7760, + X86_VMOVDQU64Z128rrkz = 7761, + X86_VMOVDQU64Z128rrkz_REV = 7762, + X86_VMOVDQU64Z256mr = 7763, + X86_VMOVDQU64Z256mrk = 7764, + X86_VMOVDQU64Z256rm = 7765, + X86_VMOVDQU64Z256rmk = 7766, + X86_VMOVDQU64Z256rmkz = 7767, + X86_VMOVDQU64Z256rr = 7768, + X86_VMOVDQU64Z256rr_REV = 7769, + X86_VMOVDQU64Z256rrk = 7770, + X86_VMOVDQU64Z256rrk_REV = 7771, + X86_VMOVDQU64Z256rrkz = 7772, + X86_VMOVDQU64Z256rrkz_REV = 7773, + X86_VMOVDQU64Zmr = 7774, + X86_VMOVDQU64Zmrk = 7775, + X86_VMOVDQU64Zrm = 7776, + X86_VMOVDQU64Zrmk = 7777, + X86_VMOVDQU64Zrmkz = 7778, + X86_VMOVDQU64Zrr = 7779, + X86_VMOVDQU64Zrr_REV = 7780, + X86_VMOVDQU64Zrrk = 7781, + X86_VMOVDQU64Zrrk_REV = 7782, + X86_VMOVDQU64Zrrkz = 7783, + X86_VMOVDQU64Zrrkz_REV = 7784, + X86_VMOVDQU8Z128mr = 7785, + X86_VMOVDQU8Z128mrk = 7786, + X86_VMOVDQU8Z128rm = 7787, + X86_VMOVDQU8Z128rmk = 7788, + X86_VMOVDQU8Z128rmkz = 7789, + X86_VMOVDQU8Z128rr = 7790, + X86_VMOVDQU8Z128rr_REV = 7791, + X86_VMOVDQU8Z128rrk = 7792, + X86_VMOVDQU8Z128rrk_REV = 7793, + X86_VMOVDQU8Z128rrkz = 7794, + X86_VMOVDQU8Z128rrkz_REV = 7795, + X86_VMOVDQU8Z256mr = 7796, + X86_VMOVDQU8Z256mrk = 7797, + X86_VMOVDQU8Z256rm = 7798, + X86_VMOVDQU8Z256rmk = 7799, + X86_VMOVDQU8Z256rmkz = 7800, + X86_VMOVDQU8Z256rr = 7801, + X86_VMOVDQU8Z256rr_REV = 7802, + X86_VMOVDQU8Z256rrk = 7803, + X86_VMOVDQU8Z256rrk_REV = 7804, + X86_VMOVDQU8Z256rrkz = 7805, + X86_VMOVDQU8Z256rrkz_REV = 7806, + X86_VMOVDQU8Zmr = 7807, + X86_VMOVDQU8Zmrk = 7808, + X86_VMOVDQU8Zrm = 7809, + X86_VMOVDQU8Zrmk = 7810, + X86_VMOVDQU8Zrmkz = 7811, + X86_VMOVDQU8Zrr = 7812, + X86_VMOVDQU8Zrr_REV = 7813, + X86_VMOVDQU8Zrrk = 7814, + X86_VMOVDQU8Zrrk_REV = 7815, + X86_VMOVDQU8Zrrkz = 7816, + X86_VMOVDQU8Zrrkz_REV = 7817, + X86_VMOVDQUYmr = 7818, + X86_VMOVDQUYrm = 7819, + X86_VMOVDQUYrr = 7820, + X86_VMOVDQUYrr_REV = 7821, + X86_VMOVDQUmr = 7822, + X86_VMOVDQUrm = 7823, + X86_VMOVDQUrr = 7824, + X86_VMOVDQUrr_REV = 7825, + X86_VMOVHLPSZrr = 7826, + X86_VMOVHLPSrr = 7827, + X86_VMOVHPDZ128mr = 7828, + X86_VMOVHPDZ128rm = 7829, + X86_VMOVHPDmr = 7830, + X86_VMOVHPDrm = 7831, + X86_VMOVHPSZ128mr = 7832, + X86_VMOVHPSZ128rm = 7833, + X86_VMOVHPSmr = 7834, + X86_VMOVHPSrm = 7835, + X86_VMOVLHPSZrr = 7836, + X86_VMOVLHPSrr = 7837, + X86_VMOVLPDZ128mr = 7838, + X86_VMOVLPDZ128rm = 7839, + X86_VMOVLPDmr = 7840, + X86_VMOVLPDrm = 7841, + X86_VMOVLPSZ128mr = 7842, + X86_VMOVLPSZ128rm = 7843, + X86_VMOVLPSmr = 7844, + X86_VMOVLPSrm = 7845, + X86_VMOVMSKPDYrr = 7846, + X86_VMOVMSKPDrr = 7847, + X86_VMOVMSKPSYrr = 7848, + X86_VMOVMSKPSrr = 7849, + X86_VMOVNTDQAYrm = 7850, + X86_VMOVNTDQAZ128rm = 7851, + X86_VMOVNTDQAZ256rm = 7852, + X86_VMOVNTDQAZrm = 7853, + X86_VMOVNTDQArm = 7854, + X86_VMOVNTDQYmr = 7855, + X86_VMOVNTDQZ128mr = 7856, + X86_VMOVNTDQZ256mr = 7857, + X86_VMOVNTDQZmr = 7858, + X86_VMOVNTDQmr = 7859, + X86_VMOVNTPDYmr = 7860, + X86_VMOVNTPDZ128mr = 7861, + X86_VMOVNTPDZ256mr = 7862, + X86_VMOVNTPDZmr = 7863, + X86_VMOVNTPDmr = 7864, + X86_VMOVNTPSYmr = 7865, + X86_VMOVNTPSZ128mr = 7866, + X86_VMOVNTPSZ256mr = 7867, + X86_VMOVNTPSZmr = 7868, + X86_VMOVNTPSmr = 7869, + X86_VMOVPDI2DIZmr = 7870, + X86_VMOVPDI2DIZrr = 7871, + X86_VMOVPDI2DImr = 7872, + X86_VMOVPDI2DIrr = 7873, + X86_VMOVPQI2QIZmr = 7874, + X86_VMOVPQI2QIZrr = 7875, + X86_VMOVPQI2QImr = 7876, + X86_VMOVPQI2QIrr = 7877, + X86_VMOVPQIto64Zmr = 7878, + X86_VMOVPQIto64Zrr = 7879, + X86_VMOVPQIto64mr = 7880, + X86_VMOVPQIto64rr = 7881, + X86_VMOVQI2PQIZrm = 7882, + X86_VMOVQI2PQIrm = 7883, + X86_VMOVSDZmr = 7884, + X86_VMOVSDZmrk = 7885, + X86_VMOVSDZrm = 7886, + X86_VMOVSDZrmk = 7887, + X86_VMOVSDZrmkz = 7888, + X86_VMOVSDZrr = 7889, + X86_VMOVSDZrr_REV = 7890, + X86_VMOVSDZrrk = 7891, + X86_VMOVSDZrrk_REV = 7892, + X86_VMOVSDZrrkz = 7893, + X86_VMOVSDZrrkz_REV = 7894, + X86_VMOVSDmr = 7895, + X86_VMOVSDrm = 7896, + X86_VMOVSDrr = 7897, + X86_VMOVSDrr_REV = 7898, + X86_VMOVSDto64Zmr = 7899, + X86_VMOVSDto64Zrr = 7900, + X86_VMOVSDto64mr = 7901, + X86_VMOVSDto64rr = 7902, + X86_VMOVSHDUPYrm = 7903, + X86_VMOVSHDUPYrr = 7904, + X86_VMOVSHDUPZ128rm = 7905, + X86_VMOVSHDUPZ128rmk = 7906, + X86_VMOVSHDUPZ128rmkz = 7907, + X86_VMOVSHDUPZ128rr = 7908, + X86_VMOVSHDUPZ128rrk = 7909, + X86_VMOVSHDUPZ128rrkz = 7910, + X86_VMOVSHDUPZ256rm = 7911, + X86_VMOVSHDUPZ256rmk = 7912, + X86_VMOVSHDUPZ256rmkz = 7913, + X86_VMOVSHDUPZ256rr = 7914, + X86_VMOVSHDUPZ256rrk = 7915, + X86_VMOVSHDUPZ256rrkz = 7916, + X86_VMOVSHDUPZrm = 7917, + X86_VMOVSHDUPZrmk = 7918, + X86_VMOVSHDUPZrmkz = 7919, + X86_VMOVSHDUPZrr = 7920, + X86_VMOVSHDUPZrrk = 7921, + X86_VMOVSHDUPZrrkz = 7922, + X86_VMOVSHDUPrm = 7923, + X86_VMOVSHDUPrr = 7924, + X86_VMOVSLDUPYrm = 7925, + X86_VMOVSLDUPYrr = 7926, + X86_VMOVSLDUPZ128rm = 7927, + X86_VMOVSLDUPZ128rmk = 7928, + X86_VMOVSLDUPZ128rmkz = 7929, + X86_VMOVSLDUPZ128rr = 7930, + X86_VMOVSLDUPZ128rrk = 7931, + X86_VMOVSLDUPZ128rrkz = 7932, + X86_VMOVSLDUPZ256rm = 7933, + X86_VMOVSLDUPZ256rmk = 7934, + X86_VMOVSLDUPZ256rmkz = 7935, + X86_VMOVSLDUPZ256rr = 7936, + X86_VMOVSLDUPZ256rrk = 7937, + X86_VMOVSLDUPZ256rrkz = 7938, + X86_VMOVSLDUPZrm = 7939, + X86_VMOVSLDUPZrmk = 7940, + X86_VMOVSLDUPZrmkz = 7941, + X86_VMOVSLDUPZrr = 7942, + X86_VMOVSLDUPZrrk = 7943, + X86_VMOVSLDUPZrrkz = 7944, + X86_VMOVSLDUPrm = 7945, + X86_VMOVSLDUPrr = 7946, + X86_VMOVSS2DIZmr = 7947, + X86_VMOVSS2DIZrr = 7948, + X86_VMOVSS2DImr = 7949, + X86_VMOVSS2DIrr = 7950, + X86_VMOVSSZmr = 7951, + X86_VMOVSSZmrk = 7952, + X86_VMOVSSZrm = 7953, + X86_VMOVSSZrmk = 7954, + X86_VMOVSSZrmkz = 7955, + X86_VMOVSSZrr = 7956, + X86_VMOVSSZrr_REV = 7957, + X86_VMOVSSZrrk = 7958, + X86_VMOVSSZrrk_REV = 7959, + X86_VMOVSSZrrkz = 7960, + X86_VMOVSSZrrkz_REV = 7961, + X86_VMOVSSmr = 7962, + X86_VMOVSSrm = 7963, + X86_VMOVSSrr = 7964, + X86_VMOVSSrr_REV = 7965, + X86_VMOVUPDYmr = 7966, + X86_VMOVUPDYrm = 7967, + X86_VMOVUPDYrr = 7968, + X86_VMOVUPDYrr_REV = 7969, + X86_VMOVUPDZ128mr = 7970, + X86_VMOVUPDZ128mrk = 7971, + X86_VMOVUPDZ128rm = 7972, + X86_VMOVUPDZ128rmk = 7973, + X86_VMOVUPDZ128rmkz = 7974, + X86_VMOVUPDZ128rr = 7975, + X86_VMOVUPDZ128rr_REV = 7976, + X86_VMOVUPDZ128rrk = 7977, + X86_VMOVUPDZ128rrk_REV = 7978, + X86_VMOVUPDZ128rrkz = 7979, + X86_VMOVUPDZ128rrkz_REV = 7980, + X86_VMOVUPDZ256mr = 7981, + X86_VMOVUPDZ256mrk = 7982, + X86_VMOVUPDZ256rm = 7983, + X86_VMOVUPDZ256rmk = 7984, + X86_VMOVUPDZ256rmkz = 7985, + X86_VMOVUPDZ256rr = 7986, + X86_VMOVUPDZ256rr_REV = 7987, + X86_VMOVUPDZ256rrk = 7988, + X86_VMOVUPDZ256rrk_REV = 7989, + X86_VMOVUPDZ256rrkz = 7990, + X86_VMOVUPDZ256rrkz_REV = 7991, + X86_VMOVUPDZmr = 7992, + X86_VMOVUPDZmrk = 7993, + X86_VMOVUPDZrm = 7994, + X86_VMOVUPDZrmk = 7995, + X86_VMOVUPDZrmkz = 7996, + X86_VMOVUPDZrr = 7997, + X86_VMOVUPDZrr_REV = 7998, + X86_VMOVUPDZrrk = 7999, + X86_VMOVUPDZrrk_REV = 8000, + X86_VMOVUPDZrrkz = 8001, + X86_VMOVUPDZrrkz_REV = 8002, + X86_VMOVUPDmr = 8003, + X86_VMOVUPDrm = 8004, + X86_VMOVUPDrr = 8005, + X86_VMOVUPDrr_REV = 8006, + X86_VMOVUPSYmr = 8007, + X86_VMOVUPSYrm = 8008, + X86_VMOVUPSYrr = 8009, + X86_VMOVUPSYrr_REV = 8010, + X86_VMOVUPSZ128mr = 8011, + X86_VMOVUPSZ128mrk = 8012, + X86_VMOVUPSZ128rm = 8013, + X86_VMOVUPSZ128rmk = 8014, + X86_VMOVUPSZ128rmkz = 8015, + X86_VMOVUPSZ128rr = 8016, + X86_VMOVUPSZ128rr_REV = 8017, + X86_VMOVUPSZ128rrk = 8018, + X86_VMOVUPSZ128rrk_REV = 8019, + X86_VMOVUPSZ128rrkz = 8020, + X86_VMOVUPSZ128rrkz_REV = 8021, + X86_VMOVUPSZ256mr = 8022, + X86_VMOVUPSZ256mrk = 8023, + X86_VMOVUPSZ256rm = 8024, + X86_VMOVUPSZ256rmk = 8025, + X86_VMOVUPSZ256rmkz = 8026, + X86_VMOVUPSZ256rr = 8027, + X86_VMOVUPSZ256rr_REV = 8028, + X86_VMOVUPSZ256rrk = 8029, + X86_VMOVUPSZ256rrk_REV = 8030, + X86_VMOVUPSZ256rrkz = 8031, + X86_VMOVUPSZ256rrkz_REV = 8032, + X86_VMOVUPSZmr = 8033, + X86_VMOVUPSZmrk = 8034, + X86_VMOVUPSZrm = 8035, + X86_VMOVUPSZrmk = 8036, + X86_VMOVUPSZrmkz = 8037, + X86_VMOVUPSZrr = 8038, + X86_VMOVUPSZrr_REV = 8039, + X86_VMOVUPSZrrk = 8040, + X86_VMOVUPSZrrk_REV = 8041, + X86_VMOVUPSZrrkz = 8042, + X86_VMOVUPSZrrkz_REV = 8043, + X86_VMOVUPSmr = 8044, + X86_VMOVUPSrm = 8045, + X86_VMOVUPSrr = 8046, + X86_VMOVUPSrr_REV = 8047, + X86_VMOVZPQILo2PQIZrr = 8048, + X86_VMOVZPQILo2PQIrr = 8049, + X86_VMPSADBWYrmi = 8050, + X86_VMPSADBWYrri = 8051, + X86_VMPSADBWrmi = 8052, + X86_VMPSADBWrri = 8053, + X86_VMPTRLDm = 8054, + X86_VMPTRSTm = 8055, + X86_VMREAD32mr = 8056, + X86_VMREAD32rr = 8057, + X86_VMREAD64mr = 8058, + X86_VMREAD64rr = 8059, + X86_VMRESUME = 8060, + X86_VMRUN32 = 8061, + X86_VMRUN64 = 8062, + X86_VMSAVE32 = 8063, + X86_VMSAVE64 = 8064, + X86_VMULPDYrm = 8065, + X86_VMULPDYrr = 8066, + X86_VMULPDZ128rm = 8067, + X86_VMULPDZ128rmb = 8068, + X86_VMULPDZ128rmbk = 8069, + X86_VMULPDZ128rmbkz = 8070, + X86_VMULPDZ128rmk = 8071, + X86_VMULPDZ128rmkz = 8072, + X86_VMULPDZ128rr = 8073, + X86_VMULPDZ128rrk = 8074, + X86_VMULPDZ128rrkz = 8075, + X86_VMULPDZ256rm = 8076, + X86_VMULPDZ256rmb = 8077, + X86_VMULPDZ256rmbk = 8078, + X86_VMULPDZ256rmbkz = 8079, + X86_VMULPDZ256rmk = 8080, + X86_VMULPDZ256rmkz = 8081, + X86_VMULPDZ256rr = 8082, + X86_VMULPDZ256rrk = 8083, + X86_VMULPDZ256rrkz = 8084, + X86_VMULPDZrm = 8085, + X86_VMULPDZrmb = 8086, + X86_VMULPDZrmbk = 8087, + X86_VMULPDZrmbkz = 8088, + X86_VMULPDZrmk = 8089, + X86_VMULPDZrmkz = 8090, + X86_VMULPDZrr = 8091, + X86_VMULPDZrrb = 8092, + X86_VMULPDZrrbk = 8093, + X86_VMULPDZrrbkz = 8094, + X86_VMULPDZrrk = 8095, + X86_VMULPDZrrkz = 8096, + X86_VMULPDrm = 8097, + X86_VMULPDrr = 8098, + X86_VMULPSYrm = 8099, + X86_VMULPSYrr = 8100, + X86_VMULPSZ128rm = 8101, + X86_VMULPSZ128rmb = 8102, + X86_VMULPSZ128rmbk = 8103, + X86_VMULPSZ128rmbkz = 8104, + X86_VMULPSZ128rmk = 8105, + X86_VMULPSZ128rmkz = 8106, + X86_VMULPSZ128rr = 8107, + X86_VMULPSZ128rrk = 8108, + X86_VMULPSZ128rrkz = 8109, + X86_VMULPSZ256rm = 8110, + X86_VMULPSZ256rmb = 8111, + X86_VMULPSZ256rmbk = 8112, + X86_VMULPSZ256rmbkz = 8113, + X86_VMULPSZ256rmk = 8114, + X86_VMULPSZ256rmkz = 8115, + X86_VMULPSZ256rr = 8116, + X86_VMULPSZ256rrk = 8117, + X86_VMULPSZ256rrkz = 8118, + X86_VMULPSZrm = 8119, + X86_VMULPSZrmb = 8120, + X86_VMULPSZrmbk = 8121, + X86_VMULPSZrmbkz = 8122, + X86_VMULPSZrmk = 8123, + X86_VMULPSZrmkz = 8124, + X86_VMULPSZrr = 8125, + X86_VMULPSZrrb = 8126, + X86_VMULPSZrrbk = 8127, + X86_VMULPSZrrbkz = 8128, + X86_VMULPSZrrk = 8129, + X86_VMULPSZrrkz = 8130, + X86_VMULPSrm = 8131, + X86_VMULPSrr = 8132, + X86_VMULSDZrm = 8133, + X86_VMULSDZrm_Int = 8134, + X86_VMULSDZrm_Intk = 8135, + X86_VMULSDZrm_Intkz = 8136, + X86_VMULSDZrr = 8137, + X86_VMULSDZrr_Int = 8138, + X86_VMULSDZrr_Intk = 8139, + X86_VMULSDZrr_Intkz = 8140, + X86_VMULSDZrrb_Int = 8141, + X86_VMULSDZrrb_Intk = 8142, + X86_VMULSDZrrb_Intkz = 8143, + X86_VMULSDrm = 8144, + X86_VMULSDrm_Int = 8145, + X86_VMULSDrr = 8146, + X86_VMULSDrr_Int = 8147, + X86_VMULSSZrm = 8148, + X86_VMULSSZrm_Int = 8149, + X86_VMULSSZrm_Intk = 8150, + X86_VMULSSZrm_Intkz = 8151, + X86_VMULSSZrr = 8152, + X86_VMULSSZrr_Int = 8153, + X86_VMULSSZrr_Intk = 8154, + X86_VMULSSZrr_Intkz = 8155, + X86_VMULSSZrrb_Int = 8156, + X86_VMULSSZrrb_Intk = 8157, + X86_VMULSSZrrb_Intkz = 8158, + X86_VMULSSrm = 8159, + X86_VMULSSrm_Int = 8160, + X86_VMULSSrr = 8161, + X86_VMULSSrr_Int = 8162, + X86_VMWRITE32rm = 8163, + X86_VMWRITE32rr = 8164, + X86_VMWRITE64rm = 8165, + X86_VMWRITE64rr = 8166, + X86_VMXOFF = 8167, + X86_VMXON = 8168, + X86_VORPDYrm = 8169, + X86_VORPDYrr = 8170, + X86_VORPDZ128rm = 8171, + X86_VORPDZ128rmb = 8172, + X86_VORPDZ128rmbk = 8173, + X86_VORPDZ128rmbkz = 8174, + X86_VORPDZ128rmk = 8175, + X86_VORPDZ128rmkz = 8176, + X86_VORPDZ128rr = 8177, + X86_VORPDZ128rrk = 8178, + X86_VORPDZ128rrkz = 8179, + X86_VORPDZ256rm = 8180, + X86_VORPDZ256rmb = 8181, + X86_VORPDZ256rmbk = 8182, + X86_VORPDZ256rmbkz = 8183, + X86_VORPDZ256rmk = 8184, + X86_VORPDZ256rmkz = 8185, + X86_VORPDZ256rr = 8186, + X86_VORPDZ256rrk = 8187, + X86_VORPDZ256rrkz = 8188, + X86_VORPDZrm = 8189, + X86_VORPDZrmb = 8190, + X86_VORPDZrmbk = 8191, + X86_VORPDZrmbkz = 8192, + X86_VORPDZrmk = 8193, + X86_VORPDZrmkz = 8194, + X86_VORPDZrr = 8195, + X86_VORPDZrrk = 8196, + X86_VORPDZrrkz = 8197, + X86_VORPDrm = 8198, + X86_VORPDrr = 8199, + X86_VORPSYrm = 8200, + X86_VORPSYrr = 8201, + X86_VORPSZ128rm = 8202, + X86_VORPSZ128rmb = 8203, + X86_VORPSZ128rmbk = 8204, + X86_VORPSZ128rmbkz = 8205, + X86_VORPSZ128rmk = 8206, + X86_VORPSZ128rmkz = 8207, + X86_VORPSZ128rr = 8208, + X86_VORPSZ128rrk = 8209, + X86_VORPSZ128rrkz = 8210, + X86_VORPSZ256rm = 8211, + X86_VORPSZ256rmb = 8212, + X86_VORPSZ256rmbk = 8213, + X86_VORPSZ256rmbkz = 8214, + X86_VORPSZ256rmk = 8215, + X86_VORPSZ256rmkz = 8216, + X86_VORPSZ256rr = 8217, + X86_VORPSZ256rrk = 8218, + X86_VORPSZ256rrkz = 8219, + X86_VORPSZrm = 8220, + X86_VORPSZrmb = 8221, + X86_VORPSZrmbk = 8222, + X86_VORPSZrmbkz = 8223, + X86_VORPSZrmk = 8224, + X86_VORPSZrmkz = 8225, + X86_VORPSZrr = 8226, + X86_VORPSZrrk = 8227, + X86_VORPSZrrkz = 8228, + X86_VORPSrm = 8229, + X86_VORPSrr = 8230, + X86_VP4DPWSSDSrm = 8231, + X86_VP4DPWSSDSrmk = 8232, + X86_VP4DPWSSDSrmkz = 8233, + X86_VP4DPWSSDrm = 8234, + X86_VP4DPWSSDrmk = 8235, + X86_VP4DPWSSDrmkz = 8236, + X86_VPABSBYrm = 8237, + X86_VPABSBYrr = 8238, + X86_VPABSBZ128rm = 8239, + X86_VPABSBZ128rmk = 8240, + X86_VPABSBZ128rmkz = 8241, + X86_VPABSBZ128rr = 8242, + X86_VPABSBZ128rrk = 8243, + X86_VPABSBZ128rrkz = 8244, + X86_VPABSBZ256rm = 8245, + X86_VPABSBZ256rmk = 8246, + X86_VPABSBZ256rmkz = 8247, + X86_VPABSBZ256rr = 8248, + X86_VPABSBZ256rrk = 8249, + X86_VPABSBZ256rrkz = 8250, + X86_VPABSBZrm = 8251, + X86_VPABSBZrmk = 8252, + X86_VPABSBZrmkz = 8253, + X86_VPABSBZrr = 8254, + X86_VPABSBZrrk = 8255, + X86_VPABSBZrrkz = 8256, + X86_VPABSBrm = 8257, + X86_VPABSBrr = 8258, + X86_VPABSDYrm = 8259, + X86_VPABSDYrr = 8260, + X86_VPABSDZ128rm = 8261, + X86_VPABSDZ128rmb = 8262, + X86_VPABSDZ128rmbk = 8263, + X86_VPABSDZ128rmbkz = 8264, + X86_VPABSDZ128rmk = 8265, + X86_VPABSDZ128rmkz = 8266, + X86_VPABSDZ128rr = 8267, + X86_VPABSDZ128rrk = 8268, + X86_VPABSDZ128rrkz = 8269, + X86_VPABSDZ256rm = 8270, + X86_VPABSDZ256rmb = 8271, + X86_VPABSDZ256rmbk = 8272, + X86_VPABSDZ256rmbkz = 8273, + X86_VPABSDZ256rmk = 8274, + X86_VPABSDZ256rmkz = 8275, + X86_VPABSDZ256rr = 8276, + X86_VPABSDZ256rrk = 8277, + X86_VPABSDZ256rrkz = 8278, + X86_VPABSDZrm = 8279, + X86_VPABSDZrmb = 8280, + X86_VPABSDZrmbk = 8281, + X86_VPABSDZrmbkz = 8282, + X86_VPABSDZrmk = 8283, + X86_VPABSDZrmkz = 8284, + X86_VPABSDZrr = 8285, + X86_VPABSDZrrk = 8286, + X86_VPABSDZrrkz = 8287, + X86_VPABSDrm = 8288, + X86_VPABSDrr = 8289, + X86_VPABSQZ128rm = 8290, + X86_VPABSQZ128rmb = 8291, + X86_VPABSQZ128rmbk = 8292, + X86_VPABSQZ128rmbkz = 8293, + X86_VPABSQZ128rmk = 8294, + X86_VPABSQZ128rmkz = 8295, + X86_VPABSQZ128rr = 8296, + X86_VPABSQZ128rrk = 8297, + X86_VPABSQZ128rrkz = 8298, + X86_VPABSQZ256rm = 8299, + X86_VPABSQZ256rmb = 8300, + X86_VPABSQZ256rmbk = 8301, + X86_VPABSQZ256rmbkz = 8302, + X86_VPABSQZ256rmk = 8303, + X86_VPABSQZ256rmkz = 8304, + X86_VPABSQZ256rr = 8305, + X86_VPABSQZ256rrk = 8306, + X86_VPABSQZ256rrkz = 8307, + X86_VPABSQZrm = 8308, + X86_VPABSQZrmb = 8309, + X86_VPABSQZrmbk = 8310, + X86_VPABSQZrmbkz = 8311, + X86_VPABSQZrmk = 8312, + X86_VPABSQZrmkz = 8313, + X86_VPABSQZrr = 8314, + X86_VPABSQZrrk = 8315, + X86_VPABSQZrrkz = 8316, + X86_VPABSWYrm = 8317, + X86_VPABSWYrr = 8318, + X86_VPABSWZ128rm = 8319, + X86_VPABSWZ128rmk = 8320, + X86_VPABSWZ128rmkz = 8321, + X86_VPABSWZ128rr = 8322, + X86_VPABSWZ128rrk = 8323, + X86_VPABSWZ128rrkz = 8324, + X86_VPABSWZ256rm = 8325, + X86_VPABSWZ256rmk = 8326, + X86_VPABSWZ256rmkz = 8327, + X86_VPABSWZ256rr = 8328, + X86_VPABSWZ256rrk = 8329, + X86_VPABSWZ256rrkz = 8330, + X86_VPABSWZrm = 8331, + X86_VPABSWZrmk = 8332, + X86_VPABSWZrmkz = 8333, + X86_VPABSWZrr = 8334, + X86_VPABSWZrrk = 8335, + X86_VPABSWZrrkz = 8336, + X86_VPABSWrm = 8337, + X86_VPABSWrr = 8338, + X86_VPACKSSDWYrm = 8339, + X86_VPACKSSDWYrr = 8340, + X86_VPACKSSDWZ128rm = 8341, + X86_VPACKSSDWZ128rmb = 8342, + X86_VPACKSSDWZ128rmbk = 8343, + X86_VPACKSSDWZ128rmbkz = 8344, + X86_VPACKSSDWZ128rmk = 8345, + X86_VPACKSSDWZ128rmkz = 8346, + X86_VPACKSSDWZ128rr = 8347, + X86_VPACKSSDWZ128rrk = 8348, + X86_VPACKSSDWZ128rrkz = 8349, + X86_VPACKSSDWZ256rm = 8350, + X86_VPACKSSDWZ256rmb = 8351, + X86_VPACKSSDWZ256rmbk = 8352, + X86_VPACKSSDWZ256rmbkz = 8353, + X86_VPACKSSDWZ256rmk = 8354, + X86_VPACKSSDWZ256rmkz = 8355, + X86_VPACKSSDWZ256rr = 8356, + X86_VPACKSSDWZ256rrk = 8357, + X86_VPACKSSDWZ256rrkz = 8358, + X86_VPACKSSDWZrm = 8359, + X86_VPACKSSDWZrmb = 8360, + X86_VPACKSSDWZrmbk = 8361, + X86_VPACKSSDWZrmbkz = 8362, + X86_VPACKSSDWZrmk = 8363, + X86_VPACKSSDWZrmkz = 8364, + X86_VPACKSSDWZrr = 8365, + X86_VPACKSSDWZrrk = 8366, + X86_VPACKSSDWZrrkz = 8367, + X86_VPACKSSDWrm = 8368, + X86_VPACKSSDWrr = 8369, + X86_VPACKSSWBYrm = 8370, + X86_VPACKSSWBYrr = 8371, + X86_VPACKSSWBZ128rm = 8372, + X86_VPACKSSWBZ128rmk = 8373, + X86_VPACKSSWBZ128rmkz = 8374, + X86_VPACKSSWBZ128rr = 8375, + X86_VPACKSSWBZ128rrk = 8376, + X86_VPACKSSWBZ128rrkz = 8377, + X86_VPACKSSWBZ256rm = 8378, + X86_VPACKSSWBZ256rmk = 8379, + X86_VPACKSSWBZ256rmkz = 8380, + X86_VPACKSSWBZ256rr = 8381, + X86_VPACKSSWBZ256rrk = 8382, + X86_VPACKSSWBZ256rrkz = 8383, + X86_VPACKSSWBZrm = 8384, + X86_VPACKSSWBZrmk = 8385, + X86_VPACKSSWBZrmkz = 8386, + X86_VPACKSSWBZrr = 8387, + X86_VPACKSSWBZrrk = 8388, + X86_VPACKSSWBZrrkz = 8389, + X86_VPACKSSWBrm = 8390, + X86_VPACKSSWBrr = 8391, + X86_VPACKUSDWYrm = 8392, + X86_VPACKUSDWYrr = 8393, + X86_VPACKUSDWZ128rm = 8394, + X86_VPACKUSDWZ128rmb = 8395, + X86_VPACKUSDWZ128rmbk = 8396, + X86_VPACKUSDWZ128rmbkz = 8397, + X86_VPACKUSDWZ128rmk = 8398, + X86_VPACKUSDWZ128rmkz = 8399, + X86_VPACKUSDWZ128rr = 8400, + X86_VPACKUSDWZ128rrk = 8401, + X86_VPACKUSDWZ128rrkz = 8402, + X86_VPACKUSDWZ256rm = 8403, + X86_VPACKUSDWZ256rmb = 8404, + X86_VPACKUSDWZ256rmbk = 8405, + X86_VPACKUSDWZ256rmbkz = 8406, + X86_VPACKUSDWZ256rmk = 8407, + X86_VPACKUSDWZ256rmkz = 8408, + X86_VPACKUSDWZ256rr = 8409, + X86_VPACKUSDWZ256rrk = 8410, + X86_VPACKUSDWZ256rrkz = 8411, + X86_VPACKUSDWZrm = 8412, + X86_VPACKUSDWZrmb = 8413, + X86_VPACKUSDWZrmbk = 8414, + X86_VPACKUSDWZrmbkz = 8415, + X86_VPACKUSDWZrmk = 8416, + X86_VPACKUSDWZrmkz = 8417, + X86_VPACKUSDWZrr = 8418, + X86_VPACKUSDWZrrk = 8419, + X86_VPACKUSDWZrrkz = 8420, + X86_VPACKUSDWrm = 8421, + X86_VPACKUSDWrr = 8422, + X86_VPACKUSWBYrm = 8423, + X86_VPACKUSWBYrr = 8424, + X86_VPACKUSWBZ128rm = 8425, + X86_VPACKUSWBZ128rmk = 8426, + X86_VPACKUSWBZ128rmkz = 8427, + X86_VPACKUSWBZ128rr = 8428, + X86_VPACKUSWBZ128rrk = 8429, + X86_VPACKUSWBZ128rrkz = 8430, + X86_VPACKUSWBZ256rm = 8431, + X86_VPACKUSWBZ256rmk = 8432, + X86_VPACKUSWBZ256rmkz = 8433, + X86_VPACKUSWBZ256rr = 8434, + X86_VPACKUSWBZ256rrk = 8435, + X86_VPACKUSWBZ256rrkz = 8436, + X86_VPACKUSWBZrm = 8437, + X86_VPACKUSWBZrmk = 8438, + X86_VPACKUSWBZrmkz = 8439, + X86_VPACKUSWBZrr = 8440, + X86_VPACKUSWBZrrk = 8441, + X86_VPACKUSWBZrrkz = 8442, + X86_VPACKUSWBrm = 8443, + X86_VPACKUSWBrr = 8444, + X86_VPADDBYrm = 8445, + X86_VPADDBYrr = 8446, + X86_VPADDBZ128rm = 8447, + X86_VPADDBZ128rmk = 8448, + X86_VPADDBZ128rmkz = 8449, + X86_VPADDBZ128rr = 8450, + X86_VPADDBZ128rrk = 8451, + X86_VPADDBZ128rrkz = 8452, + X86_VPADDBZ256rm = 8453, + X86_VPADDBZ256rmk = 8454, + X86_VPADDBZ256rmkz = 8455, + X86_VPADDBZ256rr = 8456, + X86_VPADDBZ256rrk = 8457, + X86_VPADDBZ256rrkz = 8458, + X86_VPADDBZrm = 8459, + X86_VPADDBZrmk = 8460, + X86_VPADDBZrmkz = 8461, + X86_VPADDBZrr = 8462, + X86_VPADDBZrrk = 8463, + X86_VPADDBZrrkz = 8464, + X86_VPADDBrm = 8465, + X86_VPADDBrr = 8466, + X86_VPADDDYrm = 8467, + X86_VPADDDYrr = 8468, + X86_VPADDDZ128rm = 8469, + X86_VPADDDZ128rmb = 8470, + X86_VPADDDZ128rmbk = 8471, + X86_VPADDDZ128rmbkz = 8472, + X86_VPADDDZ128rmk = 8473, + X86_VPADDDZ128rmkz = 8474, + X86_VPADDDZ128rr = 8475, + X86_VPADDDZ128rrk = 8476, + X86_VPADDDZ128rrkz = 8477, + X86_VPADDDZ256rm = 8478, + X86_VPADDDZ256rmb = 8479, + X86_VPADDDZ256rmbk = 8480, + X86_VPADDDZ256rmbkz = 8481, + X86_VPADDDZ256rmk = 8482, + X86_VPADDDZ256rmkz = 8483, + X86_VPADDDZ256rr = 8484, + X86_VPADDDZ256rrk = 8485, + X86_VPADDDZ256rrkz = 8486, + X86_VPADDDZrm = 8487, + X86_VPADDDZrmb = 8488, + X86_VPADDDZrmbk = 8489, + X86_VPADDDZrmbkz = 8490, + X86_VPADDDZrmk = 8491, + X86_VPADDDZrmkz = 8492, + X86_VPADDDZrr = 8493, + X86_VPADDDZrrk = 8494, + X86_VPADDDZrrkz = 8495, + X86_VPADDDrm = 8496, + X86_VPADDDrr = 8497, + X86_VPADDQYrm = 8498, + X86_VPADDQYrr = 8499, + X86_VPADDQZ128rm = 8500, + X86_VPADDQZ128rmb = 8501, + X86_VPADDQZ128rmbk = 8502, + X86_VPADDQZ128rmbkz = 8503, + X86_VPADDQZ128rmk = 8504, + X86_VPADDQZ128rmkz = 8505, + X86_VPADDQZ128rr = 8506, + X86_VPADDQZ128rrk = 8507, + X86_VPADDQZ128rrkz = 8508, + X86_VPADDQZ256rm = 8509, + X86_VPADDQZ256rmb = 8510, + X86_VPADDQZ256rmbk = 8511, + X86_VPADDQZ256rmbkz = 8512, + X86_VPADDQZ256rmk = 8513, + X86_VPADDQZ256rmkz = 8514, + X86_VPADDQZ256rr = 8515, + X86_VPADDQZ256rrk = 8516, + X86_VPADDQZ256rrkz = 8517, + X86_VPADDQZrm = 8518, + X86_VPADDQZrmb = 8519, + X86_VPADDQZrmbk = 8520, + X86_VPADDQZrmbkz = 8521, + X86_VPADDQZrmk = 8522, + X86_VPADDQZrmkz = 8523, + X86_VPADDQZrr = 8524, + X86_VPADDQZrrk = 8525, + X86_VPADDQZrrkz = 8526, + X86_VPADDQrm = 8527, + X86_VPADDQrr = 8528, + X86_VPADDSBYrm = 8529, + X86_VPADDSBYrr = 8530, + X86_VPADDSBZ128rm = 8531, + X86_VPADDSBZ128rmk = 8532, + X86_VPADDSBZ128rmkz = 8533, + X86_VPADDSBZ128rr = 8534, + X86_VPADDSBZ128rrk = 8535, + X86_VPADDSBZ128rrkz = 8536, + X86_VPADDSBZ256rm = 8537, + X86_VPADDSBZ256rmk = 8538, + X86_VPADDSBZ256rmkz = 8539, + X86_VPADDSBZ256rr = 8540, + X86_VPADDSBZ256rrk = 8541, + X86_VPADDSBZ256rrkz = 8542, + X86_VPADDSBZrm = 8543, + X86_VPADDSBZrmk = 8544, + X86_VPADDSBZrmkz = 8545, + X86_VPADDSBZrr = 8546, + X86_VPADDSBZrrk = 8547, + X86_VPADDSBZrrkz = 8548, + X86_VPADDSBrm = 8549, + X86_VPADDSBrr = 8550, + X86_VPADDSWYrm = 8551, + X86_VPADDSWYrr = 8552, + X86_VPADDSWZ128rm = 8553, + X86_VPADDSWZ128rmk = 8554, + X86_VPADDSWZ128rmkz = 8555, + X86_VPADDSWZ128rr = 8556, + X86_VPADDSWZ128rrk = 8557, + X86_VPADDSWZ128rrkz = 8558, + X86_VPADDSWZ256rm = 8559, + X86_VPADDSWZ256rmk = 8560, + X86_VPADDSWZ256rmkz = 8561, + X86_VPADDSWZ256rr = 8562, + X86_VPADDSWZ256rrk = 8563, + X86_VPADDSWZ256rrkz = 8564, + X86_VPADDSWZrm = 8565, + X86_VPADDSWZrmk = 8566, + X86_VPADDSWZrmkz = 8567, + X86_VPADDSWZrr = 8568, + X86_VPADDSWZrrk = 8569, + X86_VPADDSWZrrkz = 8570, + X86_VPADDSWrm = 8571, + X86_VPADDSWrr = 8572, + X86_VPADDUSBYrm = 8573, + X86_VPADDUSBYrr = 8574, + X86_VPADDUSBZ128rm = 8575, + X86_VPADDUSBZ128rmk = 8576, + X86_VPADDUSBZ128rmkz = 8577, + X86_VPADDUSBZ128rr = 8578, + X86_VPADDUSBZ128rrk = 8579, + X86_VPADDUSBZ128rrkz = 8580, + X86_VPADDUSBZ256rm = 8581, + X86_VPADDUSBZ256rmk = 8582, + X86_VPADDUSBZ256rmkz = 8583, + X86_VPADDUSBZ256rr = 8584, + X86_VPADDUSBZ256rrk = 8585, + X86_VPADDUSBZ256rrkz = 8586, + X86_VPADDUSBZrm = 8587, + X86_VPADDUSBZrmk = 8588, + X86_VPADDUSBZrmkz = 8589, + X86_VPADDUSBZrr = 8590, + X86_VPADDUSBZrrk = 8591, + X86_VPADDUSBZrrkz = 8592, + X86_VPADDUSBrm = 8593, + X86_VPADDUSBrr = 8594, + X86_VPADDUSWYrm = 8595, + X86_VPADDUSWYrr = 8596, + X86_VPADDUSWZ128rm = 8597, + X86_VPADDUSWZ128rmk = 8598, + X86_VPADDUSWZ128rmkz = 8599, + X86_VPADDUSWZ128rr = 8600, + X86_VPADDUSWZ128rrk = 8601, + X86_VPADDUSWZ128rrkz = 8602, + X86_VPADDUSWZ256rm = 8603, + X86_VPADDUSWZ256rmk = 8604, + X86_VPADDUSWZ256rmkz = 8605, + X86_VPADDUSWZ256rr = 8606, + X86_VPADDUSWZ256rrk = 8607, + X86_VPADDUSWZ256rrkz = 8608, + X86_VPADDUSWZrm = 8609, + X86_VPADDUSWZrmk = 8610, + X86_VPADDUSWZrmkz = 8611, + X86_VPADDUSWZrr = 8612, + X86_VPADDUSWZrrk = 8613, + X86_VPADDUSWZrrkz = 8614, + X86_VPADDUSWrm = 8615, + X86_VPADDUSWrr = 8616, + X86_VPADDWYrm = 8617, + X86_VPADDWYrr = 8618, + X86_VPADDWZ128rm = 8619, + X86_VPADDWZ128rmk = 8620, + X86_VPADDWZ128rmkz = 8621, + X86_VPADDWZ128rr = 8622, + X86_VPADDWZ128rrk = 8623, + X86_VPADDWZ128rrkz = 8624, + X86_VPADDWZ256rm = 8625, + X86_VPADDWZ256rmk = 8626, + X86_VPADDWZ256rmkz = 8627, + X86_VPADDWZ256rr = 8628, + X86_VPADDWZ256rrk = 8629, + X86_VPADDWZ256rrkz = 8630, + X86_VPADDWZrm = 8631, + X86_VPADDWZrmk = 8632, + X86_VPADDWZrmkz = 8633, + X86_VPADDWZrr = 8634, + X86_VPADDWZrrk = 8635, + X86_VPADDWZrrkz = 8636, + X86_VPADDWrm = 8637, + X86_VPADDWrr = 8638, + X86_VPALIGNRYrmi = 8639, + X86_VPALIGNRYrri = 8640, + X86_VPALIGNRZ128rmi = 8641, + X86_VPALIGNRZ128rmik = 8642, + X86_VPALIGNRZ128rmikz = 8643, + X86_VPALIGNRZ128rri = 8644, + X86_VPALIGNRZ128rrik = 8645, + X86_VPALIGNRZ128rrikz = 8646, + X86_VPALIGNRZ256rmi = 8647, + X86_VPALIGNRZ256rmik = 8648, + X86_VPALIGNRZ256rmikz = 8649, + X86_VPALIGNRZ256rri = 8650, + X86_VPALIGNRZ256rrik = 8651, + X86_VPALIGNRZ256rrikz = 8652, + X86_VPALIGNRZrmi = 8653, + X86_VPALIGNRZrmik = 8654, + X86_VPALIGNRZrmikz = 8655, + X86_VPALIGNRZrri = 8656, + X86_VPALIGNRZrrik = 8657, + X86_VPALIGNRZrrikz = 8658, + X86_VPALIGNRrmi = 8659, + X86_VPALIGNRrri = 8660, + X86_VPANDDZ128rm = 8661, + X86_VPANDDZ128rmb = 8662, + X86_VPANDDZ128rmbk = 8663, + X86_VPANDDZ128rmbkz = 8664, + X86_VPANDDZ128rmk = 8665, + X86_VPANDDZ128rmkz = 8666, + X86_VPANDDZ128rr = 8667, + X86_VPANDDZ128rrk = 8668, + X86_VPANDDZ128rrkz = 8669, + X86_VPANDDZ256rm = 8670, + X86_VPANDDZ256rmb = 8671, + X86_VPANDDZ256rmbk = 8672, + X86_VPANDDZ256rmbkz = 8673, + X86_VPANDDZ256rmk = 8674, + X86_VPANDDZ256rmkz = 8675, + X86_VPANDDZ256rr = 8676, + X86_VPANDDZ256rrk = 8677, + X86_VPANDDZ256rrkz = 8678, + X86_VPANDDZrm = 8679, + X86_VPANDDZrmb = 8680, + X86_VPANDDZrmbk = 8681, + X86_VPANDDZrmbkz = 8682, + X86_VPANDDZrmk = 8683, + X86_VPANDDZrmkz = 8684, + X86_VPANDDZrr = 8685, + X86_VPANDDZrrk = 8686, + X86_VPANDDZrrkz = 8687, + X86_VPANDNDZ128rm = 8688, + X86_VPANDNDZ128rmb = 8689, + X86_VPANDNDZ128rmbk = 8690, + X86_VPANDNDZ128rmbkz = 8691, + X86_VPANDNDZ128rmk = 8692, + X86_VPANDNDZ128rmkz = 8693, + X86_VPANDNDZ128rr = 8694, + X86_VPANDNDZ128rrk = 8695, + X86_VPANDNDZ128rrkz = 8696, + X86_VPANDNDZ256rm = 8697, + X86_VPANDNDZ256rmb = 8698, + X86_VPANDNDZ256rmbk = 8699, + X86_VPANDNDZ256rmbkz = 8700, + X86_VPANDNDZ256rmk = 8701, + X86_VPANDNDZ256rmkz = 8702, + X86_VPANDNDZ256rr = 8703, + X86_VPANDNDZ256rrk = 8704, + X86_VPANDNDZ256rrkz = 8705, + X86_VPANDNDZrm = 8706, + X86_VPANDNDZrmb = 8707, + X86_VPANDNDZrmbk = 8708, + X86_VPANDNDZrmbkz = 8709, + X86_VPANDNDZrmk = 8710, + X86_VPANDNDZrmkz = 8711, + X86_VPANDNDZrr = 8712, + X86_VPANDNDZrrk = 8713, + X86_VPANDNDZrrkz = 8714, + X86_VPANDNQZ128rm = 8715, + X86_VPANDNQZ128rmb = 8716, + X86_VPANDNQZ128rmbk = 8717, + X86_VPANDNQZ128rmbkz = 8718, + X86_VPANDNQZ128rmk = 8719, + X86_VPANDNQZ128rmkz = 8720, + X86_VPANDNQZ128rr = 8721, + X86_VPANDNQZ128rrk = 8722, + X86_VPANDNQZ128rrkz = 8723, + X86_VPANDNQZ256rm = 8724, + X86_VPANDNQZ256rmb = 8725, + X86_VPANDNQZ256rmbk = 8726, + X86_VPANDNQZ256rmbkz = 8727, + X86_VPANDNQZ256rmk = 8728, + X86_VPANDNQZ256rmkz = 8729, + X86_VPANDNQZ256rr = 8730, + X86_VPANDNQZ256rrk = 8731, + X86_VPANDNQZ256rrkz = 8732, + X86_VPANDNQZrm = 8733, + X86_VPANDNQZrmb = 8734, + X86_VPANDNQZrmbk = 8735, + X86_VPANDNQZrmbkz = 8736, + X86_VPANDNQZrmk = 8737, + X86_VPANDNQZrmkz = 8738, + X86_VPANDNQZrr = 8739, + X86_VPANDNQZrrk = 8740, + X86_VPANDNQZrrkz = 8741, + X86_VPANDNYrm = 8742, + X86_VPANDNYrr = 8743, + X86_VPANDNrm = 8744, + X86_VPANDNrr = 8745, + X86_VPANDQZ128rm = 8746, + X86_VPANDQZ128rmb = 8747, + X86_VPANDQZ128rmbk = 8748, + X86_VPANDQZ128rmbkz = 8749, + X86_VPANDQZ128rmk = 8750, + X86_VPANDQZ128rmkz = 8751, + X86_VPANDQZ128rr = 8752, + X86_VPANDQZ128rrk = 8753, + X86_VPANDQZ128rrkz = 8754, + X86_VPANDQZ256rm = 8755, + X86_VPANDQZ256rmb = 8756, + X86_VPANDQZ256rmbk = 8757, + X86_VPANDQZ256rmbkz = 8758, + X86_VPANDQZ256rmk = 8759, + X86_VPANDQZ256rmkz = 8760, + X86_VPANDQZ256rr = 8761, + X86_VPANDQZ256rrk = 8762, + X86_VPANDQZ256rrkz = 8763, + X86_VPANDQZrm = 8764, + X86_VPANDQZrmb = 8765, + X86_VPANDQZrmbk = 8766, + X86_VPANDQZrmbkz = 8767, + X86_VPANDQZrmk = 8768, + X86_VPANDQZrmkz = 8769, + X86_VPANDQZrr = 8770, + X86_VPANDQZrrk = 8771, + X86_VPANDQZrrkz = 8772, + X86_VPANDYrm = 8773, + X86_VPANDYrr = 8774, + X86_VPANDrm = 8775, + X86_VPANDrr = 8776, + X86_VPAVGBYrm = 8777, + X86_VPAVGBYrr = 8778, + X86_VPAVGBZ128rm = 8779, + X86_VPAVGBZ128rmk = 8780, + X86_VPAVGBZ128rmkz = 8781, + X86_VPAVGBZ128rr = 8782, + X86_VPAVGBZ128rrk = 8783, + X86_VPAVGBZ128rrkz = 8784, + X86_VPAVGBZ256rm = 8785, + X86_VPAVGBZ256rmk = 8786, + X86_VPAVGBZ256rmkz = 8787, + X86_VPAVGBZ256rr = 8788, + X86_VPAVGBZ256rrk = 8789, + X86_VPAVGBZ256rrkz = 8790, + X86_VPAVGBZrm = 8791, + X86_VPAVGBZrmk = 8792, + X86_VPAVGBZrmkz = 8793, + X86_VPAVGBZrr = 8794, + X86_VPAVGBZrrk = 8795, + X86_VPAVGBZrrkz = 8796, + X86_VPAVGBrm = 8797, + X86_VPAVGBrr = 8798, + X86_VPAVGWYrm = 8799, + X86_VPAVGWYrr = 8800, + X86_VPAVGWZ128rm = 8801, + X86_VPAVGWZ128rmk = 8802, + X86_VPAVGWZ128rmkz = 8803, + X86_VPAVGWZ128rr = 8804, + X86_VPAVGWZ128rrk = 8805, + X86_VPAVGWZ128rrkz = 8806, + X86_VPAVGWZ256rm = 8807, + X86_VPAVGWZ256rmk = 8808, + X86_VPAVGWZ256rmkz = 8809, + X86_VPAVGWZ256rr = 8810, + X86_VPAVGWZ256rrk = 8811, + X86_VPAVGWZ256rrkz = 8812, + X86_VPAVGWZrm = 8813, + X86_VPAVGWZrmk = 8814, + X86_VPAVGWZrmkz = 8815, + X86_VPAVGWZrr = 8816, + X86_VPAVGWZrrk = 8817, + X86_VPAVGWZrrkz = 8818, + X86_VPAVGWrm = 8819, + X86_VPAVGWrr = 8820, + X86_VPBLENDDYrmi = 8821, + X86_VPBLENDDYrri = 8822, + X86_VPBLENDDrmi = 8823, + X86_VPBLENDDrri = 8824, + X86_VPBLENDMBZ128rm = 8825, + X86_VPBLENDMBZ128rmk = 8826, + X86_VPBLENDMBZ128rmkz = 8827, + X86_VPBLENDMBZ128rr = 8828, + X86_VPBLENDMBZ128rrk = 8829, + X86_VPBLENDMBZ128rrkz = 8830, + X86_VPBLENDMBZ256rm = 8831, + X86_VPBLENDMBZ256rmk = 8832, + X86_VPBLENDMBZ256rmkz = 8833, + X86_VPBLENDMBZ256rr = 8834, + X86_VPBLENDMBZ256rrk = 8835, + X86_VPBLENDMBZ256rrkz = 8836, + X86_VPBLENDMBZrm = 8837, + X86_VPBLENDMBZrmk = 8838, + X86_VPBLENDMBZrmkz = 8839, + X86_VPBLENDMBZrr = 8840, + X86_VPBLENDMBZrrk = 8841, + X86_VPBLENDMBZrrkz = 8842, + X86_VPBLENDMDZ128rm = 8843, + X86_VPBLENDMDZ128rmb = 8844, + X86_VPBLENDMDZ128rmbk = 8845, + X86_VPBLENDMDZ128rmbkz = 8846, + X86_VPBLENDMDZ128rmk = 8847, + X86_VPBLENDMDZ128rmkz = 8848, + X86_VPBLENDMDZ128rr = 8849, + X86_VPBLENDMDZ128rrk = 8850, + X86_VPBLENDMDZ128rrkz = 8851, + X86_VPBLENDMDZ256rm = 8852, + X86_VPBLENDMDZ256rmb = 8853, + X86_VPBLENDMDZ256rmbk = 8854, + X86_VPBLENDMDZ256rmbkz = 8855, + X86_VPBLENDMDZ256rmk = 8856, + X86_VPBLENDMDZ256rmkz = 8857, + X86_VPBLENDMDZ256rr = 8858, + X86_VPBLENDMDZ256rrk = 8859, + X86_VPBLENDMDZ256rrkz = 8860, + X86_VPBLENDMDZrm = 8861, + X86_VPBLENDMDZrmb = 8862, + X86_VPBLENDMDZrmbk = 8863, + X86_VPBLENDMDZrmbkz = 8864, + X86_VPBLENDMDZrmk = 8865, + X86_VPBLENDMDZrmkz = 8866, + X86_VPBLENDMDZrr = 8867, + X86_VPBLENDMDZrrk = 8868, + X86_VPBLENDMDZrrkz = 8869, + X86_VPBLENDMQZ128rm = 8870, + X86_VPBLENDMQZ128rmb = 8871, + X86_VPBLENDMQZ128rmbk = 8872, + X86_VPBLENDMQZ128rmbkz = 8873, + X86_VPBLENDMQZ128rmk = 8874, + X86_VPBLENDMQZ128rmkz = 8875, + X86_VPBLENDMQZ128rr = 8876, + X86_VPBLENDMQZ128rrk = 8877, + X86_VPBLENDMQZ128rrkz = 8878, + X86_VPBLENDMQZ256rm = 8879, + X86_VPBLENDMQZ256rmb = 8880, + X86_VPBLENDMQZ256rmbk = 8881, + X86_VPBLENDMQZ256rmbkz = 8882, + X86_VPBLENDMQZ256rmk = 8883, + X86_VPBLENDMQZ256rmkz = 8884, + X86_VPBLENDMQZ256rr = 8885, + X86_VPBLENDMQZ256rrk = 8886, + X86_VPBLENDMQZ256rrkz = 8887, + X86_VPBLENDMQZrm = 8888, + X86_VPBLENDMQZrmb = 8889, + X86_VPBLENDMQZrmbk = 8890, + X86_VPBLENDMQZrmbkz = 8891, + X86_VPBLENDMQZrmk = 8892, + X86_VPBLENDMQZrmkz = 8893, + X86_VPBLENDMQZrr = 8894, + X86_VPBLENDMQZrrk = 8895, + X86_VPBLENDMQZrrkz = 8896, + X86_VPBLENDMWZ128rm = 8897, + X86_VPBLENDMWZ128rmk = 8898, + X86_VPBLENDMWZ128rmkz = 8899, + X86_VPBLENDMWZ128rr = 8900, + X86_VPBLENDMWZ128rrk = 8901, + X86_VPBLENDMWZ128rrkz = 8902, + X86_VPBLENDMWZ256rm = 8903, + X86_VPBLENDMWZ256rmk = 8904, + X86_VPBLENDMWZ256rmkz = 8905, + X86_VPBLENDMWZ256rr = 8906, + X86_VPBLENDMWZ256rrk = 8907, + X86_VPBLENDMWZ256rrkz = 8908, + X86_VPBLENDMWZrm = 8909, + X86_VPBLENDMWZrmk = 8910, + X86_VPBLENDMWZrmkz = 8911, + X86_VPBLENDMWZrr = 8912, + X86_VPBLENDMWZrrk = 8913, + X86_VPBLENDMWZrrkz = 8914, + X86_VPBLENDVBYrm = 8915, + X86_VPBLENDVBYrr = 8916, + X86_VPBLENDVBrm = 8917, + X86_VPBLENDVBrr = 8918, + X86_VPBLENDWYrmi = 8919, + X86_VPBLENDWYrri = 8920, + X86_VPBLENDWrmi = 8921, + X86_VPBLENDWrri = 8922, + X86_VPBROADCASTBYrm = 8923, + X86_VPBROADCASTBYrr = 8924, + X86_VPBROADCASTBZ128m = 8925, + X86_VPBROADCASTBZ128mk = 8926, + X86_VPBROADCASTBZ128mkz = 8927, + X86_VPBROADCASTBZ128r = 8928, + X86_VPBROADCASTBZ128rk = 8929, + X86_VPBROADCASTBZ128rkz = 8930, + X86_VPBROADCASTBZ256m = 8931, + X86_VPBROADCASTBZ256mk = 8932, + X86_VPBROADCASTBZ256mkz = 8933, + X86_VPBROADCASTBZ256r = 8934, + X86_VPBROADCASTBZ256rk = 8935, + X86_VPBROADCASTBZ256rkz = 8936, + X86_VPBROADCASTBZm = 8937, + X86_VPBROADCASTBZmk = 8938, + X86_VPBROADCASTBZmkz = 8939, + X86_VPBROADCASTBZr = 8940, + X86_VPBROADCASTBZrk = 8941, + X86_VPBROADCASTBZrkz = 8942, + X86_VPBROADCASTBrZ128r = 8943, + X86_VPBROADCASTBrZ128rk = 8944, + X86_VPBROADCASTBrZ128rkz = 8945, + X86_VPBROADCASTBrZ256r = 8946, + X86_VPBROADCASTBrZ256rk = 8947, + X86_VPBROADCASTBrZ256rkz = 8948, + X86_VPBROADCASTBrZr = 8949, + X86_VPBROADCASTBrZrk = 8950, + X86_VPBROADCASTBrZrkz = 8951, + X86_VPBROADCASTBrm = 8952, + X86_VPBROADCASTBrr = 8953, + X86_VPBROADCASTDYrm = 8954, + X86_VPBROADCASTDYrr = 8955, + X86_VPBROADCASTDZ128m = 8956, + X86_VPBROADCASTDZ128mk = 8957, + X86_VPBROADCASTDZ128mkz = 8958, + X86_VPBROADCASTDZ128r = 8959, + X86_VPBROADCASTDZ128rk = 8960, + X86_VPBROADCASTDZ128rkz = 8961, + X86_VPBROADCASTDZ256m = 8962, + X86_VPBROADCASTDZ256mk = 8963, + X86_VPBROADCASTDZ256mkz = 8964, + X86_VPBROADCASTDZ256r = 8965, + X86_VPBROADCASTDZ256rk = 8966, + X86_VPBROADCASTDZ256rkz = 8967, + X86_VPBROADCASTDZm = 8968, + X86_VPBROADCASTDZmk = 8969, + X86_VPBROADCASTDZmkz = 8970, + X86_VPBROADCASTDZr = 8971, + X86_VPBROADCASTDZrk = 8972, + X86_VPBROADCASTDZrkz = 8973, + X86_VPBROADCASTDrZ128r = 8974, + X86_VPBROADCASTDrZ128rk = 8975, + X86_VPBROADCASTDrZ128rkz = 8976, + X86_VPBROADCASTDrZ256r = 8977, + X86_VPBROADCASTDrZ256rk = 8978, + X86_VPBROADCASTDrZ256rkz = 8979, + X86_VPBROADCASTDrZr = 8980, + X86_VPBROADCASTDrZrk = 8981, + X86_VPBROADCASTDrZrkz = 8982, + X86_VPBROADCASTDrm = 8983, + X86_VPBROADCASTDrr = 8984, + X86_VPBROADCASTMB2QZ128rr = 8985, + X86_VPBROADCASTMB2QZ256rr = 8986, + X86_VPBROADCASTMB2QZrr = 8987, + X86_VPBROADCASTMW2DZ128rr = 8988, + X86_VPBROADCASTMW2DZ256rr = 8989, + X86_VPBROADCASTMW2DZrr = 8990, + X86_VPBROADCASTQYrm = 8991, + X86_VPBROADCASTQYrr = 8992, + X86_VPBROADCASTQZ128m = 8993, + X86_VPBROADCASTQZ128mk = 8994, + X86_VPBROADCASTQZ128mkz = 8995, + X86_VPBROADCASTQZ128r = 8996, + X86_VPBROADCASTQZ128rk = 8997, + X86_VPBROADCASTQZ128rkz = 8998, + X86_VPBROADCASTQZ256m = 8999, + X86_VPBROADCASTQZ256mk = 9000, + X86_VPBROADCASTQZ256mkz = 9001, + X86_VPBROADCASTQZ256r = 9002, + X86_VPBROADCASTQZ256rk = 9003, + X86_VPBROADCASTQZ256rkz = 9004, + X86_VPBROADCASTQZm = 9005, + X86_VPBROADCASTQZmk = 9006, + X86_VPBROADCASTQZmkz = 9007, + X86_VPBROADCASTQZr = 9008, + X86_VPBROADCASTQZrk = 9009, + X86_VPBROADCASTQZrkz = 9010, + X86_VPBROADCASTQrZ128r = 9011, + X86_VPBROADCASTQrZ128rk = 9012, + X86_VPBROADCASTQrZ128rkz = 9013, + X86_VPBROADCASTQrZ256r = 9014, + X86_VPBROADCASTQrZ256rk = 9015, + X86_VPBROADCASTQrZ256rkz = 9016, + X86_VPBROADCASTQrZr = 9017, + X86_VPBROADCASTQrZrk = 9018, + X86_VPBROADCASTQrZrkz = 9019, + X86_VPBROADCASTQrm = 9020, + X86_VPBROADCASTQrr = 9021, + X86_VPBROADCASTWYrm = 9022, + X86_VPBROADCASTWYrr = 9023, + X86_VPBROADCASTWZ128m = 9024, + X86_VPBROADCASTWZ128mk = 9025, + X86_VPBROADCASTWZ128mkz = 9026, + X86_VPBROADCASTWZ128r = 9027, + X86_VPBROADCASTWZ128rk = 9028, + X86_VPBROADCASTWZ128rkz = 9029, + X86_VPBROADCASTWZ256m = 9030, + X86_VPBROADCASTWZ256mk = 9031, + X86_VPBROADCASTWZ256mkz = 9032, + X86_VPBROADCASTWZ256r = 9033, + X86_VPBROADCASTWZ256rk = 9034, + X86_VPBROADCASTWZ256rkz = 9035, + X86_VPBROADCASTWZm = 9036, + X86_VPBROADCASTWZmk = 9037, + X86_VPBROADCASTWZmkz = 9038, + X86_VPBROADCASTWZr = 9039, + X86_VPBROADCASTWZrk = 9040, + X86_VPBROADCASTWZrkz = 9041, + X86_VPBROADCASTWrZ128r = 9042, + X86_VPBROADCASTWrZ128rk = 9043, + X86_VPBROADCASTWrZ128rkz = 9044, + X86_VPBROADCASTWrZ256r = 9045, + X86_VPBROADCASTWrZ256rk = 9046, + X86_VPBROADCASTWrZ256rkz = 9047, + X86_VPBROADCASTWrZr = 9048, + X86_VPBROADCASTWrZrk = 9049, + X86_VPBROADCASTWrZrkz = 9050, + X86_VPBROADCASTWrm = 9051, + X86_VPBROADCASTWrr = 9052, + X86_VPCLMULQDQYrm = 9053, + X86_VPCLMULQDQYrr = 9054, + X86_VPCLMULQDQZ128rm = 9055, + X86_VPCLMULQDQZ128rr = 9056, + X86_VPCLMULQDQZ256rm = 9057, + X86_VPCLMULQDQZ256rr = 9058, + X86_VPCLMULQDQZrm = 9059, + X86_VPCLMULQDQZrr = 9060, + X86_VPCLMULQDQrm = 9061, + X86_VPCLMULQDQrr = 9062, + X86_VPCMOVYrmr = 9063, + X86_VPCMOVYrrm = 9064, + X86_VPCMOVYrrr = 9065, + X86_VPCMOVYrrr_REV = 9066, + X86_VPCMOVrmr = 9067, + X86_VPCMOVrrm = 9068, + X86_VPCMOVrrr = 9069, + X86_VPCMOVrrr_REV = 9070, + X86_VPCMPBZ128rmi = 9071, + X86_VPCMPBZ128rmi_alt = 9072, + X86_VPCMPBZ128rmik = 9073, + X86_VPCMPBZ128rmik_alt = 9074, + X86_VPCMPBZ128rri = 9075, + X86_VPCMPBZ128rri_alt = 9076, + X86_VPCMPBZ128rrik = 9077, + X86_VPCMPBZ128rrik_alt = 9078, + X86_VPCMPBZ256rmi = 9079, + X86_VPCMPBZ256rmi_alt = 9080, + X86_VPCMPBZ256rmik = 9081, + X86_VPCMPBZ256rmik_alt = 9082, + X86_VPCMPBZ256rri = 9083, + X86_VPCMPBZ256rri_alt = 9084, + X86_VPCMPBZ256rrik = 9085, + X86_VPCMPBZ256rrik_alt = 9086, + X86_VPCMPBZrmi = 9087, + X86_VPCMPBZrmi_alt = 9088, + X86_VPCMPBZrmik = 9089, + X86_VPCMPBZrmik_alt = 9090, + X86_VPCMPBZrri = 9091, + X86_VPCMPBZrri_alt = 9092, + X86_VPCMPBZrrik = 9093, + X86_VPCMPBZrrik_alt = 9094, + X86_VPCMPDZ128rmi = 9095, + X86_VPCMPDZ128rmi_alt = 9096, + X86_VPCMPDZ128rmib = 9097, + X86_VPCMPDZ128rmib_alt = 9098, + X86_VPCMPDZ128rmibk = 9099, + X86_VPCMPDZ128rmibk_alt = 9100, + X86_VPCMPDZ128rmik = 9101, + X86_VPCMPDZ128rmik_alt = 9102, + X86_VPCMPDZ128rri = 9103, + X86_VPCMPDZ128rri_alt = 9104, + X86_VPCMPDZ128rrik = 9105, + X86_VPCMPDZ128rrik_alt = 9106, + X86_VPCMPDZ256rmi = 9107, + X86_VPCMPDZ256rmi_alt = 9108, + X86_VPCMPDZ256rmib = 9109, + X86_VPCMPDZ256rmib_alt = 9110, + X86_VPCMPDZ256rmibk = 9111, + X86_VPCMPDZ256rmibk_alt = 9112, + X86_VPCMPDZ256rmik = 9113, + X86_VPCMPDZ256rmik_alt = 9114, + X86_VPCMPDZ256rri = 9115, + X86_VPCMPDZ256rri_alt = 9116, + X86_VPCMPDZ256rrik = 9117, + X86_VPCMPDZ256rrik_alt = 9118, + X86_VPCMPDZrmi = 9119, + X86_VPCMPDZrmi_alt = 9120, + X86_VPCMPDZrmib = 9121, + X86_VPCMPDZrmib_alt = 9122, + X86_VPCMPDZrmibk = 9123, + X86_VPCMPDZrmibk_alt = 9124, + X86_VPCMPDZrmik = 9125, + X86_VPCMPDZrmik_alt = 9126, + X86_VPCMPDZrri = 9127, + X86_VPCMPDZrri_alt = 9128, + X86_VPCMPDZrrik = 9129, + X86_VPCMPDZrrik_alt = 9130, + X86_VPCMPEQBYrm = 9131, + X86_VPCMPEQBYrr = 9132, + X86_VPCMPEQBZ128rm = 9133, + X86_VPCMPEQBZ128rmk = 9134, + X86_VPCMPEQBZ128rr = 9135, + X86_VPCMPEQBZ128rrk = 9136, + X86_VPCMPEQBZ256rm = 9137, + X86_VPCMPEQBZ256rmk = 9138, + X86_VPCMPEQBZ256rr = 9139, + X86_VPCMPEQBZ256rrk = 9140, + X86_VPCMPEQBZrm = 9141, + X86_VPCMPEQBZrmk = 9142, + X86_VPCMPEQBZrr = 9143, + X86_VPCMPEQBZrrk = 9144, + X86_VPCMPEQBrm = 9145, + X86_VPCMPEQBrr = 9146, + X86_VPCMPEQDYrm = 9147, + X86_VPCMPEQDYrr = 9148, + X86_VPCMPEQDZ128rm = 9149, + X86_VPCMPEQDZ128rmb = 9150, + X86_VPCMPEQDZ128rmbk = 9151, + X86_VPCMPEQDZ128rmk = 9152, + X86_VPCMPEQDZ128rr = 9153, + X86_VPCMPEQDZ128rrk = 9154, + X86_VPCMPEQDZ256rm = 9155, + X86_VPCMPEQDZ256rmb = 9156, + X86_VPCMPEQDZ256rmbk = 9157, + X86_VPCMPEQDZ256rmk = 9158, + X86_VPCMPEQDZ256rr = 9159, + X86_VPCMPEQDZ256rrk = 9160, + X86_VPCMPEQDZrm = 9161, + X86_VPCMPEQDZrmb = 9162, + X86_VPCMPEQDZrmbk = 9163, + X86_VPCMPEQDZrmk = 9164, + X86_VPCMPEQDZrr = 9165, + X86_VPCMPEQDZrrk = 9166, + X86_VPCMPEQDrm = 9167, + X86_VPCMPEQDrr = 9168, + X86_VPCMPEQQYrm = 9169, + X86_VPCMPEQQYrr = 9170, + X86_VPCMPEQQZ128rm = 9171, + X86_VPCMPEQQZ128rmb = 9172, + X86_VPCMPEQQZ128rmbk = 9173, + X86_VPCMPEQQZ128rmk = 9174, + X86_VPCMPEQQZ128rr = 9175, + X86_VPCMPEQQZ128rrk = 9176, + X86_VPCMPEQQZ256rm = 9177, + X86_VPCMPEQQZ256rmb = 9178, + X86_VPCMPEQQZ256rmbk = 9179, + X86_VPCMPEQQZ256rmk = 9180, + X86_VPCMPEQQZ256rr = 9181, + X86_VPCMPEQQZ256rrk = 9182, + X86_VPCMPEQQZrm = 9183, + X86_VPCMPEQQZrmb = 9184, + X86_VPCMPEQQZrmbk = 9185, + X86_VPCMPEQQZrmk = 9186, + X86_VPCMPEQQZrr = 9187, + X86_VPCMPEQQZrrk = 9188, + X86_VPCMPEQQrm = 9189, + X86_VPCMPEQQrr = 9190, + X86_VPCMPEQWYrm = 9191, + X86_VPCMPEQWYrr = 9192, + X86_VPCMPEQWZ128rm = 9193, + X86_VPCMPEQWZ128rmk = 9194, + X86_VPCMPEQWZ128rr = 9195, + X86_VPCMPEQWZ128rrk = 9196, + X86_VPCMPEQWZ256rm = 9197, + X86_VPCMPEQWZ256rmk = 9198, + X86_VPCMPEQWZ256rr = 9199, + X86_VPCMPEQWZ256rrk = 9200, + X86_VPCMPEQWZrm = 9201, + X86_VPCMPEQWZrmk = 9202, + X86_VPCMPEQWZrr = 9203, + X86_VPCMPEQWZrrk = 9204, + X86_VPCMPEQWrm = 9205, + X86_VPCMPEQWrr = 9206, + X86_VPCMPESTRIrm = 9207, + X86_VPCMPESTRIrr = 9208, + X86_VPCMPESTRMrm = 9209, + X86_VPCMPESTRMrr = 9210, + X86_VPCMPGTBYrm = 9211, + X86_VPCMPGTBYrr = 9212, + X86_VPCMPGTBZ128rm = 9213, + X86_VPCMPGTBZ128rmk = 9214, + X86_VPCMPGTBZ128rr = 9215, + X86_VPCMPGTBZ128rrk = 9216, + X86_VPCMPGTBZ256rm = 9217, + X86_VPCMPGTBZ256rmk = 9218, + X86_VPCMPGTBZ256rr = 9219, + X86_VPCMPGTBZ256rrk = 9220, + X86_VPCMPGTBZrm = 9221, + X86_VPCMPGTBZrmk = 9222, + X86_VPCMPGTBZrr = 9223, + X86_VPCMPGTBZrrk = 9224, + X86_VPCMPGTBrm = 9225, + X86_VPCMPGTBrr = 9226, + X86_VPCMPGTDYrm = 9227, + X86_VPCMPGTDYrr = 9228, + X86_VPCMPGTDZ128rm = 9229, + X86_VPCMPGTDZ128rmb = 9230, + X86_VPCMPGTDZ128rmbk = 9231, + X86_VPCMPGTDZ128rmk = 9232, + X86_VPCMPGTDZ128rr = 9233, + X86_VPCMPGTDZ128rrk = 9234, + X86_VPCMPGTDZ256rm = 9235, + X86_VPCMPGTDZ256rmb = 9236, + X86_VPCMPGTDZ256rmbk = 9237, + X86_VPCMPGTDZ256rmk = 9238, + X86_VPCMPGTDZ256rr = 9239, + X86_VPCMPGTDZ256rrk = 9240, + X86_VPCMPGTDZrm = 9241, + X86_VPCMPGTDZrmb = 9242, + X86_VPCMPGTDZrmbk = 9243, + X86_VPCMPGTDZrmk = 9244, + X86_VPCMPGTDZrr = 9245, + X86_VPCMPGTDZrrk = 9246, + X86_VPCMPGTDrm = 9247, + X86_VPCMPGTDrr = 9248, + X86_VPCMPGTQYrm = 9249, + X86_VPCMPGTQYrr = 9250, + X86_VPCMPGTQZ128rm = 9251, + X86_VPCMPGTQZ128rmb = 9252, + X86_VPCMPGTQZ128rmbk = 9253, + X86_VPCMPGTQZ128rmk = 9254, + X86_VPCMPGTQZ128rr = 9255, + X86_VPCMPGTQZ128rrk = 9256, + X86_VPCMPGTQZ256rm = 9257, + X86_VPCMPGTQZ256rmb = 9258, + X86_VPCMPGTQZ256rmbk = 9259, + X86_VPCMPGTQZ256rmk = 9260, + X86_VPCMPGTQZ256rr = 9261, + X86_VPCMPGTQZ256rrk = 9262, + X86_VPCMPGTQZrm = 9263, + X86_VPCMPGTQZrmb = 9264, + X86_VPCMPGTQZrmbk = 9265, + X86_VPCMPGTQZrmk = 9266, + X86_VPCMPGTQZrr = 9267, + X86_VPCMPGTQZrrk = 9268, + X86_VPCMPGTQrm = 9269, + X86_VPCMPGTQrr = 9270, + X86_VPCMPGTWYrm = 9271, + X86_VPCMPGTWYrr = 9272, + X86_VPCMPGTWZ128rm = 9273, + X86_VPCMPGTWZ128rmk = 9274, + X86_VPCMPGTWZ128rr = 9275, + X86_VPCMPGTWZ128rrk = 9276, + X86_VPCMPGTWZ256rm = 9277, + X86_VPCMPGTWZ256rmk = 9278, + X86_VPCMPGTWZ256rr = 9279, + X86_VPCMPGTWZ256rrk = 9280, + X86_VPCMPGTWZrm = 9281, + X86_VPCMPGTWZrmk = 9282, + X86_VPCMPGTWZrr = 9283, + X86_VPCMPGTWZrrk = 9284, + X86_VPCMPGTWrm = 9285, + X86_VPCMPGTWrr = 9286, + X86_VPCMPISTRIrm = 9287, + X86_VPCMPISTRIrr = 9288, + X86_VPCMPISTRMrm = 9289, + X86_VPCMPISTRMrr = 9290, + X86_VPCMPQZ128rmi = 9291, + X86_VPCMPQZ128rmi_alt = 9292, + X86_VPCMPQZ128rmib = 9293, + X86_VPCMPQZ128rmib_alt = 9294, + X86_VPCMPQZ128rmibk = 9295, + X86_VPCMPQZ128rmibk_alt = 9296, + X86_VPCMPQZ128rmik = 9297, + X86_VPCMPQZ128rmik_alt = 9298, + X86_VPCMPQZ128rri = 9299, + X86_VPCMPQZ128rri_alt = 9300, + X86_VPCMPQZ128rrik = 9301, + X86_VPCMPQZ128rrik_alt = 9302, + X86_VPCMPQZ256rmi = 9303, + X86_VPCMPQZ256rmi_alt = 9304, + X86_VPCMPQZ256rmib = 9305, + X86_VPCMPQZ256rmib_alt = 9306, + X86_VPCMPQZ256rmibk = 9307, + X86_VPCMPQZ256rmibk_alt = 9308, + X86_VPCMPQZ256rmik = 9309, + X86_VPCMPQZ256rmik_alt = 9310, + X86_VPCMPQZ256rri = 9311, + X86_VPCMPQZ256rri_alt = 9312, + X86_VPCMPQZ256rrik = 9313, + X86_VPCMPQZ256rrik_alt = 9314, + X86_VPCMPQZrmi = 9315, + X86_VPCMPQZrmi_alt = 9316, + X86_VPCMPQZrmib = 9317, + X86_VPCMPQZrmib_alt = 9318, + X86_VPCMPQZrmibk = 9319, + X86_VPCMPQZrmibk_alt = 9320, + X86_VPCMPQZrmik = 9321, + X86_VPCMPQZrmik_alt = 9322, + X86_VPCMPQZrri = 9323, + X86_VPCMPQZrri_alt = 9324, + X86_VPCMPQZrrik = 9325, + X86_VPCMPQZrrik_alt = 9326, + X86_VPCMPUBZ128rmi = 9327, + X86_VPCMPUBZ128rmi_alt = 9328, + X86_VPCMPUBZ128rmik = 9329, + X86_VPCMPUBZ128rmik_alt = 9330, + X86_VPCMPUBZ128rri = 9331, + X86_VPCMPUBZ128rri_alt = 9332, + X86_VPCMPUBZ128rrik = 9333, + X86_VPCMPUBZ128rrik_alt = 9334, + X86_VPCMPUBZ256rmi = 9335, + X86_VPCMPUBZ256rmi_alt = 9336, + X86_VPCMPUBZ256rmik = 9337, + X86_VPCMPUBZ256rmik_alt = 9338, + X86_VPCMPUBZ256rri = 9339, + X86_VPCMPUBZ256rri_alt = 9340, + X86_VPCMPUBZ256rrik = 9341, + X86_VPCMPUBZ256rrik_alt = 9342, + X86_VPCMPUBZrmi = 9343, + X86_VPCMPUBZrmi_alt = 9344, + X86_VPCMPUBZrmik = 9345, + X86_VPCMPUBZrmik_alt = 9346, + X86_VPCMPUBZrri = 9347, + X86_VPCMPUBZrri_alt = 9348, + X86_VPCMPUBZrrik = 9349, + X86_VPCMPUBZrrik_alt = 9350, + X86_VPCMPUDZ128rmi = 9351, + X86_VPCMPUDZ128rmi_alt = 9352, + X86_VPCMPUDZ128rmib = 9353, + X86_VPCMPUDZ128rmib_alt = 9354, + X86_VPCMPUDZ128rmibk = 9355, + X86_VPCMPUDZ128rmibk_alt = 9356, + X86_VPCMPUDZ128rmik = 9357, + X86_VPCMPUDZ128rmik_alt = 9358, + X86_VPCMPUDZ128rri = 9359, + X86_VPCMPUDZ128rri_alt = 9360, + X86_VPCMPUDZ128rrik = 9361, + X86_VPCMPUDZ128rrik_alt = 9362, + X86_VPCMPUDZ256rmi = 9363, + X86_VPCMPUDZ256rmi_alt = 9364, + X86_VPCMPUDZ256rmib = 9365, + X86_VPCMPUDZ256rmib_alt = 9366, + X86_VPCMPUDZ256rmibk = 9367, + X86_VPCMPUDZ256rmibk_alt = 9368, + X86_VPCMPUDZ256rmik = 9369, + X86_VPCMPUDZ256rmik_alt = 9370, + X86_VPCMPUDZ256rri = 9371, + X86_VPCMPUDZ256rri_alt = 9372, + X86_VPCMPUDZ256rrik = 9373, + X86_VPCMPUDZ256rrik_alt = 9374, + X86_VPCMPUDZrmi = 9375, + X86_VPCMPUDZrmi_alt = 9376, + X86_VPCMPUDZrmib = 9377, + X86_VPCMPUDZrmib_alt = 9378, + X86_VPCMPUDZrmibk = 9379, + X86_VPCMPUDZrmibk_alt = 9380, + X86_VPCMPUDZrmik = 9381, + X86_VPCMPUDZrmik_alt = 9382, + X86_VPCMPUDZrri = 9383, + X86_VPCMPUDZrri_alt = 9384, + X86_VPCMPUDZrrik = 9385, + X86_VPCMPUDZrrik_alt = 9386, + X86_VPCMPUQZ128rmi = 9387, + X86_VPCMPUQZ128rmi_alt = 9388, + X86_VPCMPUQZ128rmib = 9389, + X86_VPCMPUQZ128rmib_alt = 9390, + X86_VPCMPUQZ128rmibk = 9391, + X86_VPCMPUQZ128rmibk_alt = 9392, + X86_VPCMPUQZ128rmik = 9393, + X86_VPCMPUQZ128rmik_alt = 9394, + X86_VPCMPUQZ128rri = 9395, + X86_VPCMPUQZ128rri_alt = 9396, + X86_VPCMPUQZ128rrik = 9397, + X86_VPCMPUQZ128rrik_alt = 9398, + X86_VPCMPUQZ256rmi = 9399, + X86_VPCMPUQZ256rmi_alt = 9400, + X86_VPCMPUQZ256rmib = 9401, + X86_VPCMPUQZ256rmib_alt = 9402, + X86_VPCMPUQZ256rmibk = 9403, + X86_VPCMPUQZ256rmibk_alt = 9404, + X86_VPCMPUQZ256rmik = 9405, + X86_VPCMPUQZ256rmik_alt = 9406, + X86_VPCMPUQZ256rri = 9407, + X86_VPCMPUQZ256rri_alt = 9408, + X86_VPCMPUQZ256rrik = 9409, + X86_VPCMPUQZ256rrik_alt = 9410, + X86_VPCMPUQZrmi = 9411, + X86_VPCMPUQZrmi_alt = 9412, + X86_VPCMPUQZrmib = 9413, + X86_VPCMPUQZrmib_alt = 9414, + X86_VPCMPUQZrmibk = 9415, + X86_VPCMPUQZrmibk_alt = 9416, + X86_VPCMPUQZrmik = 9417, + X86_VPCMPUQZrmik_alt = 9418, + X86_VPCMPUQZrri = 9419, + X86_VPCMPUQZrri_alt = 9420, + X86_VPCMPUQZrrik = 9421, + X86_VPCMPUQZrrik_alt = 9422, + X86_VPCMPUWZ128rmi = 9423, + X86_VPCMPUWZ128rmi_alt = 9424, + X86_VPCMPUWZ128rmik = 9425, + X86_VPCMPUWZ128rmik_alt = 9426, + X86_VPCMPUWZ128rri = 9427, + X86_VPCMPUWZ128rri_alt = 9428, + X86_VPCMPUWZ128rrik = 9429, + X86_VPCMPUWZ128rrik_alt = 9430, + X86_VPCMPUWZ256rmi = 9431, + X86_VPCMPUWZ256rmi_alt = 9432, + X86_VPCMPUWZ256rmik = 9433, + X86_VPCMPUWZ256rmik_alt = 9434, + X86_VPCMPUWZ256rri = 9435, + X86_VPCMPUWZ256rri_alt = 9436, + X86_VPCMPUWZ256rrik = 9437, + X86_VPCMPUWZ256rrik_alt = 9438, + X86_VPCMPUWZrmi = 9439, + X86_VPCMPUWZrmi_alt = 9440, + X86_VPCMPUWZrmik = 9441, + X86_VPCMPUWZrmik_alt = 9442, + X86_VPCMPUWZrri = 9443, + X86_VPCMPUWZrri_alt = 9444, + X86_VPCMPUWZrrik = 9445, + X86_VPCMPUWZrrik_alt = 9446, + X86_VPCMPWZ128rmi = 9447, + X86_VPCMPWZ128rmi_alt = 9448, + X86_VPCMPWZ128rmik = 9449, + X86_VPCMPWZ128rmik_alt = 9450, + X86_VPCMPWZ128rri = 9451, + X86_VPCMPWZ128rri_alt = 9452, + X86_VPCMPWZ128rrik = 9453, + X86_VPCMPWZ128rrik_alt = 9454, + X86_VPCMPWZ256rmi = 9455, + X86_VPCMPWZ256rmi_alt = 9456, + X86_VPCMPWZ256rmik = 9457, + X86_VPCMPWZ256rmik_alt = 9458, + X86_VPCMPWZ256rri = 9459, + X86_VPCMPWZ256rri_alt = 9460, + X86_VPCMPWZ256rrik = 9461, + X86_VPCMPWZ256rrik_alt = 9462, + X86_VPCMPWZrmi = 9463, + X86_VPCMPWZrmi_alt = 9464, + X86_VPCMPWZrmik = 9465, + X86_VPCMPWZrmik_alt = 9466, + X86_VPCMPWZrri = 9467, + X86_VPCMPWZrri_alt = 9468, + X86_VPCMPWZrrik = 9469, + X86_VPCMPWZrrik_alt = 9470, + X86_VPCOMBmi = 9471, + X86_VPCOMBmi_alt = 9472, + X86_VPCOMBri = 9473, + X86_VPCOMBri_alt = 9474, + X86_VPCOMDmi = 9475, + X86_VPCOMDmi_alt = 9476, + X86_VPCOMDri = 9477, + X86_VPCOMDri_alt = 9478, + X86_VPCOMPRESSBZ128mr = 9479, + X86_VPCOMPRESSBZ128mrk = 9480, + X86_VPCOMPRESSBZ128rr = 9481, + X86_VPCOMPRESSBZ128rrk = 9482, + X86_VPCOMPRESSBZ128rrkz = 9483, + X86_VPCOMPRESSBZ256mr = 9484, + X86_VPCOMPRESSBZ256mrk = 9485, + X86_VPCOMPRESSBZ256rr = 9486, + X86_VPCOMPRESSBZ256rrk = 9487, + X86_VPCOMPRESSBZ256rrkz = 9488, + X86_VPCOMPRESSBZmr = 9489, + X86_VPCOMPRESSBZmrk = 9490, + X86_VPCOMPRESSBZrr = 9491, + X86_VPCOMPRESSBZrrk = 9492, + X86_VPCOMPRESSBZrrkz = 9493, + X86_VPCOMPRESSDZ128mr = 9494, + X86_VPCOMPRESSDZ128mrk = 9495, + X86_VPCOMPRESSDZ128rr = 9496, + X86_VPCOMPRESSDZ128rrk = 9497, + X86_VPCOMPRESSDZ128rrkz = 9498, + X86_VPCOMPRESSDZ256mr = 9499, + X86_VPCOMPRESSDZ256mrk = 9500, + X86_VPCOMPRESSDZ256rr = 9501, + X86_VPCOMPRESSDZ256rrk = 9502, + X86_VPCOMPRESSDZ256rrkz = 9503, + X86_VPCOMPRESSDZmr = 9504, + X86_VPCOMPRESSDZmrk = 9505, + X86_VPCOMPRESSDZrr = 9506, + X86_VPCOMPRESSDZrrk = 9507, + X86_VPCOMPRESSDZrrkz = 9508, + X86_VPCOMPRESSQZ128mr = 9509, + X86_VPCOMPRESSQZ128mrk = 9510, + X86_VPCOMPRESSQZ128rr = 9511, + X86_VPCOMPRESSQZ128rrk = 9512, + X86_VPCOMPRESSQZ128rrkz = 9513, + X86_VPCOMPRESSQZ256mr = 9514, + X86_VPCOMPRESSQZ256mrk = 9515, + X86_VPCOMPRESSQZ256rr = 9516, + X86_VPCOMPRESSQZ256rrk = 9517, + X86_VPCOMPRESSQZ256rrkz = 9518, + X86_VPCOMPRESSQZmr = 9519, + X86_VPCOMPRESSQZmrk = 9520, + X86_VPCOMPRESSQZrr = 9521, + X86_VPCOMPRESSQZrrk = 9522, + X86_VPCOMPRESSQZrrkz = 9523, + X86_VPCOMPRESSWZ128mr = 9524, + X86_VPCOMPRESSWZ128mrk = 9525, + X86_VPCOMPRESSWZ128rr = 9526, + X86_VPCOMPRESSWZ128rrk = 9527, + X86_VPCOMPRESSWZ128rrkz = 9528, + X86_VPCOMPRESSWZ256mr = 9529, + X86_VPCOMPRESSWZ256mrk = 9530, + X86_VPCOMPRESSWZ256rr = 9531, + X86_VPCOMPRESSWZ256rrk = 9532, + X86_VPCOMPRESSWZ256rrkz = 9533, + X86_VPCOMPRESSWZmr = 9534, + X86_VPCOMPRESSWZmrk = 9535, + X86_VPCOMPRESSWZrr = 9536, + X86_VPCOMPRESSWZrrk = 9537, + X86_VPCOMPRESSWZrrkz = 9538, + X86_VPCOMQmi = 9539, + X86_VPCOMQmi_alt = 9540, + X86_VPCOMQri = 9541, + X86_VPCOMQri_alt = 9542, + X86_VPCOMUBmi = 9543, + X86_VPCOMUBmi_alt = 9544, + X86_VPCOMUBri = 9545, + X86_VPCOMUBri_alt = 9546, + X86_VPCOMUDmi = 9547, + X86_VPCOMUDmi_alt = 9548, + X86_VPCOMUDri = 9549, + X86_VPCOMUDri_alt = 9550, + X86_VPCOMUQmi = 9551, + X86_VPCOMUQmi_alt = 9552, + X86_VPCOMUQri = 9553, + X86_VPCOMUQri_alt = 9554, + X86_VPCOMUWmi = 9555, + X86_VPCOMUWmi_alt = 9556, + X86_VPCOMUWri = 9557, + X86_VPCOMUWri_alt = 9558, + X86_VPCOMWmi = 9559, + X86_VPCOMWmi_alt = 9560, + X86_VPCOMWri = 9561, + X86_VPCOMWri_alt = 9562, + X86_VPCONFLICTDZ128rm = 9563, + X86_VPCONFLICTDZ128rmb = 9564, + X86_VPCONFLICTDZ128rmbk = 9565, + X86_VPCONFLICTDZ128rmbkz = 9566, + X86_VPCONFLICTDZ128rmk = 9567, + X86_VPCONFLICTDZ128rmkz = 9568, + X86_VPCONFLICTDZ128rr = 9569, + X86_VPCONFLICTDZ128rrk = 9570, + X86_VPCONFLICTDZ128rrkz = 9571, + X86_VPCONFLICTDZ256rm = 9572, + X86_VPCONFLICTDZ256rmb = 9573, + X86_VPCONFLICTDZ256rmbk = 9574, + X86_VPCONFLICTDZ256rmbkz = 9575, + X86_VPCONFLICTDZ256rmk = 9576, + X86_VPCONFLICTDZ256rmkz = 9577, + X86_VPCONFLICTDZ256rr = 9578, + X86_VPCONFLICTDZ256rrk = 9579, + X86_VPCONFLICTDZ256rrkz = 9580, + X86_VPCONFLICTDZrm = 9581, + X86_VPCONFLICTDZrmb = 9582, + X86_VPCONFLICTDZrmbk = 9583, + X86_VPCONFLICTDZrmbkz = 9584, + X86_VPCONFLICTDZrmk = 9585, + X86_VPCONFLICTDZrmkz = 9586, + X86_VPCONFLICTDZrr = 9587, + X86_VPCONFLICTDZrrk = 9588, + X86_VPCONFLICTDZrrkz = 9589, + X86_VPCONFLICTQZ128rm = 9590, + X86_VPCONFLICTQZ128rmb = 9591, + X86_VPCONFLICTQZ128rmbk = 9592, + X86_VPCONFLICTQZ128rmbkz = 9593, + X86_VPCONFLICTQZ128rmk = 9594, + X86_VPCONFLICTQZ128rmkz = 9595, + X86_VPCONFLICTQZ128rr = 9596, + X86_VPCONFLICTQZ128rrk = 9597, + X86_VPCONFLICTQZ128rrkz = 9598, + X86_VPCONFLICTQZ256rm = 9599, + X86_VPCONFLICTQZ256rmb = 9600, + X86_VPCONFLICTQZ256rmbk = 9601, + X86_VPCONFLICTQZ256rmbkz = 9602, + X86_VPCONFLICTQZ256rmk = 9603, + X86_VPCONFLICTQZ256rmkz = 9604, + X86_VPCONFLICTQZ256rr = 9605, + X86_VPCONFLICTQZ256rrk = 9606, + X86_VPCONFLICTQZ256rrkz = 9607, + X86_VPCONFLICTQZrm = 9608, + X86_VPCONFLICTQZrmb = 9609, + X86_VPCONFLICTQZrmbk = 9610, + X86_VPCONFLICTQZrmbkz = 9611, + X86_VPCONFLICTQZrmk = 9612, + X86_VPCONFLICTQZrmkz = 9613, + X86_VPCONFLICTQZrr = 9614, + X86_VPCONFLICTQZrrk = 9615, + X86_VPCONFLICTQZrrkz = 9616, + X86_VPDPBUSDSZ128m = 9617, + X86_VPDPBUSDSZ128mb = 9618, + X86_VPDPBUSDSZ128mbk = 9619, + X86_VPDPBUSDSZ128mbkz = 9620, + X86_VPDPBUSDSZ128mk = 9621, + X86_VPDPBUSDSZ128mkz = 9622, + X86_VPDPBUSDSZ128r = 9623, + X86_VPDPBUSDSZ128rk = 9624, + X86_VPDPBUSDSZ128rkz = 9625, + X86_VPDPBUSDSZ256m = 9626, + X86_VPDPBUSDSZ256mb = 9627, + X86_VPDPBUSDSZ256mbk = 9628, + X86_VPDPBUSDSZ256mbkz = 9629, + X86_VPDPBUSDSZ256mk = 9630, + X86_VPDPBUSDSZ256mkz = 9631, + X86_VPDPBUSDSZ256r = 9632, + X86_VPDPBUSDSZ256rk = 9633, + X86_VPDPBUSDSZ256rkz = 9634, + X86_VPDPBUSDSZm = 9635, + X86_VPDPBUSDSZmb = 9636, + X86_VPDPBUSDSZmbk = 9637, + X86_VPDPBUSDSZmbkz = 9638, + X86_VPDPBUSDSZmk = 9639, + X86_VPDPBUSDSZmkz = 9640, + X86_VPDPBUSDSZr = 9641, + X86_VPDPBUSDSZrk = 9642, + X86_VPDPBUSDSZrkz = 9643, + X86_VPDPBUSDZ128m = 9644, + X86_VPDPBUSDZ128mb = 9645, + X86_VPDPBUSDZ128mbk = 9646, + X86_VPDPBUSDZ128mbkz = 9647, + X86_VPDPBUSDZ128mk = 9648, + X86_VPDPBUSDZ128mkz = 9649, + X86_VPDPBUSDZ128r = 9650, + X86_VPDPBUSDZ128rk = 9651, + X86_VPDPBUSDZ128rkz = 9652, + X86_VPDPBUSDZ256m = 9653, + X86_VPDPBUSDZ256mb = 9654, + X86_VPDPBUSDZ256mbk = 9655, + X86_VPDPBUSDZ256mbkz = 9656, + X86_VPDPBUSDZ256mk = 9657, + X86_VPDPBUSDZ256mkz = 9658, + X86_VPDPBUSDZ256r = 9659, + X86_VPDPBUSDZ256rk = 9660, + X86_VPDPBUSDZ256rkz = 9661, + X86_VPDPBUSDZm = 9662, + X86_VPDPBUSDZmb = 9663, + X86_VPDPBUSDZmbk = 9664, + X86_VPDPBUSDZmbkz = 9665, + X86_VPDPBUSDZmk = 9666, + X86_VPDPBUSDZmkz = 9667, + X86_VPDPBUSDZr = 9668, + X86_VPDPBUSDZrk = 9669, + X86_VPDPBUSDZrkz = 9670, + X86_VPDPWSSDSZ128m = 9671, + X86_VPDPWSSDSZ128mb = 9672, + X86_VPDPWSSDSZ128mbk = 9673, + X86_VPDPWSSDSZ128mbkz = 9674, + X86_VPDPWSSDSZ128mk = 9675, + X86_VPDPWSSDSZ128mkz = 9676, + X86_VPDPWSSDSZ128r = 9677, + X86_VPDPWSSDSZ128rk = 9678, + X86_VPDPWSSDSZ128rkz = 9679, + X86_VPDPWSSDSZ256m = 9680, + X86_VPDPWSSDSZ256mb = 9681, + X86_VPDPWSSDSZ256mbk = 9682, + X86_VPDPWSSDSZ256mbkz = 9683, + X86_VPDPWSSDSZ256mk = 9684, + X86_VPDPWSSDSZ256mkz = 9685, + X86_VPDPWSSDSZ256r = 9686, + X86_VPDPWSSDSZ256rk = 9687, + X86_VPDPWSSDSZ256rkz = 9688, + X86_VPDPWSSDSZm = 9689, + X86_VPDPWSSDSZmb = 9690, + X86_VPDPWSSDSZmbk = 9691, + X86_VPDPWSSDSZmbkz = 9692, + X86_VPDPWSSDSZmk = 9693, + X86_VPDPWSSDSZmkz = 9694, + X86_VPDPWSSDSZr = 9695, + X86_VPDPWSSDSZrk = 9696, + X86_VPDPWSSDSZrkz = 9697, + X86_VPDPWSSDZ128m = 9698, + X86_VPDPWSSDZ128mb = 9699, + X86_VPDPWSSDZ128mbk = 9700, + X86_VPDPWSSDZ128mbkz = 9701, + X86_VPDPWSSDZ128mk = 9702, + X86_VPDPWSSDZ128mkz = 9703, + X86_VPDPWSSDZ128r = 9704, + X86_VPDPWSSDZ128rk = 9705, + X86_VPDPWSSDZ128rkz = 9706, + X86_VPDPWSSDZ256m = 9707, + X86_VPDPWSSDZ256mb = 9708, + X86_VPDPWSSDZ256mbk = 9709, + X86_VPDPWSSDZ256mbkz = 9710, + X86_VPDPWSSDZ256mk = 9711, + X86_VPDPWSSDZ256mkz = 9712, + X86_VPDPWSSDZ256r = 9713, + X86_VPDPWSSDZ256rk = 9714, + X86_VPDPWSSDZ256rkz = 9715, + X86_VPDPWSSDZm = 9716, + X86_VPDPWSSDZmb = 9717, + X86_VPDPWSSDZmbk = 9718, + X86_VPDPWSSDZmbkz = 9719, + X86_VPDPWSSDZmk = 9720, + X86_VPDPWSSDZmkz = 9721, + X86_VPDPWSSDZr = 9722, + X86_VPDPWSSDZrk = 9723, + X86_VPDPWSSDZrkz = 9724, + X86_VPERM2F128rm = 9725, + X86_VPERM2F128rr = 9726, + X86_VPERM2I128rm = 9727, + X86_VPERM2I128rr = 9728, + X86_VPERMBZ128rm = 9729, + X86_VPERMBZ128rmk = 9730, + X86_VPERMBZ128rmkz = 9731, + X86_VPERMBZ128rr = 9732, + X86_VPERMBZ128rrk = 9733, + X86_VPERMBZ128rrkz = 9734, + X86_VPERMBZ256rm = 9735, + X86_VPERMBZ256rmk = 9736, + X86_VPERMBZ256rmkz = 9737, + X86_VPERMBZ256rr = 9738, + X86_VPERMBZ256rrk = 9739, + X86_VPERMBZ256rrkz = 9740, + X86_VPERMBZrm = 9741, + X86_VPERMBZrmk = 9742, + X86_VPERMBZrmkz = 9743, + X86_VPERMBZrr = 9744, + X86_VPERMBZrrk = 9745, + X86_VPERMBZrrkz = 9746, + X86_VPERMDYrm = 9747, + X86_VPERMDYrr = 9748, + X86_VPERMDZ256rm = 9749, + X86_VPERMDZ256rmb = 9750, + X86_VPERMDZ256rmbk = 9751, + X86_VPERMDZ256rmbkz = 9752, + X86_VPERMDZ256rmk = 9753, + X86_VPERMDZ256rmkz = 9754, + X86_VPERMDZ256rr = 9755, + X86_VPERMDZ256rrk = 9756, + X86_VPERMDZ256rrkz = 9757, + X86_VPERMDZrm = 9758, + X86_VPERMDZrmb = 9759, + X86_VPERMDZrmbk = 9760, + X86_VPERMDZrmbkz = 9761, + X86_VPERMDZrmk = 9762, + X86_VPERMDZrmkz = 9763, + X86_VPERMDZrr = 9764, + X86_VPERMDZrrk = 9765, + X86_VPERMDZrrkz = 9766, + X86_VPERMI2B128rm = 9767, + X86_VPERMI2B128rmk = 9768, + X86_VPERMI2B128rmkz = 9769, + X86_VPERMI2B128rr = 9770, + X86_VPERMI2B128rrk = 9771, + X86_VPERMI2B128rrkz = 9772, + X86_VPERMI2B256rm = 9773, + X86_VPERMI2B256rmk = 9774, + X86_VPERMI2B256rmkz = 9775, + X86_VPERMI2B256rr = 9776, + X86_VPERMI2B256rrk = 9777, + X86_VPERMI2B256rrkz = 9778, + X86_VPERMI2Brm = 9779, + X86_VPERMI2Brmk = 9780, + X86_VPERMI2Brmkz = 9781, + X86_VPERMI2Brr = 9782, + X86_VPERMI2Brrk = 9783, + X86_VPERMI2Brrkz = 9784, + X86_VPERMI2D128rm = 9785, + X86_VPERMI2D128rmb = 9786, + X86_VPERMI2D128rmbk = 9787, + X86_VPERMI2D128rmbkz = 9788, + X86_VPERMI2D128rmk = 9789, + X86_VPERMI2D128rmkz = 9790, + X86_VPERMI2D128rr = 9791, + X86_VPERMI2D128rrk = 9792, + X86_VPERMI2D128rrkz = 9793, + X86_VPERMI2D256rm = 9794, + X86_VPERMI2D256rmb = 9795, + X86_VPERMI2D256rmbk = 9796, + X86_VPERMI2D256rmbkz = 9797, + X86_VPERMI2D256rmk = 9798, + X86_VPERMI2D256rmkz = 9799, + X86_VPERMI2D256rr = 9800, + X86_VPERMI2D256rrk = 9801, + X86_VPERMI2D256rrkz = 9802, + X86_VPERMI2Drm = 9803, + X86_VPERMI2Drmb = 9804, + X86_VPERMI2Drmbk = 9805, + X86_VPERMI2Drmbkz = 9806, + X86_VPERMI2Drmk = 9807, + X86_VPERMI2Drmkz = 9808, + X86_VPERMI2Drr = 9809, + X86_VPERMI2Drrk = 9810, + X86_VPERMI2Drrkz = 9811, + X86_VPERMI2PD128rm = 9812, + X86_VPERMI2PD128rmb = 9813, + X86_VPERMI2PD128rmbk = 9814, + X86_VPERMI2PD128rmbkz = 9815, + X86_VPERMI2PD128rmk = 9816, + X86_VPERMI2PD128rmkz = 9817, + X86_VPERMI2PD128rr = 9818, + X86_VPERMI2PD128rrk = 9819, + X86_VPERMI2PD128rrkz = 9820, + X86_VPERMI2PD256rm = 9821, + X86_VPERMI2PD256rmb = 9822, + X86_VPERMI2PD256rmbk = 9823, + X86_VPERMI2PD256rmbkz = 9824, + X86_VPERMI2PD256rmk = 9825, + X86_VPERMI2PD256rmkz = 9826, + X86_VPERMI2PD256rr = 9827, + X86_VPERMI2PD256rrk = 9828, + X86_VPERMI2PD256rrkz = 9829, + X86_VPERMI2PDrm = 9830, + X86_VPERMI2PDrmb = 9831, + X86_VPERMI2PDrmbk = 9832, + X86_VPERMI2PDrmbkz = 9833, + X86_VPERMI2PDrmk = 9834, + X86_VPERMI2PDrmkz = 9835, + X86_VPERMI2PDrr = 9836, + X86_VPERMI2PDrrk = 9837, + X86_VPERMI2PDrrkz = 9838, + X86_VPERMI2PS128rm = 9839, + X86_VPERMI2PS128rmb = 9840, + X86_VPERMI2PS128rmbk = 9841, + X86_VPERMI2PS128rmbkz = 9842, + X86_VPERMI2PS128rmk = 9843, + X86_VPERMI2PS128rmkz = 9844, + X86_VPERMI2PS128rr = 9845, + X86_VPERMI2PS128rrk = 9846, + X86_VPERMI2PS128rrkz = 9847, + X86_VPERMI2PS256rm = 9848, + X86_VPERMI2PS256rmb = 9849, + X86_VPERMI2PS256rmbk = 9850, + X86_VPERMI2PS256rmbkz = 9851, + X86_VPERMI2PS256rmk = 9852, + X86_VPERMI2PS256rmkz = 9853, + X86_VPERMI2PS256rr = 9854, + X86_VPERMI2PS256rrk = 9855, + X86_VPERMI2PS256rrkz = 9856, + X86_VPERMI2PSrm = 9857, + X86_VPERMI2PSrmb = 9858, + X86_VPERMI2PSrmbk = 9859, + X86_VPERMI2PSrmbkz = 9860, + X86_VPERMI2PSrmk = 9861, + X86_VPERMI2PSrmkz = 9862, + X86_VPERMI2PSrr = 9863, + X86_VPERMI2PSrrk = 9864, + X86_VPERMI2PSrrkz = 9865, + X86_VPERMI2Q128rm = 9866, + X86_VPERMI2Q128rmb = 9867, + X86_VPERMI2Q128rmbk = 9868, + X86_VPERMI2Q128rmbkz = 9869, + X86_VPERMI2Q128rmk = 9870, + X86_VPERMI2Q128rmkz = 9871, + X86_VPERMI2Q128rr = 9872, + X86_VPERMI2Q128rrk = 9873, + X86_VPERMI2Q128rrkz = 9874, + X86_VPERMI2Q256rm = 9875, + X86_VPERMI2Q256rmb = 9876, + X86_VPERMI2Q256rmbk = 9877, + X86_VPERMI2Q256rmbkz = 9878, + X86_VPERMI2Q256rmk = 9879, + X86_VPERMI2Q256rmkz = 9880, + X86_VPERMI2Q256rr = 9881, + X86_VPERMI2Q256rrk = 9882, + X86_VPERMI2Q256rrkz = 9883, + X86_VPERMI2Qrm = 9884, + X86_VPERMI2Qrmb = 9885, + X86_VPERMI2Qrmbk = 9886, + X86_VPERMI2Qrmbkz = 9887, + X86_VPERMI2Qrmk = 9888, + X86_VPERMI2Qrmkz = 9889, + X86_VPERMI2Qrr = 9890, + X86_VPERMI2Qrrk = 9891, + X86_VPERMI2Qrrkz = 9892, + X86_VPERMI2W128rm = 9893, + X86_VPERMI2W128rmk = 9894, + X86_VPERMI2W128rmkz = 9895, + X86_VPERMI2W128rr = 9896, + X86_VPERMI2W128rrk = 9897, + X86_VPERMI2W128rrkz = 9898, + X86_VPERMI2W256rm = 9899, + X86_VPERMI2W256rmk = 9900, + X86_VPERMI2W256rmkz = 9901, + X86_VPERMI2W256rr = 9902, + X86_VPERMI2W256rrk = 9903, + X86_VPERMI2W256rrkz = 9904, + X86_VPERMI2Wrm = 9905, + X86_VPERMI2Wrmk = 9906, + X86_VPERMI2Wrmkz = 9907, + X86_VPERMI2Wrr = 9908, + X86_VPERMI2Wrrk = 9909, + X86_VPERMI2Wrrkz = 9910, + X86_VPERMIL2PDYmr = 9911, + X86_VPERMIL2PDYrm = 9912, + X86_VPERMIL2PDYrr = 9913, + X86_VPERMIL2PDYrr_REV = 9914, + X86_VPERMIL2PDmr = 9915, + X86_VPERMIL2PDrm = 9916, + X86_VPERMIL2PDrr = 9917, + X86_VPERMIL2PDrr_REV = 9918, + X86_VPERMIL2PSYmr = 9919, + X86_VPERMIL2PSYrm = 9920, + X86_VPERMIL2PSYrr = 9921, + X86_VPERMIL2PSYrr_REV = 9922, + X86_VPERMIL2PSmr = 9923, + X86_VPERMIL2PSrm = 9924, + X86_VPERMIL2PSrr = 9925, + X86_VPERMIL2PSrr_REV = 9926, + X86_VPERMILPDYmi = 9927, + X86_VPERMILPDYri = 9928, + X86_VPERMILPDYrm = 9929, + X86_VPERMILPDYrr = 9930, + X86_VPERMILPDZ128mbi = 9931, + X86_VPERMILPDZ128mbik = 9932, + X86_VPERMILPDZ128mbikz = 9933, + X86_VPERMILPDZ128mi = 9934, + X86_VPERMILPDZ128mik = 9935, + X86_VPERMILPDZ128mikz = 9936, + X86_VPERMILPDZ128ri = 9937, + X86_VPERMILPDZ128rik = 9938, + X86_VPERMILPDZ128rikz = 9939, + X86_VPERMILPDZ128rm = 9940, + X86_VPERMILPDZ128rmb = 9941, + X86_VPERMILPDZ128rmbk = 9942, + X86_VPERMILPDZ128rmbkz = 9943, + X86_VPERMILPDZ128rmk = 9944, + X86_VPERMILPDZ128rmkz = 9945, + X86_VPERMILPDZ128rr = 9946, + X86_VPERMILPDZ128rrk = 9947, + X86_VPERMILPDZ128rrkz = 9948, + X86_VPERMILPDZ256mbi = 9949, + X86_VPERMILPDZ256mbik = 9950, + X86_VPERMILPDZ256mbikz = 9951, + X86_VPERMILPDZ256mi = 9952, + X86_VPERMILPDZ256mik = 9953, + X86_VPERMILPDZ256mikz = 9954, + X86_VPERMILPDZ256ri = 9955, + X86_VPERMILPDZ256rik = 9956, + X86_VPERMILPDZ256rikz = 9957, + X86_VPERMILPDZ256rm = 9958, + X86_VPERMILPDZ256rmb = 9959, + X86_VPERMILPDZ256rmbk = 9960, + X86_VPERMILPDZ256rmbkz = 9961, + X86_VPERMILPDZ256rmk = 9962, + X86_VPERMILPDZ256rmkz = 9963, + X86_VPERMILPDZ256rr = 9964, + X86_VPERMILPDZ256rrk = 9965, + X86_VPERMILPDZ256rrkz = 9966, + X86_VPERMILPDZmbi = 9967, + X86_VPERMILPDZmbik = 9968, + X86_VPERMILPDZmbikz = 9969, + X86_VPERMILPDZmi = 9970, + X86_VPERMILPDZmik = 9971, + X86_VPERMILPDZmikz = 9972, + X86_VPERMILPDZri = 9973, + X86_VPERMILPDZrik = 9974, + X86_VPERMILPDZrikz = 9975, + X86_VPERMILPDZrm = 9976, + X86_VPERMILPDZrmb = 9977, + X86_VPERMILPDZrmbk = 9978, + X86_VPERMILPDZrmbkz = 9979, + X86_VPERMILPDZrmk = 9980, + X86_VPERMILPDZrmkz = 9981, + X86_VPERMILPDZrr = 9982, + X86_VPERMILPDZrrk = 9983, + X86_VPERMILPDZrrkz = 9984, + X86_VPERMILPDmi = 9985, + X86_VPERMILPDri = 9986, + X86_VPERMILPDrm = 9987, + X86_VPERMILPDrr = 9988, + X86_VPERMILPSYmi = 9989, + X86_VPERMILPSYri = 9990, + X86_VPERMILPSYrm = 9991, + X86_VPERMILPSYrr = 9992, + X86_VPERMILPSZ128mbi = 9993, + X86_VPERMILPSZ128mbik = 9994, + X86_VPERMILPSZ128mbikz = 9995, + X86_VPERMILPSZ128mi = 9996, + X86_VPERMILPSZ128mik = 9997, + X86_VPERMILPSZ128mikz = 9998, + X86_VPERMILPSZ128ri = 9999, + X86_VPERMILPSZ128rik = 10000, + X86_VPERMILPSZ128rikz = 10001, + X86_VPERMILPSZ128rm = 10002, + X86_VPERMILPSZ128rmb = 10003, + X86_VPERMILPSZ128rmbk = 10004, + X86_VPERMILPSZ128rmbkz = 10005, + X86_VPERMILPSZ128rmk = 10006, + X86_VPERMILPSZ128rmkz = 10007, + X86_VPERMILPSZ128rr = 10008, + X86_VPERMILPSZ128rrk = 10009, + X86_VPERMILPSZ128rrkz = 10010, + X86_VPERMILPSZ256mbi = 10011, + X86_VPERMILPSZ256mbik = 10012, + X86_VPERMILPSZ256mbikz = 10013, + X86_VPERMILPSZ256mi = 10014, + X86_VPERMILPSZ256mik = 10015, + X86_VPERMILPSZ256mikz = 10016, + X86_VPERMILPSZ256ri = 10017, + X86_VPERMILPSZ256rik = 10018, + X86_VPERMILPSZ256rikz = 10019, + X86_VPERMILPSZ256rm = 10020, + X86_VPERMILPSZ256rmb = 10021, + X86_VPERMILPSZ256rmbk = 10022, + X86_VPERMILPSZ256rmbkz = 10023, + X86_VPERMILPSZ256rmk = 10024, + X86_VPERMILPSZ256rmkz = 10025, + X86_VPERMILPSZ256rr = 10026, + X86_VPERMILPSZ256rrk = 10027, + X86_VPERMILPSZ256rrkz = 10028, + X86_VPERMILPSZmbi = 10029, + X86_VPERMILPSZmbik = 10030, + X86_VPERMILPSZmbikz = 10031, + X86_VPERMILPSZmi = 10032, + X86_VPERMILPSZmik = 10033, + X86_VPERMILPSZmikz = 10034, + X86_VPERMILPSZri = 10035, + X86_VPERMILPSZrik = 10036, + X86_VPERMILPSZrikz = 10037, + X86_VPERMILPSZrm = 10038, + X86_VPERMILPSZrmb = 10039, + X86_VPERMILPSZrmbk = 10040, + X86_VPERMILPSZrmbkz = 10041, + X86_VPERMILPSZrmk = 10042, + X86_VPERMILPSZrmkz = 10043, + X86_VPERMILPSZrr = 10044, + X86_VPERMILPSZrrk = 10045, + X86_VPERMILPSZrrkz = 10046, + X86_VPERMILPSmi = 10047, + X86_VPERMILPSri = 10048, + X86_VPERMILPSrm = 10049, + X86_VPERMILPSrr = 10050, + X86_VPERMPDYmi = 10051, + X86_VPERMPDYri = 10052, + X86_VPERMPDZ256mbi = 10053, + X86_VPERMPDZ256mbik = 10054, + X86_VPERMPDZ256mbikz = 10055, + X86_VPERMPDZ256mi = 10056, + X86_VPERMPDZ256mik = 10057, + X86_VPERMPDZ256mikz = 10058, + X86_VPERMPDZ256ri = 10059, + X86_VPERMPDZ256rik = 10060, + X86_VPERMPDZ256rikz = 10061, + X86_VPERMPDZ256rm = 10062, + X86_VPERMPDZ256rmb = 10063, + X86_VPERMPDZ256rmbk = 10064, + X86_VPERMPDZ256rmbkz = 10065, + X86_VPERMPDZ256rmk = 10066, + X86_VPERMPDZ256rmkz = 10067, + X86_VPERMPDZ256rr = 10068, + X86_VPERMPDZ256rrk = 10069, + X86_VPERMPDZ256rrkz = 10070, + X86_VPERMPDZmbi = 10071, + X86_VPERMPDZmbik = 10072, + X86_VPERMPDZmbikz = 10073, + X86_VPERMPDZmi = 10074, + X86_VPERMPDZmik = 10075, + X86_VPERMPDZmikz = 10076, + X86_VPERMPDZri = 10077, + X86_VPERMPDZrik = 10078, + X86_VPERMPDZrikz = 10079, + X86_VPERMPDZrm = 10080, + X86_VPERMPDZrmb = 10081, + X86_VPERMPDZrmbk = 10082, + X86_VPERMPDZrmbkz = 10083, + X86_VPERMPDZrmk = 10084, + X86_VPERMPDZrmkz = 10085, + X86_VPERMPDZrr = 10086, + X86_VPERMPDZrrk = 10087, + X86_VPERMPDZrrkz = 10088, + X86_VPERMPSYrm = 10089, + X86_VPERMPSYrr = 10090, + X86_VPERMPSZ256rm = 10091, + X86_VPERMPSZ256rmb = 10092, + X86_VPERMPSZ256rmbk = 10093, + X86_VPERMPSZ256rmbkz = 10094, + X86_VPERMPSZ256rmk = 10095, + X86_VPERMPSZ256rmkz = 10096, + X86_VPERMPSZ256rr = 10097, + X86_VPERMPSZ256rrk = 10098, + X86_VPERMPSZ256rrkz = 10099, + X86_VPERMPSZrm = 10100, + X86_VPERMPSZrmb = 10101, + X86_VPERMPSZrmbk = 10102, + X86_VPERMPSZrmbkz = 10103, + X86_VPERMPSZrmk = 10104, + X86_VPERMPSZrmkz = 10105, + X86_VPERMPSZrr = 10106, + X86_VPERMPSZrrk = 10107, + X86_VPERMPSZrrkz = 10108, + X86_VPERMQYmi = 10109, + X86_VPERMQYri = 10110, + X86_VPERMQZ256mbi = 10111, + X86_VPERMQZ256mbik = 10112, + X86_VPERMQZ256mbikz = 10113, + X86_VPERMQZ256mi = 10114, + X86_VPERMQZ256mik = 10115, + X86_VPERMQZ256mikz = 10116, + X86_VPERMQZ256ri = 10117, + X86_VPERMQZ256rik = 10118, + X86_VPERMQZ256rikz = 10119, + X86_VPERMQZ256rm = 10120, + X86_VPERMQZ256rmb = 10121, + X86_VPERMQZ256rmbk = 10122, + X86_VPERMQZ256rmbkz = 10123, + X86_VPERMQZ256rmk = 10124, + X86_VPERMQZ256rmkz = 10125, + X86_VPERMQZ256rr = 10126, + X86_VPERMQZ256rrk = 10127, + X86_VPERMQZ256rrkz = 10128, + X86_VPERMQZmbi = 10129, + X86_VPERMQZmbik = 10130, + X86_VPERMQZmbikz = 10131, + X86_VPERMQZmi = 10132, + X86_VPERMQZmik = 10133, + X86_VPERMQZmikz = 10134, + X86_VPERMQZri = 10135, + X86_VPERMQZrik = 10136, + X86_VPERMQZrikz = 10137, + X86_VPERMQZrm = 10138, + X86_VPERMQZrmb = 10139, + X86_VPERMQZrmbk = 10140, + X86_VPERMQZrmbkz = 10141, + X86_VPERMQZrmk = 10142, + X86_VPERMQZrmkz = 10143, + X86_VPERMQZrr = 10144, + X86_VPERMQZrrk = 10145, + X86_VPERMQZrrkz = 10146, + X86_VPERMT2B128rm = 10147, + X86_VPERMT2B128rmk = 10148, + X86_VPERMT2B128rmkz = 10149, + X86_VPERMT2B128rr = 10150, + X86_VPERMT2B128rrk = 10151, + X86_VPERMT2B128rrkz = 10152, + X86_VPERMT2B256rm = 10153, + X86_VPERMT2B256rmk = 10154, + X86_VPERMT2B256rmkz = 10155, + X86_VPERMT2B256rr = 10156, + X86_VPERMT2B256rrk = 10157, + X86_VPERMT2B256rrkz = 10158, + X86_VPERMT2Brm = 10159, + X86_VPERMT2Brmk = 10160, + X86_VPERMT2Brmkz = 10161, + X86_VPERMT2Brr = 10162, + X86_VPERMT2Brrk = 10163, + X86_VPERMT2Brrkz = 10164, + X86_VPERMT2D128rm = 10165, + X86_VPERMT2D128rmb = 10166, + X86_VPERMT2D128rmbk = 10167, + X86_VPERMT2D128rmbkz = 10168, + X86_VPERMT2D128rmk = 10169, + X86_VPERMT2D128rmkz = 10170, + X86_VPERMT2D128rr = 10171, + X86_VPERMT2D128rrk = 10172, + X86_VPERMT2D128rrkz = 10173, + X86_VPERMT2D256rm = 10174, + X86_VPERMT2D256rmb = 10175, + X86_VPERMT2D256rmbk = 10176, + X86_VPERMT2D256rmbkz = 10177, + X86_VPERMT2D256rmk = 10178, + X86_VPERMT2D256rmkz = 10179, + X86_VPERMT2D256rr = 10180, + X86_VPERMT2D256rrk = 10181, + X86_VPERMT2D256rrkz = 10182, + X86_VPERMT2Drm = 10183, + X86_VPERMT2Drmb = 10184, + X86_VPERMT2Drmbk = 10185, + X86_VPERMT2Drmbkz = 10186, + X86_VPERMT2Drmk = 10187, + X86_VPERMT2Drmkz = 10188, + X86_VPERMT2Drr = 10189, + X86_VPERMT2Drrk = 10190, + X86_VPERMT2Drrkz = 10191, + X86_VPERMT2PD128rm = 10192, + X86_VPERMT2PD128rmb = 10193, + X86_VPERMT2PD128rmbk = 10194, + X86_VPERMT2PD128rmbkz = 10195, + X86_VPERMT2PD128rmk = 10196, + X86_VPERMT2PD128rmkz = 10197, + X86_VPERMT2PD128rr = 10198, + X86_VPERMT2PD128rrk = 10199, + X86_VPERMT2PD128rrkz = 10200, + X86_VPERMT2PD256rm = 10201, + X86_VPERMT2PD256rmb = 10202, + X86_VPERMT2PD256rmbk = 10203, + X86_VPERMT2PD256rmbkz = 10204, + X86_VPERMT2PD256rmk = 10205, + X86_VPERMT2PD256rmkz = 10206, + X86_VPERMT2PD256rr = 10207, + X86_VPERMT2PD256rrk = 10208, + X86_VPERMT2PD256rrkz = 10209, + X86_VPERMT2PDrm = 10210, + X86_VPERMT2PDrmb = 10211, + X86_VPERMT2PDrmbk = 10212, + X86_VPERMT2PDrmbkz = 10213, + X86_VPERMT2PDrmk = 10214, + X86_VPERMT2PDrmkz = 10215, + X86_VPERMT2PDrr = 10216, + X86_VPERMT2PDrrk = 10217, + X86_VPERMT2PDrrkz = 10218, + X86_VPERMT2PS128rm = 10219, + X86_VPERMT2PS128rmb = 10220, + X86_VPERMT2PS128rmbk = 10221, + X86_VPERMT2PS128rmbkz = 10222, + X86_VPERMT2PS128rmk = 10223, + X86_VPERMT2PS128rmkz = 10224, + X86_VPERMT2PS128rr = 10225, + X86_VPERMT2PS128rrk = 10226, + X86_VPERMT2PS128rrkz = 10227, + X86_VPERMT2PS256rm = 10228, + X86_VPERMT2PS256rmb = 10229, + X86_VPERMT2PS256rmbk = 10230, + X86_VPERMT2PS256rmbkz = 10231, + X86_VPERMT2PS256rmk = 10232, + X86_VPERMT2PS256rmkz = 10233, + X86_VPERMT2PS256rr = 10234, + X86_VPERMT2PS256rrk = 10235, + X86_VPERMT2PS256rrkz = 10236, + X86_VPERMT2PSrm = 10237, + X86_VPERMT2PSrmb = 10238, + X86_VPERMT2PSrmbk = 10239, + X86_VPERMT2PSrmbkz = 10240, + X86_VPERMT2PSrmk = 10241, + X86_VPERMT2PSrmkz = 10242, + X86_VPERMT2PSrr = 10243, + X86_VPERMT2PSrrk = 10244, + X86_VPERMT2PSrrkz = 10245, + X86_VPERMT2Q128rm = 10246, + X86_VPERMT2Q128rmb = 10247, + X86_VPERMT2Q128rmbk = 10248, + X86_VPERMT2Q128rmbkz = 10249, + X86_VPERMT2Q128rmk = 10250, + X86_VPERMT2Q128rmkz = 10251, + X86_VPERMT2Q128rr = 10252, + X86_VPERMT2Q128rrk = 10253, + X86_VPERMT2Q128rrkz = 10254, + X86_VPERMT2Q256rm = 10255, + X86_VPERMT2Q256rmb = 10256, + X86_VPERMT2Q256rmbk = 10257, + X86_VPERMT2Q256rmbkz = 10258, + X86_VPERMT2Q256rmk = 10259, + X86_VPERMT2Q256rmkz = 10260, + X86_VPERMT2Q256rr = 10261, + X86_VPERMT2Q256rrk = 10262, + X86_VPERMT2Q256rrkz = 10263, + X86_VPERMT2Qrm = 10264, + X86_VPERMT2Qrmb = 10265, + X86_VPERMT2Qrmbk = 10266, + X86_VPERMT2Qrmbkz = 10267, + X86_VPERMT2Qrmk = 10268, + X86_VPERMT2Qrmkz = 10269, + X86_VPERMT2Qrr = 10270, + X86_VPERMT2Qrrk = 10271, + X86_VPERMT2Qrrkz = 10272, + X86_VPERMT2W128rm = 10273, + X86_VPERMT2W128rmk = 10274, + X86_VPERMT2W128rmkz = 10275, + X86_VPERMT2W128rr = 10276, + X86_VPERMT2W128rrk = 10277, + X86_VPERMT2W128rrkz = 10278, + X86_VPERMT2W256rm = 10279, + X86_VPERMT2W256rmk = 10280, + X86_VPERMT2W256rmkz = 10281, + X86_VPERMT2W256rr = 10282, + X86_VPERMT2W256rrk = 10283, + X86_VPERMT2W256rrkz = 10284, + X86_VPERMT2Wrm = 10285, + X86_VPERMT2Wrmk = 10286, + X86_VPERMT2Wrmkz = 10287, + X86_VPERMT2Wrr = 10288, + X86_VPERMT2Wrrk = 10289, + X86_VPERMT2Wrrkz = 10290, + X86_VPERMWZ128rm = 10291, + X86_VPERMWZ128rmk = 10292, + X86_VPERMWZ128rmkz = 10293, + X86_VPERMWZ128rr = 10294, + X86_VPERMWZ128rrk = 10295, + X86_VPERMWZ128rrkz = 10296, + X86_VPERMWZ256rm = 10297, + X86_VPERMWZ256rmk = 10298, + X86_VPERMWZ256rmkz = 10299, + X86_VPERMWZ256rr = 10300, + X86_VPERMWZ256rrk = 10301, + X86_VPERMWZ256rrkz = 10302, + X86_VPERMWZrm = 10303, + X86_VPERMWZrmk = 10304, + X86_VPERMWZrmkz = 10305, + X86_VPERMWZrr = 10306, + X86_VPERMWZrrk = 10307, + X86_VPERMWZrrkz = 10308, + X86_VPEXPANDBZ128rm = 10309, + X86_VPEXPANDBZ128rmk = 10310, + X86_VPEXPANDBZ128rmkz = 10311, + X86_VPEXPANDBZ128rr = 10312, + X86_VPEXPANDBZ128rrk = 10313, + X86_VPEXPANDBZ128rrkz = 10314, + X86_VPEXPANDBZ256rm = 10315, + X86_VPEXPANDBZ256rmk = 10316, + X86_VPEXPANDBZ256rmkz = 10317, + X86_VPEXPANDBZ256rr = 10318, + X86_VPEXPANDBZ256rrk = 10319, + X86_VPEXPANDBZ256rrkz = 10320, + X86_VPEXPANDBZrm = 10321, + X86_VPEXPANDBZrmk = 10322, + X86_VPEXPANDBZrmkz = 10323, + X86_VPEXPANDBZrr = 10324, + X86_VPEXPANDBZrrk = 10325, + X86_VPEXPANDBZrrkz = 10326, + X86_VPEXPANDDZ128rm = 10327, + X86_VPEXPANDDZ128rmk = 10328, + X86_VPEXPANDDZ128rmkz = 10329, + X86_VPEXPANDDZ128rr = 10330, + X86_VPEXPANDDZ128rrk = 10331, + X86_VPEXPANDDZ128rrkz = 10332, + X86_VPEXPANDDZ256rm = 10333, + X86_VPEXPANDDZ256rmk = 10334, + X86_VPEXPANDDZ256rmkz = 10335, + X86_VPEXPANDDZ256rr = 10336, + X86_VPEXPANDDZ256rrk = 10337, + X86_VPEXPANDDZ256rrkz = 10338, + X86_VPEXPANDDZrm = 10339, + X86_VPEXPANDDZrmk = 10340, + X86_VPEXPANDDZrmkz = 10341, + X86_VPEXPANDDZrr = 10342, + X86_VPEXPANDDZrrk = 10343, + X86_VPEXPANDDZrrkz = 10344, + X86_VPEXPANDQZ128rm = 10345, + X86_VPEXPANDQZ128rmk = 10346, + X86_VPEXPANDQZ128rmkz = 10347, + X86_VPEXPANDQZ128rr = 10348, + X86_VPEXPANDQZ128rrk = 10349, + X86_VPEXPANDQZ128rrkz = 10350, + X86_VPEXPANDQZ256rm = 10351, + X86_VPEXPANDQZ256rmk = 10352, + X86_VPEXPANDQZ256rmkz = 10353, + X86_VPEXPANDQZ256rr = 10354, + X86_VPEXPANDQZ256rrk = 10355, + X86_VPEXPANDQZ256rrkz = 10356, + X86_VPEXPANDQZrm = 10357, + X86_VPEXPANDQZrmk = 10358, + X86_VPEXPANDQZrmkz = 10359, + X86_VPEXPANDQZrr = 10360, + X86_VPEXPANDQZrrk = 10361, + X86_VPEXPANDQZrrkz = 10362, + X86_VPEXPANDWZ128rm = 10363, + X86_VPEXPANDWZ128rmk = 10364, + X86_VPEXPANDWZ128rmkz = 10365, + X86_VPEXPANDWZ128rr = 10366, + X86_VPEXPANDWZ128rrk = 10367, + X86_VPEXPANDWZ128rrkz = 10368, + X86_VPEXPANDWZ256rm = 10369, + X86_VPEXPANDWZ256rmk = 10370, + X86_VPEXPANDWZ256rmkz = 10371, + X86_VPEXPANDWZ256rr = 10372, + X86_VPEXPANDWZ256rrk = 10373, + X86_VPEXPANDWZ256rrkz = 10374, + X86_VPEXPANDWZrm = 10375, + X86_VPEXPANDWZrmk = 10376, + X86_VPEXPANDWZrmkz = 10377, + X86_VPEXPANDWZrr = 10378, + X86_VPEXPANDWZrrk = 10379, + X86_VPEXPANDWZrrkz = 10380, + X86_VPEXTRBZmr = 10381, + X86_VPEXTRBZrr = 10382, + X86_VPEXTRBmr = 10383, + X86_VPEXTRBrr = 10384, + X86_VPEXTRDZmr = 10385, + X86_VPEXTRDZrr = 10386, + X86_VPEXTRDmr = 10387, + X86_VPEXTRDrr = 10388, + X86_VPEXTRQZmr = 10389, + X86_VPEXTRQZrr = 10390, + X86_VPEXTRQmr = 10391, + X86_VPEXTRQrr = 10392, + X86_VPEXTRWZmr = 10393, + X86_VPEXTRWZrr = 10394, + X86_VPEXTRWZrr_REV = 10395, + X86_VPEXTRWmr = 10396, + X86_VPEXTRWrr = 10397, + X86_VPEXTRWrr_REV = 10398, + X86_VPGATHERDDYrm = 10399, + X86_VPGATHERDDZ128rm = 10400, + X86_VPGATHERDDZ256rm = 10401, + X86_VPGATHERDDZrm = 10402, + X86_VPGATHERDDrm = 10403, + X86_VPGATHERDQYrm = 10404, + X86_VPGATHERDQZ128rm = 10405, + X86_VPGATHERDQZ256rm = 10406, + X86_VPGATHERDQZrm = 10407, + X86_VPGATHERDQrm = 10408, + X86_VPGATHERQDYrm = 10409, + X86_VPGATHERQDZ128rm = 10410, + X86_VPGATHERQDZ256rm = 10411, + X86_VPGATHERQDZrm = 10412, + X86_VPGATHERQDrm = 10413, + X86_VPGATHERQQYrm = 10414, + X86_VPGATHERQQZ128rm = 10415, + X86_VPGATHERQQZ256rm = 10416, + X86_VPGATHERQQZrm = 10417, + X86_VPGATHERQQrm = 10418, + X86_VPHADDBDrm = 10419, + X86_VPHADDBDrr = 10420, + X86_VPHADDBQrm = 10421, + X86_VPHADDBQrr = 10422, + X86_VPHADDBWrm = 10423, + X86_VPHADDBWrr = 10424, + X86_VPHADDDQrm = 10425, + X86_VPHADDDQrr = 10426, + X86_VPHADDDYrm = 10427, + X86_VPHADDDYrr = 10428, + X86_VPHADDDrm = 10429, + X86_VPHADDDrr = 10430, + X86_VPHADDSWYrm = 10431, + X86_VPHADDSWYrr = 10432, + X86_VPHADDSWrm = 10433, + X86_VPHADDSWrr = 10434, + X86_VPHADDUBDrm = 10435, + X86_VPHADDUBDrr = 10436, + X86_VPHADDUBQrm = 10437, + X86_VPHADDUBQrr = 10438, + X86_VPHADDUBWrm = 10439, + X86_VPHADDUBWrr = 10440, + X86_VPHADDUDQrm = 10441, + X86_VPHADDUDQrr = 10442, + X86_VPHADDUWDrm = 10443, + X86_VPHADDUWDrr = 10444, + X86_VPHADDUWQrm = 10445, + X86_VPHADDUWQrr = 10446, + X86_VPHADDWDrm = 10447, + X86_VPHADDWDrr = 10448, + X86_VPHADDWQrm = 10449, + X86_VPHADDWQrr = 10450, + X86_VPHADDWYrm = 10451, + X86_VPHADDWYrr = 10452, + X86_VPHADDWrm = 10453, + X86_VPHADDWrr = 10454, + X86_VPHMINPOSUWrm = 10455, + X86_VPHMINPOSUWrr = 10456, + X86_VPHSUBBWrm = 10457, + X86_VPHSUBBWrr = 10458, + X86_VPHSUBDQrm = 10459, + X86_VPHSUBDQrr = 10460, + X86_VPHSUBDYrm = 10461, + X86_VPHSUBDYrr = 10462, + X86_VPHSUBDrm = 10463, + X86_VPHSUBDrr = 10464, + X86_VPHSUBSWYrm = 10465, + X86_VPHSUBSWYrr = 10466, + X86_VPHSUBSWrm = 10467, + X86_VPHSUBSWrr = 10468, + X86_VPHSUBWDrm = 10469, + X86_VPHSUBWDrr = 10470, + X86_VPHSUBWYrm = 10471, + X86_VPHSUBWYrr = 10472, + X86_VPHSUBWrm = 10473, + X86_VPHSUBWrr = 10474, + X86_VPINSRBZrm = 10475, + X86_VPINSRBZrr = 10476, + X86_VPINSRBrm = 10477, + X86_VPINSRBrr = 10478, + X86_VPINSRDZrm = 10479, + X86_VPINSRDZrr = 10480, + X86_VPINSRDrm = 10481, + X86_VPINSRDrr = 10482, + X86_VPINSRQZrm = 10483, + X86_VPINSRQZrr = 10484, + X86_VPINSRQrm = 10485, + X86_VPINSRQrr = 10486, + X86_VPINSRWZrm = 10487, + X86_VPINSRWZrr = 10488, + X86_VPINSRWrm = 10489, + X86_VPINSRWrr = 10490, + X86_VPLZCNTDZ128rm = 10491, + X86_VPLZCNTDZ128rmb = 10492, + X86_VPLZCNTDZ128rmbk = 10493, + X86_VPLZCNTDZ128rmbkz = 10494, + X86_VPLZCNTDZ128rmk = 10495, + X86_VPLZCNTDZ128rmkz = 10496, + X86_VPLZCNTDZ128rr = 10497, + X86_VPLZCNTDZ128rrk = 10498, + X86_VPLZCNTDZ128rrkz = 10499, + X86_VPLZCNTDZ256rm = 10500, + X86_VPLZCNTDZ256rmb = 10501, + X86_VPLZCNTDZ256rmbk = 10502, + X86_VPLZCNTDZ256rmbkz = 10503, + X86_VPLZCNTDZ256rmk = 10504, + X86_VPLZCNTDZ256rmkz = 10505, + X86_VPLZCNTDZ256rr = 10506, + X86_VPLZCNTDZ256rrk = 10507, + X86_VPLZCNTDZ256rrkz = 10508, + X86_VPLZCNTDZrm = 10509, + X86_VPLZCNTDZrmb = 10510, + X86_VPLZCNTDZrmbk = 10511, + X86_VPLZCNTDZrmbkz = 10512, + X86_VPLZCNTDZrmk = 10513, + X86_VPLZCNTDZrmkz = 10514, + X86_VPLZCNTDZrr = 10515, + X86_VPLZCNTDZrrk = 10516, + X86_VPLZCNTDZrrkz = 10517, + X86_VPLZCNTQZ128rm = 10518, + X86_VPLZCNTQZ128rmb = 10519, + X86_VPLZCNTQZ128rmbk = 10520, + X86_VPLZCNTQZ128rmbkz = 10521, + X86_VPLZCNTQZ128rmk = 10522, + X86_VPLZCNTQZ128rmkz = 10523, + X86_VPLZCNTQZ128rr = 10524, + X86_VPLZCNTQZ128rrk = 10525, + X86_VPLZCNTQZ128rrkz = 10526, + X86_VPLZCNTQZ256rm = 10527, + X86_VPLZCNTQZ256rmb = 10528, + X86_VPLZCNTQZ256rmbk = 10529, + X86_VPLZCNTQZ256rmbkz = 10530, + X86_VPLZCNTQZ256rmk = 10531, + X86_VPLZCNTQZ256rmkz = 10532, + X86_VPLZCNTQZ256rr = 10533, + X86_VPLZCNTQZ256rrk = 10534, + X86_VPLZCNTQZ256rrkz = 10535, + X86_VPLZCNTQZrm = 10536, + X86_VPLZCNTQZrmb = 10537, + X86_VPLZCNTQZrmbk = 10538, + X86_VPLZCNTQZrmbkz = 10539, + X86_VPLZCNTQZrmk = 10540, + X86_VPLZCNTQZrmkz = 10541, + X86_VPLZCNTQZrr = 10542, + X86_VPLZCNTQZrrk = 10543, + X86_VPLZCNTQZrrkz = 10544, + X86_VPMACSDDrm = 10545, + X86_VPMACSDDrr = 10546, + X86_VPMACSDQHrm = 10547, + X86_VPMACSDQHrr = 10548, + X86_VPMACSDQLrm = 10549, + X86_VPMACSDQLrr = 10550, + X86_VPMACSSDDrm = 10551, + X86_VPMACSSDDrr = 10552, + X86_VPMACSSDQHrm = 10553, + X86_VPMACSSDQHrr = 10554, + X86_VPMACSSDQLrm = 10555, + X86_VPMACSSDQLrr = 10556, + X86_VPMACSSWDrm = 10557, + X86_VPMACSSWDrr = 10558, + X86_VPMACSSWWrm = 10559, + X86_VPMACSSWWrr = 10560, + X86_VPMACSWDrm = 10561, + X86_VPMACSWDrr = 10562, + X86_VPMACSWWrm = 10563, + X86_VPMACSWWrr = 10564, + X86_VPMADCSSWDrm = 10565, + X86_VPMADCSSWDrr = 10566, + X86_VPMADCSWDrm = 10567, + X86_VPMADCSWDrr = 10568, + X86_VPMADD52HUQZ128m = 10569, + X86_VPMADD52HUQZ128mb = 10570, + X86_VPMADD52HUQZ128mbk = 10571, + X86_VPMADD52HUQZ128mbkz = 10572, + X86_VPMADD52HUQZ128mk = 10573, + X86_VPMADD52HUQZ128mkz = 10574, + X86_VPMADD52HUQZ128r = 10575, + X86_VPMADD52HUQZ128rk = 10576, + X86_VPMADD52HUQZ128rkz = 10577, + X86_VPMADD52HUQZ256m = 10578, + X86_VPMADD52HUQZ256mb = 10579, + X86_VPMADD52HUQZ256mbk = 10580, + X86_VPMADD52HUQZ256mbkz = 10581, + X86_VPMADD52HUQZ256mk = 10582, + X86_VPMADD52HUQZ256mkz = 10583, + X86_VPMADD52HUQZ256r = 10584, + X86_VPMADD52HUQZ256rk = 10585, + X86_VPMADD52HUQZ256rkz = 10586, + X86_VPMADD52HUQZm = 10587, + X86_VPMADD52HUQZmb = 10588, + X86_VPMADD52HUQZmbk = 10589, + X86_VPMADD52HUQZmbkz = 10590, + X86_VPMADD52HUQZmk = 10591, + X86_VPMADD52HUQZmkz = 10592, + X86_VPMADD52HUQZr = 10593, + X86_VPMADD52HUQZrk = 10594, + X86_VPMADD52HUQZrkz = 10595, + X86_VPMADD52LUQZ128m = 10596, + X86_VPMADD52LUQZ128mb = 10597, + X86_VPMADD52LUQZ128mbk = 10598, + X86_VPMADD52LUQZ128mbkz = 10599, + X86_VPMADD52LUQZ128mk = 10600, + X86_VPMADD52LUQZ128mkz = 10601, + X86_VPMADD52LUQZ128r = 10602, + X86_VPMADD52LUQZ128rk = 10603, + X86_VPMADD52LUQZ128rkz = 10604, + X86_VPMADD52LUQZ256m = 10605, + X86_VPMADD52LUQZ256mb = 10606, + X86_VPMADD52LUQZ256mbk = 10607, + X86_VPMADD52LUQZ256mbkz = 10608, + X86_VPMADD52LUQZ256mk = 10609, + X86_VPMADD52LUQZ256mkz = 10610, + X86_VPMADD52LUQZ256r = 10611, + X86_VPMADD52LUQZ256rk = 10612, + X86_VPMADD52LUQZ256rkz = 10613, + X86_VPMADD52LUQZm = 10614, + X86_VPMADD52LUQZmb = 10615, + X86_VPMADD52LUQZmbk = 10616, + X86_VPMADD52LUQZmbkz = 10617, + X86_VPMADD52LUQZmk = 10618, + X86_VPMADD52LUQZmkz = 10619, + X86_VPMADD52LUQZr = 10620, + X86_VPMADD52LUQZrk = 10621, + X86_VPMADD52LUQZrkz = 10622, + X86_VPMADDUBSWYrm = 10623, + X86_VPMADDUBSWYrr = 10624, + X86_VPMADDUBSWZ128rm = 10625, + X86_VPMADDUBSWZ128rmk = 10626, + X86_VPMADDUBSWZ128rmkz = 10627, + X86_VPMADDUBSWZ128rr = 10628, + X86_VPMADDUBSWZ128rrk = 10629, + X86_VPMADDUBSWZ128rrkz = 10630, + X86_VPMADDUBSWZ256rm = 10631, + X86_VPMADDUBSWZ256rmk = 10632, + X86_VPMADDUBSWZ256rmkz = 10633, + X86_VPMADDUBSWZ256rr = 10634, + X86_VPMADDUBSWZ256rrk = 10635, + X86_VPMADDUBSWZ256rrkz = 10636, + X86_VPMADDUBSWZrm = 10637, + X86_VPMADDUBSWZrmk = 10638, + X86_VPMADDUBSWZrmkz = 10639, + X86_VPMADDUBSWZrr = 10640, + X86_VPMADDUBSWZrrk = 10641, + X86_VPMADDUBSWZrrkz = 10642, + X86_VPMADDUBSWrm = 10643, + X86_VPMADDUBSWrr = 10644, + X86_VPMADDWDYrm = 10645, + X86_VPMADDWDYrr = 10646, + X86_VPMADDWDZ128rm = 10647, + X86_VPMADDWDZ128rmk = 10648, + X86_VPMADDWDZ128rmkz = 10649, + X86_VPMADDWDZ128rr = 10650, + X86_VPMADDWDZ128rrk = 10651, + X86_VPMADDWDZ128rrkz = 10652, + X86_VPMADDWDZ256rm = 10653, + X86_VPMADDWDZ256rmk = 10654, + X86_VPMADDWDZ256rmkz = 10655, + X86_VPMADDWDZ256rr = 10656, + X86_VPMADDWDZ256rrk = 10657, + X86_VPMADDWDZ256rrkz = 10658, + X86_VPMADDWDZrm = 10659, + X86_VPMADDWDZrmk = 10660, + X86_VPMADDWDZrmkz = 10661, + X86_VPMADDWDZrr = 10662, + X86_VPMADDWDZrrk = 10663, + X86_VPMADDWDZrrkz = 10664, + X86_VPMADDWDrm = 10665, + X86_VPMADDWDrr = 10666, + X86_VPMASKMOVDYmr = 10667, + X86_VPMASKMOVDYrm = 10668, + X86_VPMASKMOVDmr = 10669, + X86_VPMASKMOVDrm = 10670, + X86_VPMASKMOVQYmr = 10671, + X86_VPMASKMOVQYrm = 10672, + X86_VPMASKMOVQmr = 10673, + X86_VPMASKMOVQrm = 10674, + X86_VPMAXSBYrm = 10675, + X86_VPMAXSBYrr = 10676, + X86_VPMAXSBZ128rm = 10677, + X86_VPMAXSBZ128rmk = 10678, + X86_VPMAXSBZ128rmkz = 10679, + X86_VPMAXSBZ128rr = 10680, + X86_VPMAXSBZ128rrk = 10681, + X86_VPMAXSBZ128rrkz = 10682, + X86_VPMAXSBZ256rm = 10683, + X86_VPMAXSBZ256rmk = 10684, + X86_VPMAXSBZ256rmkz = 10685, + X86_VPMAXSBZ256rr = 10686, + X86_VPMAXSBZ256rrk = 10687, + X86_VPMAXSBZ256rrkz = 10688, + X86_VPMAXSBZrm = 10689, + X86_VPMAXSBZrmk = 10690, + X86_VPMAXSBZrmkz = 10691, + X86_VPMAXSBZrr = 10692, + X86_VPMAXSBZrrk = 10693, + X86_VPMAXSBZrrkz = 10694, + X86_VPMAXSBrm = 10695, + X86_VPMAXSBrr = 10696, + X86_VPMAXSDYrm = 10697, + X86_VPMAXSDYrr = 10698, + X86_VPMAXSDZ128rm = 10699, + X86_VPMAXSDZ128rmb = 10700, + X86_VPMAXSDZ128rmbk = 10701, + X86_VPMAXSDZ128rmbkz = 10702, + X86_VPMAXSDZ128rmk = 10703, + X86_VPMAXSDZ128rmkz = 10704, + X86_VPMAXSDZ128rr = 10705, + X86_VPMAXSDZ128rrk = 10706, + X86_VPMAXSDZ128rrkz = 10707, + X86_VPMAXSDZ256rm = 10708, + X86_VPMAXSDZ256rmb = 10709, + X86_VPMAXSDZ256rmbk = 10710, + X86_VPMAXSDZ256rmbkz = 10711, + X86_VPMAXSDZ256rmk = 10712, + X86_VPMAXSDZ256rmkz = 10713, + X86_VPMAXSDZ256rr = 10714, + X86_VPMAXSDZ256rrk = 10715, + X86_VPMAXSDZ256rrkz = 10716, + X86_VPMAXSDZrm = 10717, + X86_VPMAXSDZrmb = 10718, + X86_VPMAXSDZrmbk = 10719, + X86_VPMAXSDZrmbkz = 10720, + X86_VPMAXSDZrmk = 10721, + X86_VPMAXSDZrmkz = 10722, + X86_VPMAXSDZrr = 10723, + X86_VPMAXSDZrrk = 10724, + X86_VPMAXSDZrrkz = 10725, + X86_VPMAXSDrm = 10726, + X86_VPMAXSDrr = 10727, + X86_VPMAXSQZ128rm = 10728, + X86_VPMAXSQZ128rmb = 10729, + X86_VPMAXSQZ128rmbk = 10730, + X86_VPMAXSQZ128rmbkz = 10731, + X86_VPMAXSQZ128rmk = 10732, + X86_VPMAXSQZ128rmkz = 10733, + X86_VPMAXSQZ128rr = 10734, + X86_VPMAXSQZ128rrk = 10735, + X86_VPMAXSQZ128rrkz = 10736, + X86_VPMAXSQZ256rm = 10737, + X86_VPMAXSQZ256rmb = 10738, + X86_VPMAXSQZ256rmbk = 10739, + X86_VPMAXSQZ256rmbkz = 10740, + X86_VPMAXSQZ256rmk = 10741, + X86_VPMAXSQZ256rmkz = 10742, + X86_VPMAXSQZ256rr = 10743, + X86_VPMAXSQZ256rrk = 10744, + X86_VPMAXSQZ256rrkz = 10745, + X86_VPMAXSQZrm = 10746, + X86_VPMAXSQZrmb = 10747, + X86_VPMAXSQZrmbk = 10748, + X86_VPMAXSQZrmbkz = 10749, + X86_VPMAXSQZrmk = 10750, + X86_VPMAXSQZrmkz = 10751, + X86_VPMAXSQZrr = 10752, + X86_VPMAXSQZrrk = 10753, + X86_VPMAXSQZrrkz = 10754, + X86_VPMAXSWYrm = 10755, + X86_VPMAXSWYrr = 10756, + X86_VPMAXSWZ128rm = 10757, + X86_VPMAXSWZ128rmk = 10758, + X86_VPMAXSWZ128rmkz = 10759, + X86_VPMAXSWZ128rr = 10760, + X86_VPMAXSWZ128rrk = 10761, + X86_VPMAXSWZ128rrkz = 10762, + X86_VPMAXSWZ256rm = 10763, + X86_VPMAXSWZ256rmk = 10764, + X86_VPMAXSWZ256rmkz = 10765, + X86_VPMAXSWZ256rr = 10766, + X86_VPMAXSWZ256rrk = 10767, + X86_VPMAXSWZ256rrkz = 10768, + X86_VPMAXSWZrm = 10769, + X86_VPMAXSWZrmk = 10770, + X86_VPMAXSWZrmkz = 10771, + X86_VPMAXSWZrr = 10772, + X86_VPMAXSWZrrk = 10773, + X86_VPMAXSWZrrkz = 10774, + X86_VPMAXSWrm = 10775, + X86_VPMAXSWrr = 10776, + X86_VPMAXUBYrm = 10777, + X86_VPMAXUBYrr = 10778, + X86_VPMAXUBZ128rm = 10779, + X86_VPMAXUBZ128rmk = 10780, + X86_VPMAXUBZ128rmkz = 10781, + X86_VPMAXUBZ128rr = 10782, + X86_VPMAXUBZ128rrk = 10783, + X86_VPMAXUBZ128rrkz = 10784, + X86_VPMAXUBZ256rm = 10785, + X86_VPMAXUBZ256rmk = 10786, + X86_VPMAXUBZ256rmkz = 10787, + X86_VPMAXUBZ256rr = 10788, + X86_VPMAXUBZ256rrk = 10789, + X86_VPMAXUBZ256rrkz = 10790, + X86_VPMAXUBZrm = 10791, + X86_VPMAXUBZrmk = 10792, + X86_VPMAXUBZrmkz = 10793, + X86_VPMAXUBZrr = 10794, + X86_VPMAXUBZrrk = 10795, + X86_VPMAXUBZrrkz = 10796, + X86_VPMAXUBrm = 10797, + X86_VPMAXUBrr = 10798, + X86_VPMAXUDYrm = 10799, + X86_VPMAXUDYrr = 10800, + X86_VPMAXUDZ128rm = 10801, + X86_VPMAXUDZ128rmb = 10802, + X86_VPMAXUDZ128rmbk = 10803, + X86_VPMAXUDZ128rmbkz = 10804, + X86_VPMAXUDZ128rmk = 10805, + X86_VPMAXUDZ128rmkz = 10806, + X86_VPMAXUDZ128rr = 10807, + X86_VPMAXUDZ128rrk = 10808, + X86_VPMAXUDZ128rrkz = 10809, + X86_VPMAXUDZ256rm = 10810, + X86_VPMAXUDZ256rmb = 10811, + X86_VPMAXUDZ256rmbk = 10812, + X86_VPMAXUDZ256rmbkz = 10813, + X86_VPMAXUDZ256rmk = 10814, + X86_VPMAXUDZ256rmkz = 10815, + X86_VPMAXUDZ256rr = 10816, + X86_VPMAXUDZ256rrk = 10817, + X86_VPMAXUDZ256rrkz = 10818, + X86_VPMAXUDZrm = 10819, + X86_VPMAXUDZrmb = 10820, + X86_VPMAXUDZrmbk = 10821, + X86_VPMAXUDZrmbkz = 10822, + X86_VPMAXUDZrmk = 10823, + X86_VPMAXUDZrmkz = 10824, + X86_VPMAXUDZrr = 10825, + X86_VPMAXUDZrrk = 10826, + X86_VPMAXUDZrrkz = 10827, + X86_VPMAXUDrm = 10828, + X86_VPMAXUDrr = 10829, + X86_VPMAXUQZ128rm = 10830, + X86_VPMAXUQZ128rmb = 10831, + X86_VPMAXUQZ128rmbk = 10832, + X86_VPMAXUQZ128rmbkz = 10833, + X86_VPMAXUQZ128rmk = 10834, + X86_VPMAXUQZ128rmkz = 10835, + X86_VPMAXUQZ128rr = 10836, + X86_VPMAXUQZ128rrk = 10837, + X86_VPMAXUQZ128rrkz = 10838, + X86_VPMAXUQZ256rm = 10839, + X86_VPMAXUQZ256rmb = 10840, + X86_VPMAXUQZ256rmbk = 10841, + X86_VPMAXUQZ256rmbkz = 10842, + X86_VPMAXUQZ256rmk = 10843, + X86_VPMAXUQZ256rmkz = 10844, + X86_VPMAXUQZ256rr = 10845, + X86_VPMAXUQZ256rrk = 10846, + X86_VPMAXUQZ256rrkz = 10847, + X86_VPMAXUQZrm = 10848, + X86_VPMAXUQZrmb = 10849, + X86_VPMAXUQZrmbk = 10850, + X86_VPMAXUQZrmbkz = 10851, + X86_VPMAXUQZrmk = 10852, + X86_VPMAXUQZrmkz = 10853, + X86_VPMAXUQZrr = 10854, + X86_VPMAXUQZrrk = 10855, + X86_VPMAXUQZrrkz = 10856, + X86_VPMAXUWYrm = 10857, + X86_VPMAXUWYrr = 10858, + X86_VPMAXUWZ128rm = 10859, + X86_VPMAXUWZ128rmk = 10860, + X86_VPMAXUWZ128rmkz = 10861, + X86_VPMAXUWZ128rr = 10862, + X86_VPMAXUWZ128rrk = 10863, + X86_VPMAXUWZ128rrkz = 10864, + X86_VPMAXUWZ256rm = 10865, + X86_VPMAXUWZ256rmk = 10866, + X86_VPMAXUWZ256rmkz = 10867, + X86_VPMAXUWZ256rr = 10868, + X86_VPMAXUWZ256rrk = 10869, + X86_VPMAXUWZ256rrkz = 10870, + X86_VPMAXUWZrm = 10871, + X86_VPMAXUWZrmk = 10872, + X86_VPMAXUWZrmkz = 10873, + X86_VPMAXUWZrr = 10874, + X86_VPMAXUWZrrk = 10875, + X86_VPMAXUWZrrkz = 10876, + X86_VPMAXUWrm = 10877, + X86_VPMAXUWrr = 10878, + X86_VPMINSBYrm = 10879, + X86_VPMINSBYrr = 10880, + X86_VPMINSBZ128rm = 10881, + X86_VPMINSBZ128rmk = 10882, + X86_VPMINSBZ128rmkz = 10883, + X86_VPMINSBZ128rr = 10884, + X86_VPMINSBZ128rrk = 10885, + X86_VPMINSBZ128rrkz = 10886, + X86_VPMINSBZ256rm = 10887, + X86_VPMINSBZ256rmk = 10888, + X86_VPMINSBZ256rmkz = 10889, + X86_VPMINSBZ256rr = 10890, + X86_VPMINSBZ256rrk = 10891, + X86_VPMINSBZ256rrkz = 10892, + X86_VPMINSBZrm = 10893, + X86_VPMINSBZrmk = 10894, + X86_VPMINSBZrmkz = 10895, + X86_VPMINSBZrr = 10896, + X86_VPMINSBZrrk = 10897, + X86_VPMINSBZrrkz = 10898, + X86_VPMINSBrm = 10899, + X86_VPMINSBrr = 10900, + X86_VPMINSDYrm = 10901, + X86_VPMINSDYrr = 10902, + X86_VPMINSDZ128rm = 10903, + X86_VPMINSDZ128rmb = 10904, + X86_VPMINSDZ128rmbk = 10905, + X86_VPMINSDZ128rmbkz = 10906, + X86_VPMINSDZ128rmk = 10907, + X86_VPMINSDZ128rmkz = 10908, + X86_VPMINSDZ128rr = 10909, + X86_VPMINSDZ128rrk = 10910, + X86_VPMINSDZ128rrkz = 10911, + X86_VPMINSDZ256rm = 10912, + X86_VPMINSDZ256rmb = 10913, + X86_VPMINSDZ256rmbk = 10914, + X86_VPMINSDZ256rmbkz = 10915, + X86_VPMINSDZ256rmk = 10916, + X86_VPMINSDZ256rmkz = 10917, + X86_VPMINSDZ256rr = 10918, + X86_VPMINSDZ256rrk = 10919, + X86_VPMINSDZ256rrkz = 10920, + X86_VPMINSDZrm = 10921, + X86_VPMINSDZrmb = 10922, + X86_VPMINSDZrmbk = 10923, + X86_VPMINSDZrmbkz = 10924, + X86_VPMINSDZrmk = 10925, + X86_VPMINSDZrmkz = 10926, + X86_VPMINSDZrr = 10927, + X86_VPMINSDZrrk = 10928, + X86_VPMINSDZrrkz = 10929, + X86_VPMINSDrm = 10930, + X86_VPMINSDrr = 10931, + X86_VPMINSQZ128rm = 10932, + X86_VPMINSQZ128rmb = 10933, + X86_VPMINSQZ128rmbk = 10934, + X86_VPMINSQZ128rmbkz = 10935, + X86_VPMINSQZ128rmk = 10936, + X86_VPMINSQZ128rmkz = 10937, + X86_VPMINSQZ128rr = 10938, + X86_VPMINSQZ128rrk = 10939, + X86_VPMINSQZ128rrkz = 10940, + X86_VPMINSQZ256rm = 10941, + X86_VPMINSQZ256rmb = 10942, + X86_VPMINSQZ256rmbk = 10943, + X86_VPMINSQZ256rmbkz = 10944, + X86_VPMINSQZ256rmk = 10945, + X86_VPMINSQZ256rmkz = 10946, + X86_VPMINSQZ256rr = 10947, + X86_VPMINSQZ256rrk = 10948, + X86_VPMINSQZ256rrkz = 10949, + X86_VPMINSQZrm = 10950, + X86_VPMINSQZrmb = 10951, + X86_VPMINSQZrmbk = 10952, + X86_VPMINSQZrmbkz = 10953, + X86_VPMINSQZrmk = 10954, + X86_VPMINSQZrmkz = 10955, + X86_VPMINSQZrr = 10956, + X86_VPMINSQZrrk = 10957, + X86_VPMINSQZrrkz = 10958, + X86_VPMINSWYrm = 10959, + X86_VPMINSWYrr = 10960, + X86_VPMINSWZ128rm = 10961, + X86_VPMINSWZ128rmk = 10962, + X86_VPMINSWZ128rmkz = 10963, + X86_VPMINSWZ128rr = 10964, + X86_VPMINSWZ128rrk = 10965, + X86_VPMINSWZ128rrkz = 10966, + X86_VPMINSWZ256rm = 10967, + X86_VPMINSWZ256rmk = 10968, + X86_VPMINSWZ256rmkz = 10969, + X86_VPMINSWZ256rr = 10970, + X86_VPMINSWZ256rrk = 10971, + X86_VPMINSWZ256rrkz = 10972, + X86_VPMINSWZrm = 10973, + X86_VPMINSWZrmk = 10974, + X86_VPMINSWZrmkz = 10975, + X86_VPMINSWZrr = 10976, + X86_VPMINSWZrrk = 10977, + X86_VPMINSWZrrkz = 10978, + X86_VPMINSWrm = 10979, + X86_VPMINSWrr = 10980, + X86_VPMINUBYrm = 10981, + X86_VPMINUBYrr = 10982, + X86_VPMINUBZ128rm = 10983, + X86_VPMINUBZ128rmk = 10984, + X86_VPMINUBZ128rmkz = 10985, + X86_VPMINUBZ128rr = 10986, + X86_VPMINUBZ128rrk = 10987, + X86_VPMINUBZ128rrkz = 10988, + X86_VPMINUBZ256rm = 10989, + X86_VPMINUBZ256rmk = 10990, + X86_VPMINUBZ256rmkz = 10991, + X86_VPMINUBZ256rr = 10992, + X86_VPMINUBZ256rrk = 10993, + X86_VPMINUBZ256rrkz = 10994, + X86_VPMINUBZrm = 10995, + X86_VPMINUBZrmk = 10996, + X86_VPMINUBZrmkz = 10997, + X86_VPMINUBZrr = 10998, + X86_VPMINUBZrrk = 10999, + X86_VPMINUBZrrkz = 11000, + X86_VPMINUBrm = 11001, + X86_VPMINUBrr = 11002, + X86_VPMINUDYrm = 11003, + X86_VPMINUDYrr = 11004, + X86_VPMINUDZ128rm = 11005, + X86_VPMINUDZ128rmb = 11006, + X86_VPMINUDZ128rmbk = 11007, + X86_VPMINUDZ128rmbkz = 11008, + X86_VPMINUDZ128rmk = 11009, + X86_VPMINUDZ128rmkz = 11010, + X86_VPMINUDZ128rr = 11011, + X86_VPMINUDZ128rrk = 11012, + X86_VPMINUDZ128rrkz = 11013, + X86_VPMINUDZ256rm = 11014, + X86_VPMINUDZ256rmb = 11015, + X86_VPMINUDZ256rmbk = 11016, + X86_VPMINUDZ256rmbkz = 11017, + X86_VPMINUDZ256rmk = 11018, + X86_VPMINUDZ256rmkz = 11019, + X86_VPMINUDZ256rr = 11020, + X86_VPMINUDZ256rrk = 11021, + X86_VPMINUDZ256rrkz = 11022, + X86_VPMINUDZrm = 11023, + X86_VPMINUDZrmb = 11024, + X86_VPMINUDZrmbk = 11025, + X86_VPMINUDZrmbkz = 11026, + X86_VPMINUDZrmk = 11027, + X86_VPMINUDZrmkz = 11028, + X86_VPMINUDZrr = 11029, + X86_VPMINUDZrrk = 11030, + X86_VPMINUDZrrkz = 11031, + X86_VPMINUDrm = 11032, + X86_VPMINUDrr = 11033, + X86_VPMINUQZ128rm = 11034, + X86_VPMINUQZ128rmb = 11035, + X86_VPMINUQZ128rmbk = 11036, + X86_VPMINUQZ128rmbkz = 11037, + X86_VPMINUQZ128rmk = 11038, + X86_VPMINUQZ128rmkz = 11039, + X86_VPMINUQZ128rr = 11040, + X86_VPMINUQZ128rrk = 11041, + X86_VPMINUQZ128rrkz = 11042, + X86_VPMINUQZ256rm = 11043, + X86_VPMINUQZ256rmb = 11044, + X86_VPMINUQZ256rmbk = 11045, + X86_VPMINUQZ256rmbkz = 11046, + X86_VPMINUQZ256rmk = 11047, + X86_VPMINUQZ256rmkz = 11048, + X86_VPMINUQZ256rr = 11049, + X86_VPMINUQZ256rrk = 11050, + X86_VPMINUQZ256rrkz = 11051, + X86_VPMINUQZrm = 11052, + X86_VPMINUQZrmb = 11053, + X86_VPMINUQZrmbk = 11054, + X86_VPMINUQZrmbkz = 11055, + X86_VPMINUQZrmk = 11056, + X86_VPMINUQZrmkz = 11057, + X86_VPMINUQZrr = 11058, + X86_VPMINUQZrrk = 11059, + X86_VPMINUQZrrkz = 11060, + X86_VPMINUWYrm = 11061, + X86_VPMINUWYrr = 11062, + X86_VPMINUWZ128rm = 11063, + X86_VPMINUWZ128rmk = 11064, + X86_VPMINUWZ128rmkz = 11065, + X86_VPMINUWZ128rr = 11066, + X86_VPMINUWZ128rrk = 11067, + X86_VPMINUWZ128rrkz = 11068, + X86_VPMINUWZ256rm = 11069, + X86_VPMINUWZ256rmk = 11070, + X86_VPMINUWZ256rmkz = 11071, + X86_VPMINUWZ256rr = 11072, + X86_VPMINUWZ256rrk = 11073, + X86_VPMINUWZ256rrkz = 11074, + X86_VPMINUWZrm = 11075, + X86_VPMINUWZrmk = 11076, + X86_VPMINUWZrmkz = 11077, + X86_VPMINUWZrr = 11078, + X86_VPMINUWZrrk = 11079, + X86_VPMINUWZrrkz = 11080, + X86_VPMINUWrm = 11081, + X86_VPMINUWrr = 11082, + X86_VPMOVB2MZ128rr = 11083, + X86_VPMOVB2MZ256rr = 11084, + X86_VPMOVB2MZrr = 11085, + X86_VPMOVD2MZ128rr = 11086, + X86_VPMOVD2MZ256rr = 11087, + X86_VPMOVD2MZrr = 11088, + X86_VPMOVDBZ128mr = 11089, + X86_VPMOVDBZ128mrk = 11090, + X86_VPMOVDBZ128rr = 11091, + X86_VPMOVDBZ128rrk = 11092, + X86_VPMOVDBZ128rrkz = 11093, + X86_VPMOVDBZ256mr = 11094, + X86_VPMOVDBZ256mrk = 11095, + X86_VPMOVDBZ256rr = 11096, + X86_VPMOVDBZ256rrk = 11097, + X86_VPMOVDBZ256rrkz = 11098, + X86_VPMOVDBZmr = 11099, + X86_VPMOVDBZmrk = 11100, + X86_VPMOVDBZrr = 11101, + X86_VPMOVDBZrrk = 11102, + X86_VPMOVDBZrrkz = 11103, + X86_VPMOVDWZ128mr = 11104, + X86_VPMOVDWZ128mrk = 11105, + X86_VPMOVDWZ128rr = 11106, + X86_VPMOVDWZ128rrk = 11107, + X86_VPMOVDWZ128rrkz = 11108, + X86_VPMOVDWZ256mr = 11109, + X86_VPMOVDWZ256mrk = 11110, + X86_VPMOVDWZ256rr = 11111, + X86_VPMOVDWZ256rrk = 11112, + X86_VPMOVDWZ256rrkz = 11113, + X86_VPMOVDWZmr = 11114, + X86_VPMOVDWZmrk = 11115, + X86_VPMOVDWZrr = 11116, + X86_VPMOVDWZrrk = 11117, + X86_VPMOVDWZrrkz = 11118, + X86_VPMOVM2BZ128rr = 11119, + X86_VPMOVM2BZ256rr = 11120, + X86_VPMOVM2BZrr = 11121, + X86_VPMOVM2DZ128rr = 11122, + X86_VPMOVM2DZ256rr = 11123, + X86_VPMOVM2DZrr = 11124, + X86_VPMOVM2QZ128rr = 11125, + X86_VPMOVM2QZ256rr = 11126, + X86_VPMOVM2QZrr = 11127, + X86_VPMOVM2WZ128rr = 11128, + X86_VPMOVM2WZ256rr = 11129, + X86_VPMOVM2WZrr = 11130, + X86_VPMOVMSKBYrr = 11131, + X86_VPMOVMSKBrr = 11132, + X86_VPMOVQ2MZ128rr = 11133, + X86_VPMOVQ2MZ256rr = 11134, + X86_VPMOVQ2MZrr = 11135, + X86_VPMOVQBZ128mr = 11136, + X86_VPMOVQBZ128mrk = 11137, + X86_VPMOVQBZ128rr = 11138, + X86_VPMOVQBZ128rrk = 11139, + X86_VPMOVQBZ128rrkz = 11140, + X86_VPMOVQBZ256mr = 11141, + X86_VPMOVQBZ256mrk = 11142, + X86_VPMOVQBZ256rr = 11143, + X86_VPMOVQBZ256rrk = 11144, + X86_VPMOVQBZ256rrkz = 11145, + X86_VPMOVQBZmr = 11146, + X86_VPMOVQBZmrk = 11147, + X86_VPMOVQBZrr = 11148, + X86_VPMOVQBZrrk = 11149, + X86_VPMOVQBZrrkz = 11150, + X86_VPMOVQDZ128mr = 11151, + X86_VPMOVQDZ128mrk = 11152, + X86_VPMOVQDZ128rr = 11153, + X86_VPMOVQDZ128rrk = 11154, + X86_VPMOVQDZ128rrkz = 11155, + X86_VPMOVQDZ256mr = 11156, + X86_VPMOVQDZ256mrk = 11157, + X86_VPMOVQDZ256rr = 11158, + X86_VPMOVQDZ256rrk = 11159, + X86_VPMOVQDZ256rrkz = 11160, + X86_VPMOVQDZmr = 11161, + X86_VPMOVQDZmrk = 11162, + X86_VPMOVQDZrr = 11163, + X86_VPMOVQDZrrk = 11164, + X86_VPMOVQDZrrkz = 11165, + X86_VPMOVQWZ128mr = 11166, + X86_VPMOVQWZ128mrk = 11167, + X86_VPMOVQWZ128rr = 11168, + X86_VPMOVQWZ128rrk = 11169, + X86_VPMOVQWZ128rrkz = 11170, + X86_VPMOVQWZ256mr = 11171, + X86_VPMOVQWZ256mrk = 11172, + X86_VPMOVQWZ256rr = 11173, + X86_VPMOVQWZ256rrk = 11174, + X86_VPMOVQWZ256rrkz = 11175, + X86_VPMOVQWZmr = 11176, + X86_VPMOVQWZmrk = 11177, + X86_VPMOVQWZrr = 11178, + X86_VPMOVQWZrrk = 11179, + X86_VPMOVQWZrrkz = 11180, + X86_VPMOVSDBZ128mr = 11181, + X86_VPMOVSDBZ128mrk = 11182, + X86_VPMOVSDBZ128rr = 11183, + X86_VPMOVSDBZ128rrk = 11184, + X86_VPMOVSDBZ128rrkz = 11185, + X86_VPMOVSDBZ256mr = 11186, + X86_VPMOVSDBZ256mrk = 11187, + X86_VPMOVSDBZ256rr = 11188, + X86_VPMOVSDBZ256rrk = 11189, + X86_VPMOVSDBZ256rrkz = 11190, + X86_VPMOVSDBZmr = 11191, + X86_VPMOVSDBZmrk = 11192, + X86_VPMOVSDBZrr = 11193, + X86_VPMOVSDBZrrk = 11194, + X86_VPMOVSDBZrrkz = 11195, + X86_VPMOVSDWZ128mr = 11196, + X86_VPMOVSDWZ128mrk = 11197, + X86_VPMOVSDWZ128rr = 11198, + X86_VPMOVSDWZ128rrk = 11199, + X86_VPMOVSDWZ128rrkz = 11200, + X86_VPMOVSDWZ256mr = 11201, + X86_VPMOVSDWZ256mrk = 11202, + X86_VPMOVSDWZ256rr = 11203, + X86_VPMOVSDWZ256rrk = 11204, + X86_VPMOVSDWZ256rrkz = 11205, + X86_VPMOVSDWZmr = 11206, + X86_VPMOVSDWZmrk = 11207, + X86_VPMOVSDWZrr = 11208, + X86_VPMOVSDWZrrk = 11209, + X86_VPMOVSDWZrrkz = 11210, + X86_VPMOVSQBZ128mr = 11211, + X86_VPMOVSQBZ128mrk = 11212, + X86_VPMOVSQBZ128rr = 11213, + X86_VPMOVSQBZ128rrk = 11214, + X86_VPMOVSQBZ128rrkz = 11215, + X86_VPMOVSQBZ256mr = 11216, + X86_VPMOVSQBZ256mrk = 11217, + X86_VPMOVSQBZ256rr = 11218, + X86_VPMOVSQBZ256rrk = 11219, + X86_VPMOVSQBZ256rrkz = 11220, + X86_VPMOVSQBZmr = 11221, + X86_VPMOVSQBZmrk = 11222, + X86_VPMOVSQBZrr = 11223, + X86_VPMOVSQBZrrk = 11224, + X86_VPMOVSQBZrrkz = 11225, + X86_VPMOVSQDZ128mr = 11226, + X86_VPMOVSQDZ128mrk = 11227, + X86_VPMOVSQDZ128rr = 11228, + X86_VPMOVSQDZ128rrk = 11229, + X86_VPMOVSQDZ128rrkz = 11230, + X86_VPMOVSQDZ256mr = 11231, + X86_VPMOVSQDZ256mrk = 11232, + X86_VPMOVSQDZ256rr = 11233, + X86_VPMOVSQDZ256rrk = 11234, + X86_VPMOVSQDZ256rrkz = 11235, + X86_VPMOVSQDZmr = 11236, + X86_VPMOVSQDZmrk = 11237, + X86_VPMOVSQDZrr = 11238, + X86_VPMOVSQDZrrk = 11239, + X86_VPMOVSQDZrrkz = 11240, + X86_VPMOVSQWZ128mr = 11241, + X86_VPMOVSQWZ128mrk = 11242, + X86_VPMOVSQWZ128rr = 11243, + X86_VPMOVSQWZ128rrk = 11244, + X86_VPMOVSQWZ128rrkz = 11245, + X86_VPMOVSQWZ256mr = 11246, + X86_VPMOVSQWZ256mrk = 11247, + X86_VPMOVSQWZ256rr = 11248, + X86_VPMOVSQWZ256rrk = 11249, + X86_VPMOVSQWZ256rrkz = 11250, + X86_VPMOVSQWZmr = 11251, + X86_VPMOVSQWZmrk = 11252, + X86_VPMOVSQWZrr = 11253, + X86_VPMOVSQWZrrk = 11254, + X86_VPMOVSQWZrrkz = 11255, + X86_VPMOVSWBZ128mr = 11256, + X86_VPMOVSWBZ128mrk = 11257, + X86_VPMOVSWBZ128rr = 11258, + X86_VPMOVSWBZ128rrk = 11259, + X86_VPMOVSWBZ128rrkz = 11260, + X86_VPMOVSWBZ256mr = 11261, + X86_VPMOVSWBZ256mrk = 11262, + X86_VPMOVSWBZ256rr = 11263, + X86_VPMOVSWBZ256rrk = 11264, + X86_VPMOVSWBZ256rrkz = 11265, + X86_VPMOVSWBZmr = 11266, + X86_VPMOVSWBZmrk = 11267, + X86_VPMOVSWBZrr = 11268, + X86_VPMOVSWBZrrk = 11269, + X86_VPMOVSWBZrrkz = 11270, + X86_VPMOVSXBDYrm = 11271, + X86_VPMOVSXBDYrr = 11272, + X86_VPMOVSXBDZ128rm = 11273, + X86_VPMOVSXBDZ128rmk = 11274, + X86_VPMOVSXBDZ128rmkz = 11275, + X86_VPMOVSXBDZ128rr = 11276, + X86_VPMOVSXBDZ128rrk = 11277, + X86_VPMOVSXBDZ128rrkz = 11278, + X86_VPMOVSXBDZ256rm = 11279, + X86_VPMOVSXBDZ256rmk = 11280, + X86_VPMOVSXBDZ256rmkz = 11281, + X86_VPMOVSXBDZ256rr = 11282, + X86_VPMOVSXBDZ256rrk = 11283, + X86_VPMOVSXBDZ256rrkz = 11284, + X86_VPMOVSXBDZrm = 11285, + X86_VPMOVSXBDZrmk = 11286, + X86_VPMOVSXBDZrmkz = 11287, + X86_VPMOVSXBDZrr = 11288, + X86_VPMOVSXBDZrrk = 11289, + X86_VPMOVSXBDZrrkz = 11290, + X86_VPMOVSXBDrm = 11291, + X86_VPMOVSXBDrr = 11292, + X86_VPMOVSXBQYrm = 11293, + X86_VPMOVSXBQYrr = 11294, + X86_VPMOVSXBQZ128rm = 11295, + X86_VPMOVSXBQZ128rmk = 11296, + X86_VPMOVSXBQZ128rmkz = 11297, + X86_VPMOVSXBQZ128rr = 11298, + X86_VPMOVSXBQZ128rrk = 11299, + X86_VPMOVSXBQZ128rrkz = 11300, + X86_VPMOVSXBQZ256rm = 11301, + X86_VPMOVSXBQZ256rmk = 11302, + X86_VPMOVSXBQZ256rmkz = 11303, + X86_VPMOVSXBQZ256rr = 11304, + X86_VPMOVSXBQZ256rrk = 11305, + X86_VPMOVSXBQZ256rrkz = 11306, + X86_VPMOVSXBQZrm = 11307, + X86_VPMOVSXBQZrmk = 11308, + X86_VPMOVSXBQZrmkz = 11309, + X86_VPMOVSXBQZrr = 11310, + X86_VPMOVSXBQZrrk = 11311, + X86_VPMOVSXBQZrrkz = 11312, + X86_VPMOVSXBQrm = 11313, + X86_VPMOVSXBQrr = 11314, + X86_VPMOVSXBWYrm = 11315, + X86_VPMOVSXBWYrr = 11316, + X86_VPMOVSXBWZ128rm = 11317, + X86_VPMOVSXBWZ128rmk = 11318, + X86_VPMOVSXBWZ128rmkz = 11319, + X86_VPMOVSXBWZ128rr = 11320, + X86_VPMOVSXBWZ128rrk = 11321, + X86_VPMOVSXBWZ128rrkz = 11322, + X86_VPMOVSXBWZ256rm = 11323, + X86_VPMOVSXBWZ256rmk = 11324, + X86_VPMOVSXBWZ256rmkz = 11325, + X86_VPMOVSXBWZ256rr = 11326, + X86_VPMOVSXBWZ256rrk = 11327, + X86_VPMOVSXBWZ256rrkz = 11328, + X86_VPMOVSXBWZrm = 11329, + X86_VPMOVSXBWZrmk = 11330, + X86_VPMOVSXBWZrmkz = 11331, + X86_VPMOVSXBWZrr = 11332, + X86_VPMOVSXBWZrrk = 11333, + X86_VPMOVSXBWZrrkz = 11334, + X86_VPMOVSXBWrm = 11335, + X86_VPMOVSXBWrr = 11336, + X86_VPMOVSXDQYrm = 11337, + X86_VPMOVSXDQYrr = 11338, + X86_VPMOVSXDQZ128rm = 11339, + X86_VPMOVSXDQZ128rmk = 11340, + X86_VPMOVSXDQZ128rmkz = 11341, + X86_VPMOVSXDQZ128rr = 11342, + X86_VPMOVSXDQZ128rrk = 11343, + X86_VPMOVSXDQZ128rrkz = 11344, + X86_VPMOVSXDQZ256rm = 11345, + X86_VPMOVSXDQZ256rmk = 11346, + X86_VPMOVSXDQZ256rmkz = 11347, + X86_VPMOVSXDQZ256rr = 11348, + X86_VPMOVSXDQZ256rrk = 11349, + X86_VPMOVSXDQZ256rrkz = 11350, + X86_VPMOVSXDQZrm = 11351, + X86_VPMOVSXDQZrmk = 11352, + X86_VPMOVSXDQZrmkz = 11353, + X86_VPMOVSXDQZrr = 11354, + X86_VPMOVSXDQZrrk = 11355, + X86_VPMOVSXDQZrrkz = 11356, + X86_VPMOVSXDQrm = 11357, + X86_VPMOVSXDQrr = 11358, + X86_VPMOVSXWDYrm = 11359, + X86_VPMOVSXWDYrr = 11360, + X86_VPMOVSXWDZ128rm = 11361, + X86_VPMOVSXWDZ128rmk = 11362, + X86_VPMOVSXWDZ128rmkz = 11363, + X86_VPMOVSXWDZ128rr = 11364, + X86_VPMOVSXWDZ128rrk = 11365, + X86_VPMOVSXWDZ128rrkz = 11366, + X86_VPMOVSXWDZ256rm = 11367, + X86_VPMOVSXWDZ256rmk = 11368, + X86_VPMOVSXWDZ256rmkz = 11369, + X86_VPMOVSXWDZ256rr = 11370, + X86_VPMOVSXWDZ256rrk = 11371, + X86_VPMOVSXWDZ256rrkz = 11372, + X86_VPMOVSXWDZrm = 11373, + X86_VPMOVSXWDZrmk = 11374, + X86_VPMOVSXWDZrmkz = 11375, + X86_VPMOVSXWDZrr = 11376, + X86_VPMOVSXWDZrrk = 11377, + X86_VPMOVSXWDZrrkz = 11378, + X86_VPMOVSXWDrm = 11379, + X86_VPMOVSXWDrr = 11380, + X86_VPMOVSXWQYrm = 11381, + X86_VPMOVSXWQYrr = 11382, + X86_VPMOVSXWQZ128rm = 11383, + X86_VPMOVSXWQZ128rmk = 11384, + X86_VPMOVSXWQZ128rmkz = 11385, + X86_VPMOVSXWQZ128rr = 11386, + X86_VPMOVSXWQZ128rrk = 11387, + X86_VPMOVSXWQZ128rrkz = 11388, + X86_VPMOVSXWQZ256rm = 11389, + X86_VPMOVSXWQZ256rmk = 11390, + X86_VPMOVSXWQZ256rmkz = 11391, + X86_VPMOVSXWQZ256rr = 11392, + X86_VPMOVSXWQZ256rrk = 11393, + X86_VPMOVSXWQZ256rrkz = 11394, + X86_VPMOVSXWQZrm = 11395, + X86_VPMOVSXWQZrmk = 11396, + X86_VPMOVSXWQZrmkz = 11397, + X86_VPMOVSXWQZrr = 11398, + X86_VPMOVSXWQZrrk = 11399, + X86_VPMOVSXWQZrrkz = 11400, + X86_VPMOVSXWQrm = 11401, + X86_VPMOVSXWQrr = 11402, + X86_VPMOVUSDBZ128mr = 11403, + X86_VPMOVUSDBZ128mrk = 11404, + X86_VPMOVUSDBZ128rr = 11405, + X86_VPMOVUSDBZ128rrk = 11406, + X86_VPMOVUSDBZ128rrkz = 11407, + X86_VPMOVUSDBZ256mr = 11408, + X86_VPMOVUSDBZ256mrk = 11409, + X86_VPMOVUSDBZ256rr = 11410, + X86_VPMOVUSDBZ256rrk = 11411, + X86_VPMOVUSDBZ256rrkz = 11412, + X86_VPMOVUSDBZmr = 11413, + X86_VPMOVUSDBZmrk = 11414, + X86_VPMOVUSDBZrr = 11415, + X86_VPMOVUSDBZrrk = 11416, + X86_VPMOVUSDBZrrkz = 11417, + X86_VPMOVUSDWZ128mr = 11418, + X86_VPMOVUSDWZ128mrk = 11419, + X86_VPMOVUSDWZ128rr = 11420, + X86_VPMOVUSDWZ128rrk = 11421, + X86_VPMOVUSDWZ128rrkz = 11422, + X86_VPMOVUSDWZ256mr = 11423, + X86_VPMOVUSDWZ256mrk = 11424, + X86_VPMOVUSDWZ256rr = 11425, + X86_VPMOVUSDWZ256rrk = 11426, + X86_VPMOVUSDWZ256rrkz = 11427, + X86_VPMOVUSDWZmr = 11428, + X86_VPMOVUSDWZmrk = 11429, + X86_VPMOVUSDWZrr = 11430, + X86_VPMOVUSDWZrrk = 11431, + X86_VPMOVUSDWZrrkz = 11432, + X86_VPMOVUSQBZ128mr = 11433, + X86_VPMOVUSQBZ128mrk = 11434, + X86_VPMOVUSQBZ128rr = 11435, + X86_VPMOVUSQBZ128rrk = 11436, + X86_VPMOVUSQBZ128rrkz = 11437, + X86_VPMOVUSQBZ256mr = 11438, + X86_VPMOVUSQBZ256mrk = 11439, + X86_VPMOVUSQBZ256rr = 11440, + X86_VPMOVUSQBZ256rrk = 11441, + X86_VPMOVUSQBZ256rrkz = 11442, + X86_VPMOVUSQBZmr = 11443, + X86_VPMOVUSQBZmrk = 11444, + X86_VPMOVUSQBZrr = 11445, + X86_VPMOVUSQBZrrk = 11446, + X86_VPMOVUSQBZrrkz = 11447, + X86_VPMOVUSQDZ128mr = 11448, + X86_VPMOVUSQDZ128mrk = 11449, + X86_VPMOVUSQDZ128rr = 11450, + X86_VPMOVUSQDZ128rrk = 11451, + X86_VPMOVUSQDZ128rrkz = 11452, + X86_VPMOVUSQDZ256mr = 11453, + X86_VPMOVUSQDZ256mrk = 11454, + X86_VPMOVUSQDZ256rr = 11455, + X86_VPMOVUSQDZ256rrk = 11456, + X86_VPMOVUSQDZ256rrkz = 11457, + X86_VPMOVUSQDZmr = 11458, + X86_VPMOVUSQDZmrk = 11459, + X86_VPMOVUSQDZrr = 11460, + X86_VPMOVUSQDZrrk = 11461, + X86_VPMOVUSQDZrrkz = 11462, + X86_VPMOVUSQWZ128mr = 11463, + X86_VPMOVUSQWZ128mrk = 11464, + X86_VPMOVUSQWZ128rr = 11465, + X86_VPMOVUSQWZ128rrk = 11466, + X86_VPMOVUSQWZ128rrkz = 11467, + X86_VPMOVUSQWZ256mr = 11468, + X86_VPMOVUSQWZ256mrk = 11469, + X86_VPMOVUSQWZ256rr = 11470, + X86_VPMOVUSQWZ256rrk = 11471, + X86_VPMOVUSQWZ256rrkz = 11472, + X86_VPMOVUSQWZmr = 11473, + X86_VPMOVUSQWZmrk = 11474, + X86_VPMOVUSQWZrr = 11475, + X86_VPMOVUSQWZrrk = 11476, + X86_VPMOVUSQWZrrkz = 11477, + X86_VPMOVUSWBZ128mr = 11478, + X86_VPMOVUSWBZ128mrk = 11479, + X86_VPMOVUSWBZ128rr = 11480, + X86_VPMOVUSWBZ128rrk = 11481, + X86_VPMOVUSWBZ128rrkz = 11482, + X86_VPMOVUSWBZ256mr = 11483, + X86_VPMOVUSWBZ256mrk = 11484, + X86_VPMOVUSWBZ256rr = 11485, + X86_VPMOVUSWBZ256rrk = 11486, + X86_VPMOVUSWBZ256rrkz = 11487, + X86_VPMOVUSWBZmr = 11488, + X86_VPMOVUSWBZmrk = 11489, + X86_VPMOVUSWBZrr = 11490, + X86_VPMOVUSWBZrrk = 11491, + X86_VPMOVUSWBZrrkz = 11492, + X86_VPMOVW2MZ128rr = 11493, + X86_VPMOVW2MZ256rr = 11494, + X86_VPMOVW2MZrr = 11495, + X86_VPMOVWBZ128mr = 11496, + X86_VPMOVWBZ128mrk = 11497, + X86_VPMOVWBZ128rr = 11498, + X86_VPMOVWBZ128rrk = 11499, + X86_VPMOVWBZ128rrkz = 11500, + X86_VPMOVWBZ256mr = 11501, + X86_VPMOVWBZ256mrk = 11502, + X86_VPMOVWBZ256rr = 11503, + X86_VPMOVWBZ256rrk = 11504, + X86_VPMOVWBZ256rrkz = 11505, + X86_VPMOVWBZmr = 11506, + X86_VPMOVWBZmrk = 11507, + X86_VPMOVWBZrr = 11508, + X86_VPMOVWBZrrk = 11509, + X86_VPMOVWBZrrkz = 11510, + X86_VPMOVZXBDYrm = 11511, + X86_VPMOVZXBDYrr = 11512, + X86_VPMOVZXBDZ128rm = 11513, + X86_VPMOVZXBDZ128rmk = 11514, + X86_VPMOVZXBDZ128rmkz = 11515, + X86_VPMOVZXBDZ128rr = 11516, + X86_VPMOVZXBDZ128rrk = 11517, + X86_VPMOVZXBDZ128rrkz = 11518, + X86_VPMOVZXBDZ256rm = 11519, + X86_VPMOVZXBDZ256rmk = 11520, + X86_VPMOVZXBDZ256rmkz = 11521, + X86_VPMOVZXBDZ256rr = 11522, + X86_VPMOVZXBDZ256rrk = 11523, + X86_VPMOVZXBDZ256rrkz = 11524, + X86_VPMOVZXBDZrm = 11525, + X86_VPMOVZXBDZrmk = 11526, + X86_VPMOVZXBDZrmkz = 11527, + X86_VPMOVZXBDZrr = 11528, + X86_VPMOVZXBDZrrk = 11529, + X86_VPMOVZXBDZrrkz = 11530, + X86_VPMOVZXBDrm = 11531, + X86_VPMOVZXBDrr = 11532, + X86_VPMOVZXBQYrm = 11533, + X86_VPMOVZXBQYrr = 11534, + X86_VPMOVZXBQZ128rm = 11535, + X86_VPMOVZXBQZ128rmk = 11536, + X86_VPMOVZXBQZ128rmkz = 11537, + X86_VPMOVZXBQZ128rr = 11538, + X86_VPMOVZXBQZ128rrk = 11539, + X86_VPMOVZXBQZ128rrkz = 11540, + X86_VPMOVZXBQZ256rm = 11541, + X86_VPMOVZXBQZ256rmk = 11542, + X86_VPMOVZXBQZ256rmkz = 11543, + X86_VPMOVZXBQZ256rr = 11544, + X86_VPMOVZXBQZ256rrk = 11545, + X86_VPMOVZXBQZ256rrkz = 11546, + X86_VPMOVZXBQZrm = 11547, + X86_VPMOVZXBQZrmk = 11548, + X86_VPMOVZXBQZrmkz = 11549, + X86_VPMOVZXBQZrr = 11550, + X86_VPMOVZXBQZrrk = 11551, + X86_VPMOVZXBQZrrkz = 11552, + X86_VPMOVZXBQrm = 11553, + X86_VPMOVZXBQrr = 11554, + X86_VPMOVZXBWYrm = 11555, + X86_VPMOVZXBWYrr = 11556, + X86_VPMOVZXBWZ128rm = 11557, + X86_VPMOVZXBWZ128rmk = 11558, + X86_VPMOVZXBWZ128rmkz = 11559, + X86_VPMOVZXBWZ128rr = 11560, + X86_VPMOVZXBWZ128rrk = 11561, + X86_VPMOVZXBWZ128rrkz = 11562, + X86_VPMOVZXBWZ256rm = 11563, + X86_VPMOVZXBWZ256rmk = 11564, + X86_VPMOVZXBWZ256rmkz = 11565, + X86_VPMOVZXBWZ256rr = 11566, + X86_VPMOVZXBWZ256rrk = 11567, + X86_VPMOVZXBWZ256rrkz = 11568, + X86_VPMOVZXBWZrm = 11569, + X86_VPMOVZXBWZrmk = 11570, + X86_VPMOVZXBWZrmkz = 11571, + X86_VPMOVZXBWZrr = 11572, + X86_VPMOVZXBWZrrk = 11573, + X86_VPMOVZXBWZrrkz = 11574, + X86_VPMOVZXBWrm = 11575, + X86_VPMOVZXBWrr = 11576, + X86_VPMOVZXDQYrm = 11577, + X86_VPMOVZXDQYrr = 11578, + X86_VPMOVZXDQZ128rm = 11579, + X86_VPMOVZXDQZ128rmk = 11580, + X86_VPMOVZXDQZ128rmkz = 11581, + X86_VPMOVZXDQZ128rr = 11582, + X86_VPMOVZXDQZ128rrk = 11583, + X86_VPMOVZXDQZ128rrkz = 11584, + X86_VPMOVZXDQZ256rm = 11585, + X86_VPMOVZXDQZ256rmk = 11586, + X86_VPMOVZXDQZ256rmkz = 11587, + X86_VPMOVZXDQZ256rr = 11588, + X86_VPMOVZXDQZ256rrk = 11589, + X86_VPMOVZXDQZ256rrkz = 11590, + X86_VPMOVZXDQZrm = 11591, + X86_VPMOVZXDQZrmk = 11592, + X86_VPMOVZXDQZrmkz = 11593, + X86_VPMOVZXDQZrr = 11594, + X86_VPMOVZXDQZrrk = 11595, + X86_VPMOVZXDQZrrkz = 11596, + X86_VPMOVZXDQrm = 11597, + X86_VPMOVZXDQrr = 11598, + X86_VPMOVZXWDYrm = 11599, + X86_VPMOVZXWDYrr = 11600, + X86_VPMOVZXWDZ128rm = 11601, + X86_VPMOVZXWDZ128rmk = 11602, + X86_VPMOVZXWDZ128rmkz = 11603, + X86_VPMOVZXWDZ128rr = 11604, + X86_VPMOVZXWDZ128rrk = 11605, + X86_VPMOVZXWDZ128rrkz = 11606, + X86_VPMOVZXWDZ256rm = 11607, + X86_VPMOVZXWDZ256rmk = 11608, + X86_VPMOVZXWDZ256rmkz = 11609, + X86_VPMOVZXWDZ256rr = 11610, + X86_VPMOVZXWDZ256rrk = 11611, + X86_VPMOVZXWDZ256rrkz = 11612, + X86_VPMOVZXWDZrm = 11613, + X86_VPMOVZXWDZrmk = 11614, + X86_VPMOVZXWDZrmkz = 11615, + X86_VPMOVZXWDZrr = 11616, + X86_VPMOVZXWDZrrk = 11617, + X86_VPMOVZXWDZrrkz = 11618, + X86_VPMOVZXWDrm = 11619, + X86_VPMOVZXWDrr = 11620, + X86_VPMOVZXWQYrm = 11621, + X86_VPMOVZXWQYrr = 11622, + X86_VPMOVZXWQZ128rm = 11623, + X86_VPMOVZXWQZ128rmk = 11624, + X86_VPMOVZXWQZ128rmkz = 11625, + X86_VPMOVZXWQZ128rr = 11626, + X86_VPMOVZXWQZ128rrk = 11627, + X86_VPMOVZXWQZ128rrkz = 11628, + X86_VPMOVZXWQZ256rm = 11629, + X86_VPMOVZXWQZ256rmk = 11630, + X86_VPMOVZXWQZ256rmkz = 11631, + X86_VPMOVZXWQZ256rr = 11632, + X86_VPMOVZXWQZ256rrk = 11633, + X86_VPMOVZXWQZ256rrkz = 11634, + X86_VPMOVZXWQZrm = 11635, + X86_VPMOVZXWQZrmk = 11636, + X86_VPMOVZXWQZrmkz = 11637, + X86_VPMOVZXWQZrr = 11638, + X86_VPMOVZXWQZrrk = 11639, + X86_VPMOVZXWQZrrkz = 11640, + X86_VPMOVZXWQrm = 11641, + X86_VPMOVZXWQrr = 11642, + X86_VPMULDQYrm = 11643, + X86_VPMULDQYrr = 11644, + X86_VPMULDQZ128rm = 11645, + X86_VPMULDQZ128rmb = 11646, + X86_VPMULDQZ128rmbk = 11647, + X86_VPMULDQZ128rmbkz = 11648, + X86_VPMULDQZ128rmk = 11649, + X86_VPMULDQZ128rmkz = 11650, + X86_VPMULDQZ128rr = 11651, + X86_VPMULDQZ128rrk = 11652, + X86_VPMULDQZ128rrkz = 11653, + X86_VPMULDQZ256rm = 11654, + X86_VPMULDQZ256rmb = 11655, + X86_VPMULDQZ256rmbk = 11656, + X86_VPMULDQZ256rmbkz = 11657, + X86_VPMULDQZ256rmk = 11658, + X86_VPMULDQZ256rmkz = 11659, + X86_VPMULDQZ256rr = 11660, + X86_VPMULDQZ256rrk = 11661, + X86_VPMULDQZ256rrkz = 11662, + X86_VPMULDQZrm = 11663, + X86_VPMULDQZrmb = 11664, + X86_VPMULDQZrmbk = 11665, + X86_VPMULDQZrmbkz = 11666, + X86_VPMULDQZrmk = 11667, + X86_VPMULDQZrmkz = 11668, + X86_VPMULDQZrr = 11669, + X86_VPMULDQZrrk = 11670, + X86_VPMULDQZrrkz = 11671, + X86_VPMULDQrm = 11672, + X86_VPMULDQrr = 11673, + X86_VPMULHRSWYrm = 11674, + X86_VPMULHRSWYrr = 11675, + X86_VPMULHRSWZ128rm = 11676, + X86_VPMULHRSWZ128rmk = 11677, + X86_VPMULHRSWZ128rmkz = 11678, + X86_VPMULHRSWZ128rr = 11679, + X86_VPMULHRSWZ128rrk = 11680, + X86_VPMULHRSWZ128rrkz = 11681, + X86_VPMULHRSWZ256rm = 11682, + X86_VPMULHRSWZ256rmk = 11683, + X86_VPMULHRSWZ256rmkz = 11684, + X86_VPMULHRSWZ256rr = 11685, + X86_VPMULHRSWZ256rrk = 11686, + X86_VPMULHRSWZ256rrkz = 11687, + X86_VPMULHRSWZrm = 11688, + X86_VPMULHRSWZrmk = 11689, + X86_VPMULHRSWZrmkz = 11690, + X86_VPMULHRSWZrr = 11691, + X86_VPMULHRSWZrrk = 11692, + X86_VPMULHRSWZrrkz = 11693, + X86_VPMULHRSWrm = 11694, + X86_VPMULHRSWrr = 11695, + X86_VPMULHUWYrm = 11696, + X86_VPMULHUWYrr = 11697, + X86_VPMULHUWZ128rm = 11698, + X86_VPMULHUWZ128rmk = 11699, + X86_VPMULHUWZ128rmkz = 11700, + X86_VPMULHUWZ128rr = 11701, + X86_VPMULHUWZ128rrk = 11702, + X86_VPMULHUWZ128rrkz = 11703, + X86_VPMULHUWZ256rm = 11704, + X86_VPMULHUWZ256rmk = 11705, + X86_VPMULHUWZ256rmkz = 11706, + X86_VPMULHUWZ256rr = 11707, + X86_VPMULHUWZ256rrk = 11708, + X86_VPMULHUWZ256rrkz = 11709, + X86_VPMULHUWZrm = 11710, + X86_VPMULHUWZrmk = 11711, + X86_VPMULHUWZrmkz = 11712, + X86_VPMULHUWZrr = 11713, + X86_VPMULHUWZrrk = 11714, + X86_VPMULHUWZrrkz = 11715, + X86_VPMULHUWrm = 11716, + X86_VPMULHUWrr = 11717, + X86_VPMULHWYrm = 11718, + X86_VPMULHWYrr = 11719, + X86_VPMULHWZ128rm = 11720, + X86_VPMULHWZ128rmk = 11721, + X86_VPMULHWZ128rmkz = 11722, + X86_VPMULHWZ128rr = 11723, + X86_VPMULHWZ128rrk = 11724, + X86_VPMULHWZ128rrkz = 11725, + X86_VPMULHWZ256rm = 11726, + X86_VPMULHWZ256rmk = 11727, + X86_VPMULHWZ256rmkz = 11728, + X86_VPMULHWZ256rr = 11729, + X86_VPMULHWZ256rrk = 11730, + X86_VPMULHWZ256rrkz = 11731, + X86_VPMULHWZrm = 11732, + X86_VPMULHWZrmk = 11733, + X86_VPMULHWZrmkz = 11734, + X86_VPMULHWZrr = 11735, + X86_VPMULHWZrrk = 11736, + X86_VPMULHWZrrkz = 11737, + X86_VPMULHWrm = 11738, + X86_VPMULHWrr = 11739, + X86_VPMULLDYrm = 11740, + X86_VPMULLDYrr = 11741, + X86_VPMULLDZ128rm = 11742, + X86_VPMULLDZ128rmb = 11743, + X86_VPMULLDZ128rmbk = 11744, + X86_VPMULLDZ128rmbkz = 11745, + X86_VPMULLDZ128rmk = 11746, + X86_VPMULLDZ128rmkz = 11747, + X86_VPMULLDZ128rr = 11748, + X86_VPMULLDZ128rrk = 11749, + X86_VPMULLDZ128rrkz = 11750, + X86_VPMULLDZ256rm = 11751, + X86_VPMULLDZ256rmb = 11752, + X86_VPMULLDZ256rmbk = 11753, + X86_VPMULLDZ256rmbkz = 11754, + X86_VPMULLDZ256rmk = 11755, + X86_VPMULLDZ256rmkz = 11756, + X86_VPMULLDZ256rr = 11757, + X86_VPMULLDZ256rrk = 11758, + X86_VPMULLDZ256rrkz = 11759, + X86_VPMULLDZrm = 11760, + X86_VPMULLDZrmb = 11761, + X86_VPMULLDZrmbk = 11762, + X86_VPMULLDZrmbkz = 11763, + X86_VPMULLDZrmk = 11764, + X86_VPMULLDZrmkz = 11765, + X86_VPMULLDZrr = 11766, + X86_VPMULLDZrrk = 11767, + X86_VPMULLDZrrkz = 11768, + X86_VPMULLDrm = 11769, + X86_VPMULLDrr = 11770, + X86_VPMULLQZ128rm = 11771, + X86_VPMULLQZ128rmb = 11772, + X86_VPMULLQZ128rmbk = 11773, + X86_VPMULLQZ128rmbkz = 11774, + X86_VPMULLQZ128rmk = 11775, + X86_VPMULLQZ128rmkz = 11776, + X86_VPMULLQZ128rr = 11777, + X86_VPMULLQZ128rrk = 11778, + X86_VPMULLQZ128rrkz = 11779, + X86_VPMULLQZ256rm = 11780, + X86_VPMULLQZ256rmb = 11781, + X86_VPMULLQZ256rmbk = 11782, + X86_VPMULLQZ256rmbkz = 11783, + X86_VPMULLQZ256rmk = 11784, + X86_VPMULLQZ256rmkz = 11785, + X86_VPMULLQZ256rr = 11786, + X86_VPMULLQZ256rrk = 11787, + X86_VPMULLQZ256rrkz = 11788, + X86_VPMULLQZrm = 11789, + X86_VPMULLQZrmb = 11790, + X86_VPMULLQZrmbk = 11791, + X86_VPMULLQZrmbkz = 11792, + X86_VPMULLQZrmk = 11793, + X86_VPMULLQZrmkz = 11794, + X86_VPMULLQZrr = 11795, + X86_VPMULLQZrrk = 11796, + X86_VPMULLQZrrkz = 11797, + X86_VPMULLWYrm = 11798, + X86_VPMULLWYrr = 11799, + X86_VPMULLWZ128rm = 11800, + X86_VPMULLWZ128rmk = 11801, + X86_VPMULLWZ128rmkz = 11802, + X86_VPMULLWZ128rr = 11803, + X86_VPMULLWZ128rrk = 11804, + X86_VPMULLWZ128rrkz = 11805, + X86_VPMULLWZ256rm = 11806, + X86_VPMULLWZ256rmk = 11807, + X86_VPMULLWZ256rmkz = 11808, + X86_VPMULLWZ256rr = 11809, + X86_VPMULLWZ256rrk = 11810, + X86_VPMULLWZ256rrkz = 11811, + X86_VPMULLWZrm = 11812, + X86_VPMULLWZrmk = 11813, + X86_VPMULLWZrmkz = 11814, + X86_VPMULLWZrr = 11815, + X86_VPMULLWZrrk = 11816, + X86_VPMULLWZrrkz = 11817, + X86_VPMULLWrm = 11818, + X86_VPMULLWrr = 11819, + X86_VPMULTISHIFTQBZ128rm = 11820, + X86_VPMULTISHIFTQBZ128rmb = 11821, + X86_VPMULTISHIFTQBZ128rmbk = 11822, + X86_VPMULTISHIFTQBZ128rmbkz = 11823, + X86_VPMULTISHIFTQBZ128rmk = 11824, + X86_VPMULTISHIFTQBZ128rmkz = 11825, + X86_VPMULTISHIFTQBZ128rr = 11826, + X86_VPMULTISHIFTQBZ128rrk = 11827, + X86_VPMULTISHIFTQBZ128rrkz = 11828, + X86_VPMULTISHIFTQBZ256rm = 11829, + X86_VPMULTISHIFTQBZ256rmb = 11830, + X86_VPMULTISHIFTQBZ256rmbk = 11831, + X86_VPMULTISHIFTQBZ256rmbkz = 11832, + X86_VPMULTISHIFTQBZ256rmk = 11833, + X86_VPMULTISHIFTQBZ256rmkz = 11834, + X86_VPMULTISHIFTQBZ256rr = 11835, + X86_VPMULTISHIFTQBZ256rrk = 11836, + X86_VPMULTISHIFTQBZ256rrkz = 11837, + X86_VPMULTISHIFTQBZrm = 11838, + X86_VPMULTISHIFTQBZrmb = 11839, + X86_VPMULTISHIFTQBZrmbk = 11840, + X86_VPMULTISHIFTQBZrmbkz = 11841, + X86_VPMULTISHIFTQBZrmk = 11842, + X86_VPMULTISHIFTQBZrmkz = 11843, + X86_VPMULTISHIFTQBZrr = 11844, + X86_VPMULTISHIFTQBZrrk = 11845, + X86_VPMULTISHIFTQBZrrkz = 11846, + X86_VPMULUDQYrm = 11847, + X86_VPMULUDQYrr = 11848, + X86_VPMULUDQZ128rm = 11849, + X86_VPMULUDQZ128rmb = 11850, + X86_VPMULUDQZ128rmbk = 11851, + X86_VPMULUDQZ128rmbkz = 11852, + X86_VPMULUDQZ128rmk = 11853, + X86_VPMULUDQZ128rmkz = 11854, + X86_VPMULUDQZ128rr = 11855, + X86_VPMULUDQZ128rrk = 11856, + X86_VPMULUDQZ128rrkz = 11857, + X86_VPMULUDQZ256rm = 11858, + X86_VPMULUDQZ256rmb = 11859, + X86_VPMULUDQZ256rmbk = 11860, + X86_VPMULUDQZ256rmbkz = 11861, + X86_VPMULUDQZ256rmk = 11862, + X86_VPMULUDQZ256rmkz = 11863, + X86_VPMULUDQZ256rr = 11864, + X86_VPMULUDQZ256rrk = 11865, + X86_VPMULUDQZ256rrkz = 11866, + X86_VPMULUDQZrm = 11867, + X86_VPMULUDQZrmb = 11868, + X86_VPMULUDQZrmbk = 11869, + X86_VPMULUDQZrmbkz = 11870, + X86_VPMULUDQZrmk = 11871, + X86_VPMULUDQZrmkz = 11872, + X86_VPMULUDQZrr = 11873, + X86_VPMULUDQZrrk = 11874, + X86_VPMULUDQZrrkz = 11875, + X86_VPMULUDQrm = 11876, + X86_VPMULUDQrr = 11877, + X86_VPOPCNTBZ128rm = 11878, + X86_VPOPCNTBZ128rmk = 11879, + X86_VPOPCNTBZ128rmkz = 11880, + X86_VPOPCNTBZ128rr = 11881, + X86_VPOPCNTBZ128rrk = 11882, + X86_VPOPCNTBZ128rrkz = 11883, + X86_VPOPCNTBZ256rm = 11884, + X86_VPOPCNTBZ256rmk = 11885, + X86_VPOPCNTBZ256rmkz = 11886, + X86_VPOPCNTBZ256rr = 11887, + X86_VPOPCNTBZ256rrk = 11888, + X86_VPOPCNTBZ256rrkz = 11889, + X86_VPOPCNTBZrm = 11890, + X86_VPOPCNTBZrmk = 11891, + X86_VPOPCNTBZrmkz = 11892, + X86_VPOPCNTBZrr = 11893, + X86_VPOPCNTBZrrk = 11894, + X86_VPOPCNTBZrrkz = 11895, + X86_VPOPCNTDZ128rm = 11896, + X86_VPOPCNTDZ128rmb = 11897, + X86_VPOPCNTDZ128rmbk = 11898, + X86_VPOPCNTDZ128rmbkz = 11899, + X86_VPOPCNTDZ128rmk = 11900, + X86_VPOPCNTDZ128rmkz = 11901, + X86_VPOPCNTDZ128rr = 11902, + X86_VPOPCNTDZ128rrk = 11903, + X86_VPOPCNTDZ128rrkz = 11904, + X86_VPOPCNTDZ256rm = 11905, + X86_VPOPCNTDZ256rmb = 11906, + X86_VPOPCNTDZ256rmbk = 11907, + X86_VPOPCNTDZ256rmbkz = 11908, + X86_VPOPCNTDZ256rmk = 11909, + X86_VPOPCNTDZ256rmkz = 11910, + X86_VPOPCNTDZ256rr = 11911, + X86_VPOPCNTDZ256rrk = 11912, + X86_VPOPCNTDZ256rrkz = 11913, + X86_VPOPCNTDZrm = 11914, + X86_VPOPCNTDZrmb = 11915, + X86_VPOPCNTDZrmbk = 11916, + X86_VPOPCNTDZrmbkz = 11917, + X86_VPOPCNTDZrmk = 11918, + X86_VPOPCNTDZrmkz = 11919, + X86_VPOPCNTDZrr = 11920, + X86_VPOPCNTDZrrk = 11921, + X86_VPOPCNTDZrrkz = 11922, + X86_VPOPCNTQZ128rm = 11923, + X86_VPOPCNTQZ128rmb = 11924, + X86_VPOPCNTQZ128rmbk = 11925, + X86_VPOPCNTQZ128rmbkz = 11926, + X86_VPOPCNTQZ128rmk = 11927, + X86_VPOPCNTQZ128rmkz = 11928, + X86_VPOPCNTQZ128rr = 11929, + X86_VPOPCNTQZ128rrk = 11930, + X86_VPOPCNTQZ128rrkz = 11931, + X86_VPOPCNTQZ256rm = 11932, + X86_VPOPCNTQZ256rmb = 11933, + X86_VPOPCNTQZ256rmbk = 11934, + X86_VPOPCNTQZ256rmbkz = 11935, + X86_VPOPCNTQZ256rmk = 11936, + X86_VPOPCNTQZ256rmkz = 11937, + X86_VPOPCNTQZ256rr = 11938, + X86_VPOPCNTQZ256rrk = 11939, + X86_VPOPCNTQZ256rrkz = 11940, + X86_VPOPCNTQZrm = 11941, + X86_VPOPCNTQZrmb = 11942, + X86_VPOPCNTQZrmbk = 11943, + X86_VPOPCNTQZrmbkz = 11944, + X86_VPOPCNTQZrmk = 11945, + X86_VPOPCNTQZrmkz = 11946, + X86_VPOPCNTQZrr = 11947, + X86_VPOPCNTQZrrk = 11948, + X86_VPOPCNTQZrrkz = 11949, + X86_VPOPCNTWZ128rm = 11950, + X86_VPOPCNTWZ128rmk = 11951, + X86_VPOPCNTWZ128rmkz = 11952, + X86_VPOPCNTWZ128rr = 11953, + X86_VPOPCNTWZ128rrk = 11954, + X86_VPOPCNTWZ128rrkz = 11955, + X86_VPOPCNTWZ256rm = 11956, + X86_VPOPCNTWZ256rmk = 11957, + X86_VPOPCNTWZ256rmkz = 11958, + X86_VPOPCNTWZ256rr = 11959, + X86_VPOPCNTWZ256rrk = 11960, + X86_VPOPCNTWZ256rrkz = 11961, + X86_VPOPCNTWZrm = 11962, + X86_VPOPCNTWZrmk = 11963, + X86_VPOPCNTWZrmkz = 11964, + X86_VPOPCNTWZrr = 11965, + X86_VPOPCNTWZrrk = 11966, + X86_VPOPCNTWZrrkz = 11967, + X86_VPORDZ128rm = 11968, + X86_VPORDZ128rmb = 11969, + X86_VPORDZ128rmbk = 11970, + X86_VPORDZ128rmbkz = 11971, + X86_VPORDZ128rmk = 11972, + X86_VPORDZ128rmkz = 11973, + X86_VPORDZ128rr = 11974, + X86_VPORDZ128rrk = 11975, + X86_VPORDZ128rrkz = 11976, + X86_VPORDZ256rm = 11977, + X86_VPORDZ256rmb = 11978, + X86_VPORDZ256rmbk = 11979, + X86_VPORDZ256rmbkz = 11980, + X86_VPORDZ256rmk = 11981, + X86_VPORDZ256rmkz = 11982, + X86_VPORDZ256rr = 11983, + X86_VPORDZ256rrk = 11984, + X86_VPORDZ256rrkz = 11985, + X86_VPORDZrm = 11986, + X86_VPORDZrmb = 11987, + X86_VPORDZrmbk = 11988, + X86_VPORDZrmbkz = 11989, + X86_VPORDZrmk = 11990, + X86_VPORDZrmkz = 11991, + X86_VPORDZrr = 11992, + X86_VPORDZrrk = 11993, + X86_VPORDZrrkz = 11994, + X86_VPORQZ128rm = 11995, + X86_VPORQZ128rmb = 11996, + X86_VPORQZ128rmbk = 11997, + X86_VPORQZ128rmbkz = 11998, + X86_VPORQZ128rmk = 11999, + X86_VPORQZ128rmkz = 12000, + X86_VPORQZ128rr = 12001, + X86_VPORQZ128rrk = 12002, + X86_VPORQZ128rrkz = 12003, + X86_VPORQZ256rm = 12004, + X86_VPORQZ256rmb = 12005, + X86_VPORQZ256rmbk = 12006, + X86_VPORQZ256rmbkz = 12007, + X86_VPORQZ256rmk = 12008, + X86_VPORQZ256rmkz = 12009, + X86_VPORQZ256rr = 12010, + X86_VPORQZ256rrk = 12011, + X86_VPORQZ256rrkz = 12012, + X86_VPORQZrm = 12013, + X86_VPORQZrmb = 12014, + X86_VPORQZrmbk = 12015, + X86_VPORQZrmbkz = 12016, + X86_VPORQZrmk = 12017, + X86_VPORQZrmkz = 12018, + X86_VPORQZrr = 12019, + X86_VPORQZrrk = 12020, + X86_VPORQZrrkz = 12021, + X86_VPORYrm = 12022, + X86_VPORYrr = 12023, + X86_VPORrm = 12024, + X86_VPORrr = 12025, + X86_VPPERMrmr = 12026, + X86_VPPERMrrm = 12027, + X86_VPPERMrrr = 12028, + X86_VPPERMrrr_REV = 12029, + X86_VPROLDZ128mbi = 12030, + X86_VPROLDZ128mbik = 12031, + X86_VPROLDZ128mbikz = 12032, + X86_VPROLDZ128mi = 12033, + X86_VPROLDZ128mik = 12034, + X86_VPROLDZ128mikz = 12035, + X86_VPROLDZ128ri = 12036, + X86_VPROLDZ128rik = 12037, + X86_VPROLDZ128rikz = 12038, + X86_VPROLDZ256mbi = 12039, + X86_VPROLDZ256mbik = 12040, + X86_VPROLDZ256mbikz = 12041, + X86_VPROLDZ256mi = 12042, + X86_VPROLDZ256mik = 12043, + X86_VPROLDZ256mikz = 12044, + X86_VPROLDZ256ri = 12045, + X86_VPROLDZ256rik = 12046, + X86_VPROLDZ256rikz = 12047, + X86_VPROLDZmbi = 12048, + X86_VPROLDZmbik = 12049, + X86_VPROLDZmbikz = 12050, + X86_VPROLDZmi = 12051, + X86_VPROLDZmik = 12052, + X86_VPROLDZmikz = 12053, + X86_VPROLDZri = 12054, + X86_VPROLDZrik = 12055, + X86_VPROLDZrikz = 12056, + X86_VPROLQZ128mbi = 12057, + X86_VPROLQZ128mbik = 12058, + X86_VPROLQZ128mbikz = 12059, + X86_VPROLQZ128mi = 12060, + X86_VPROLQZ128mik = 12061, + X86_VPROLQZ128mikz = 12062, + X86_VPROLQZ128ri = 12063, + X86_VPROLQZ128rik = 12064, + X86_VPROLQZ128rikz = 12065, + X86_VPROLQZ256mbi = 12066, + X86_VPROLQZ256mbik = 12067, + X86_VPROLQZ256mbikz = 12068, + X86_VPROLQZ256mi = 12069, + X86_VPROLQZ256mik = 12070, + X86_VPROLQZ256mikz = 12071, + X86_VPROLQZ256ri = 12072, + X86_VPROLQZ256rik = 12073, + X86_VPROLQZ256rikz = 12074, + X86_VPROLQZmbi = 12075, + X86_VPROLQZmbik = 12076, + X86_VPROLQZmbikz = 12077, + X86_VPROLQZmi = 12078, + X86_VPROLQZmik = 12079, + X86_VPROLQZmikz = 12080, + X86_VPROLQZri = 12081, + X86_VPROLQZrik = 12082, + X86_VPROLQZrikz = 12083, + X86_VPROLVDZ128rm = 12084, + X86_VPROLVDZ128rmb = 12085, + X86_VPROLVDZ128rmbk = 12086, + X86_VPROLVDZ128rmbkz = 12087, + X86_VPROLVDZ128rmk = 12088, + X86_VPROLVDZ128rmkz = 12089, + X86_VPROLVDZ128rr = 12090, + X86_VPROLVDZ128rrk = 12091, + X86_VPROLVDZ128rrkz = 12092, + X86_VPROLVDZ256rm = 12093, + X86_VPROLVDZ256rmb = 12094, + X86_VPROLVDZ256rmbk = 12095, + X86_VPROLVDZ256rmbkz = 12096, + X86_VPROLVDZ256rmk = 12097, + X86_VPROLVDZ256rmkz = 12098, + X86_VPROLVDZ256rr = 12099, + X86_VPROLVDZ256rrk = 12100, + X86_VPROLVDZ256rrkz = 12101, + X86_VPROLVDZrm = 12102, + X86_VPROLVDZrmb = 12103, + X86_VPROLVDZrmbk = 12104, + X86_VPROLVDZrmbkz = 12105, + X86_VPROLVDZrmk = 12106, + X86_VPROLVDZrmkz = 12107, + X86_VPROLVDZrr = 12108, + X86_VPROLVDZrrk = 12109, + X86_VPROLVDZrrkz = 12110, + X86_VPROLVQZ128rm = 12111, + X86_VPROLVQZ128rmb = 12112, + X86_VPROLVQZ128rmbk = 12113, + X86_VPROLVQZ128rmbkz = 12114, + X86_VPROLVQZ128rmk = 12115, + X86_VPROLVQZ128rmkz = 12116, + X86_VPROLVQZ128rr = 12117, + X86_VPROLVQZ128rrk = 12118, + X86_VPROLVQZ128rrkz = 12119, + X86_VPROLVQZ256rm = 12120, + X86_VPROLVQZ256rmb = 12121, + X86_VPROLVQZ256rmbk = 12122, + X86_VPROLVQZ256rmbkz = 12123, + X86_VPROLVQZ256rmk = 12124, + X86_VPROLVQZ256rmkz = 12125, + X86_VPROLVQZ256rr = 12126, + X86_VPROLVQZ256rrk = 12127, + X86_VPROLVQZ256rrkz = 12128, + X86_VPROLVQZrm = 12129, + X86_VPROLVQZrmb = 12130, + X86_VPROLVQZrmbk = 12131, + X86_VPROLVQZrmbkz = 12132, + X86_VPROLVQZrmk = 12133, + X86_VPROLVQZrmkz = 12134, + X86_VPROLVQZrr = 12135, + X86_VPROLVQZrrk = 12136, + X86_VPROLVQZrrkz = 12137, + X86_VPRORDZ128mbi = 12138, + X86_VPRORDZ128mbik = 12139, + X86_VPRORDZ128mbikz = 12140, + X86_VPRORDZ128mi = 12141, + X86_VPRORDZ128mik = 12142, + X86_VPRORDZ128mikz = 12143, + X86_VPRORDZ128ri = 12144, + X86_VPRORDZ128rik = 12145, + X86_VPRORDZ128rikz = 12146, + X86_VPRORDZ256mbi = 12147, + X86_VPRORDZ256mbik = 12148, + X86_VPRORDZ256mbikz = 12149, + X86_VPRORDZ256mi = 12150, + X86_VPRORDZ256mik = 12151, + X86_VPRORDZ256mikz = 12152, + X86_VPRORDZ256ri = 12153, + X86_VPRORDZ256rik = 12154, + X86_VPRORDZ256rikz = 12155, + X86_VPRORDZmbi = 12156, + X86_VPRORDZmbik = 12157, + X86_VPRORDZmbikz = 12158, + X86_VPRORDZmi = 12159, + X86_VPRORDZmik = 12160, + X86_VPRORDZmikz = 12161, + X86_VPRORDZri = 12162, + X86_VPRORDZrik = 12163, + X86_VPRORDZrikz = 12164, + X86_VPRORQZ128mbi = 12165, + X86_VPRORQZ128mbik = 12166, + X86_VPRORQZ128mbikz = 12167, + X86_VPRORQZ128mi = 12168, + X86_VPRORQZ128mik = 12169, + X86_VPRORQZ128mikz = 12170, + X86_VPRORQZ128ri = 12171, + X86_VPRORQZ128rik = 12172, + X86_VPRORQZ128rikz = 12173, + X86_VPRORQZ256mbi = 12174, + X86_VPRORQZ256mbik = 12175, + X86_VPRORQZ256mbikz = 12176, + X86_VPRORQZ256mi = 12177, + X86_VPRORQZ256mik = 12178, + X86_VPRORQZ256mikz = 12179, + X86_VPRORQZ256ri = 12180, + X86_VPRORQZ256rik = 12181, + X86_VPRORQZ256rikz = 12182, + X86_VPRORQZmbi = 12183, + X86_VPRORQZmbik = 12184, + X86_VPRORQZmbikz = 12185, + X86_VPRORQZmi = 12186, + X86_VPRORQZmik = 12187, + X86_VPRORQZmikz = 12188, + X86_VPRORQZri = 12189, + X86_VPRORQZrik = 12190, + X86_VPRORQZrikz = 12191, + X86_VPRORVDZ128rm = 12192, + X86_VPRORVDZ128rmb = 12193, + X86_VPRORVDZ128rmbk = 12194, + X86_VPRORVDZ128rmbkz = 12195, + X86_VPRORVDZ128rmk = 12196, + X86_VPRORVDZ128rmkz = 12197, + X86_VPRORVDZ128rr = 12198, + X86_VPRORVDZ128rrk = 12199, + X86_VPRORVDZ128rrkz = 12200, + X86_VPRORVDZ256rm = 12201, + X86_VPRORVDZ256rmb = 12202, + X86_VPRORVDZ256rmbk = 12203, + X86_VPRORVDZ256rmbkz = 12204, + X86_VPRORVDZ256rmk = 12205, + X86_VPRORVDZ256rmkz = 12206, + X86_VPRORVDZ256rr = 12207, + X86_VPRORVDZ256rrk = 12208, + X86_VPRORVDZ256rrkz = 12209, + X86_VPRORVDZrm = 12210, + X86_VPRORVDZrmb = 12211, + X86_VPRORVDZrmbk = 12212, + X86_VPRORVDZrmbkz = 12213, + X86_VPRORVDZrmk = 12214, + X86_VPRORVDZrmkz = 12215, + X86_VPRORVDZrr = 12216, + X86_VPRORVDZrrk = 12217, + X86_VPRORVDZrrkz = 12218, + X86_VPRORVQZ128rm = 12219, + X86_VPRORVQZ128rmb = 12220, + X86_VPRORVQZ128rmbk = 12221, + X86_VPRORVQZ128rmbkz = 12222, + X86_VPRORVQZ128rmk = 12223, + X86_VPRORVQZ128rmkz = 12224, + X86_VPRORVQZ128rr = 12225, + X86_VPRORVQZ128rrk = 12226, + X86_VPRORVQZ128rrkz = 12227, + X86_VPRORVQZ256rm = 12228, + X86_VPRORVQZ256rmb = 12229, + X86_VPRORVQZ256rmbk = 12230, + X86_VPRORVQZ256rmbkz = 12231, + X86_VPRORVQZ256rmk = 12232, + X86_VPRORVQZ256rmkz = 12233, + X86_VPRORVQZ256rr = 12234, + X86_VPRORVQZ256rrk = 12235, + X86_VPRORVQZ256rrkz = 12236, + X86_VPRORVQZrm = 12237, + X86_VPRORVQZrmb = 12238, + X86_VPRORVQZrmbk = 12239, + X86_VPRORVQZrmbkz = 12240, + X86_VPRORVQZrmk = 12241, + X86_VPRORVQZrmkz = 12242, + X86_VPRORVQZrr = 12243, + X86_VPRORVQZrrk = 12244, + X86_VPRORVQZrrkz = 12245, + X86_VPROTBmi = 12246, + X86_VPROTBmr = 12247, + X86_VPROTBri = 12248, + X86_VPROTBrm = 12249, + X86_VPROTBrr = 12250, + X86_VPROTBrr_REV = 12251, + X86_VPROTDmi = 12252, + X86_VPROTDmr = 12253, + X86_VPROTDri = 12254, + X86_VPROTDrm = 12255, + X86_VPROTDrr = 12256, + X86_VPROTDrr_REV = 12257, + X86_VPROTQmi = 12258, + X86_VPROTQmr = 12259, + X86_VPROTQri = 12260, + X86_VPROTQrm = 12261, + X86_VPROTQrr = 12262, + X86_VPROTQrr_REV = 12263, + X86_VPROTWmi = 12264, + X86_VPROTWmr = 12265, + X86_VPROTWri = 12266, + X86_VPROTWrm = 12267, + X86_VPROTWrr = 12268, + X86_VPROTWrr_REV = 12269, + X86_VPSADBWYrm = 12270, + X86_VPSADBWYrr = 12271, + X86_VPSADBWZ128rm = 12272, + X86_VPSADBWZ128rr = 12273, + X86_VPSADBWZ256rm = 12274, + X86_VPSADBWZ256rr = 12275, + X86_VPSADBWZrm = 12276, + X86_VPSADBWZrr = 12277, + X86_VPSADBWrm = 12278, + X86_VPSADBWrr = 12279, + X86_VPSCATTERDDZ128mr = 12280, + X86_VPSCATTERDDZ256mr = 12281, + X86_VPSCATTERDDZmr = 12282, + X86_VPSCATTERDQZ128mr = 12283, + X86_VPSCATTERDQZ256mr = 12284, + X86_VPSCATTERDQZmr = 12285, + X86_VPSCATTERQDZ128mr = 12286, + X86_VPSCATTERQDZ256mr = 12287, + X86_VPSCATTERQDZmr = 12288, + X86_VPSCATTERQQZ128mr = 12289, + X86_VPSCATTERQQZ256mr = 12290, + X86_VPSCATTERQQZmr = 12291, + X86_VPSHABmr = 12292, + X86_VPSHABrm = 12293, + X86_VPSHABrr = 12294, + X86_VPSHABrr_REV = 12295, + X86_VPSHADmr = 12296, + X86_VPSHADrm = 12297, + X86_VPSHADrr = 12298, + X86_VPSHADrr_REV = 12299, + X86_VPSHAQmr = 12300, + X86_VPSHAQrm = 12301, + X86_VPSHAQrr = 12302, + X86_VPSHAQrr_REV = 12303, + X86_VPSHAWmr = 12304, + X86_VPSHAWrm = 12305, + X86_VPSHAWrr = 12306, + X86_VPSHAWrr_REV = 12307, + X86_VPSHLBmr = 12308, + X86_VPSHLBrm = 12309, + X86_VPSHLBrr = 12310, + X86_VPSHLBrr_REV = 12311, + X86_VPSHLDDZ128rmbi = 12312, + X86_VPSHLDDZ128rmbik = 12313, + X86_VPSHLDDZ128rmbikz = 12314, + X86_VPSHLDDZ128rmi = 12315, + X86_VPSHLDDZ128rmik = 12316, + X86_VPSHLDDZ128rmikz = 12317, + X86_VPSHLDDZ128rri = 12318, + X86_VPSHLDDZ128rrik = 12319, + X86_VPSHLDDZ128rrikz = 12320, + X86_VPSHLDDZ256rmbi = 12321, + X86_VPSHLDDZ256rmbik = 12322, + X86_VPSHLDDZ256rmbikz = 12323, + X86_VPSHLDDZ256rmi = 12324, + X86_VPSHLDDZ256rmik = 12325, + X86_VPSHLDDZ256rmikz = 12326, + X86_VPSHLDDZ256rri = 12327, + X86_VPSHLDDZ256rrik = 12328, + X86_VPSHLDDZ256rrikz = 12329, + X86_VPSHLDDZrmbi = 12330, + X86_VPSHLDDZrmbik = 12331, + X86_VPSHLDDZrmbikz = 12332, + X86_VPSHLDDZrmi = 12333, + X86_VPSHLDDZrmik = 12334, + X86_VPSHLDDZrmikz = 12335, + X86_VPSHLDDZrri = 12336, + X86_VPSHLDDZrrik = 12337, + X86_VPSHLDDZrrikz = 12338, + X86_VPSHLDQZ128rmbi = 12339, + X86_VPSHLDQZ128rmbik = 12340, + X86_VPSHLDQZ128rmbikz = 12341, + X86_VPSHLDQZ128rmi = 12342, + X86_VPSHLDQZ128rmik = 12343, + X86_VPSHLDQZ128rmikz = 12344, + X86_VPSHLDQZ128rri = 12345, + X86_VPSHLDQZ128rrik = 12346, + X86_VPSHLDQZ128rrikz = 12347, + X86_VPSHLDQZ256rmbi = 12348, + X86_VPSHLDQZ256rmbik = 12349, + X86_VPSHLDQZ256rmbikz = 12350, + X86_VPSHLDQZ256rmi = 12351, + X86_VPSHLDQZ256rmik = 12352, + X86_VPSHLDQZ256rmikz = 12353, + X86_VPSHLDQZ256rri = 12354, + X86_VPSHLDQZ256rrik = 12355, + X86_VPSHLDQZ256rrikz = 12356, + X86_VPSHLDQZrmbi = 12357, + X86_VPSHLDQZrmbik = 12358, + X86_VPSHLDQZrmbikz = 12359, + X86_VPSHLDQZrmi = 12360, + X86_VPSHLDQZrmik = 12361, + X86_VPSHLDQZrmikz = 12362, + X86_VPSHLDQZrri = 12363, + X86_VPSHLDQZrrik = 12364, + X86_VPSHLDQZrrikz = 12365, + X86_VPSHLDVDZ128m = 12366, + X86_VPSHLDVDZ128mb = 12367, + X86_VPSHLDVDZ128mbk = 12368, + X86_VPSHLDVDZ128mbkz = 12369, + X86_VPSHLDVDZ128mk = 12370, + X86_VPSHLDVDZ128mkz = 12371, + X86_VPSHLDVDZ128r = 12372, + X86_VPSHLDVDZ128rk = 12373, + X86_VPSHLDVDZ128rkz = 12374, + X86_VPSHLDVDZ256m = 12375, + X86_VPSHLDVDZ256mb = 12376, + X86_VPSHLDVDZ256mbk = 12377, + X86_VPSHLDVDZ256mbkz = 12378, + X86_VPSHLDVDZ256mk = 12379, + X86_VPSHLDVDZ256mkz = 12380, + X86_VPSHLDVDZ256r = 12381, + X86_VPSHLDVDZ256rk = 12382, + X86_VPSHLDVDZ256rkz = 12383, + X86_VPSHLDVDZm = 12384, + X86_VPSHLDVDZmb = 12385, + X86_VPSHLDVDZmbk = 12386, + X86_VPSHLDVDZmbkz = 12387, + X86_VPSHLDVDZmk = 12388, + X86_VPSHLDVDZmkz = 12389, + X86_VPSHLDVDZr = 12390, + X86_VPSHLDVDZrk = 12391, + X86_VPSHLDVDZrkz = 12392, + X86_VPSHLDVQZ128m = 12393, + X86_VPSHLDVQZ128mb = 12394, + X86_VPSHLDVQZ128mbk = 12395, + X86_VPSHLDVQZ128mbkz = 12396, + X86_VPSHLDVQZ128mk = 12397, + X86_VPSHLDVQZ128mkz = 12398, + X86_VPSHLDVQZ128r = 12399, + X86_VPSHLDVQZ128rk = 12400, + X86_VPSHLDVQZ128rkz = 12401, + X86_VPSHLDVQZ256m = 12402, + X86_VPSHLDVQZ256mb = 12403, + X86_VPSHLDVQZ256mbk = 12404, + X86_VPSHLDVQZ256mbkz = 12405, + X86_VPSHLDVQZ256mk = 12406, + X86_VPSHLDVQZ256mkz = 12407, + X86_VPSHLDVQZ256r = 12408, + X86_VPSHLDVQZ256rk = 12409, + X86_VPSHLDVQZ256rkz = 12410, + X86_VPSHLDVQZm = 12411, + X86_VPSHLDVQZmb = 12412, + X86_VPSHLDVQZmbk = 12413, + X86_VPSHLDVQZmbkz = 12414, + X86_VPSHLDVQZmk = 12415, + X86_VPSHLDVQZmkz = 12416, + X86_VPSHLDVQZr = 12417, + X86_VPSHLDVQZrk = 12418, + X86_VPSHLDVQZrkz = 12419, + X86_VPSHLDVWZ128m = 12420, + X86_VPSHLDVWZ128mk = 12421, + X86_VPSHLDVWZ128mkz = 12422, + X86_VPSHLDVWZ128r = 12423, + X86_VPSHLDVWZ128rk = 12424, + X86_VPSHLDVWZ128rkz = 12425, + X86_VPSHLDVWZ256m = 12426, + X86_VPSHLDVWZ256mk = 12427, + X86_VPSHLDVWZ256mkz = 12428, + X86_VPSHLDVWZ256r = 12429, + X86_VPSHLDVWZ256rk = 12430, + X86_VPSHLDVWZ256rkz = 12431, + X86_VPSHLDVWZm = 12432, + X86_VPSHLDVWZmk = 12433, + X86_VPSHLDVWZmkz = 12434, + X86_VPSHLDVWZr = 12435, + X86_VPSHLDVWZrk = 12436, + X86_VPSHLDVWZrkz = 12437, + X86_VPSHLDWZ128rmi = 12438, + X86_VPSHLDWZ128rmik = 12439, + X86_VPSHLDWZ128rmikz = 12440, + X86_VPSHLDWZ128rri = 12441, + X86_VPSHLDWZ128rrik = 12442, + X86_VPSHLDWZ128rrikz = 12443, + X86_VPSHLDWZ256rmi = 12444, + X86_VPSHLDWZ256rmik = 12445, + X86_VPSHLDWZ256rmikz = 12446, + X86_VPSHLDWZ256rri = 12447, + X86_VPSHLDWZ256rrik = 12448, + X86_VPSHLDWZ256rrikz = 12449, + X86_VPSHLDWZrmi = 12450, + X86_VPSHLDWZrmik = 12451, + X86_VPSHLDWZrmikz = 12452, + X86_VPSHLDWZrri = 12453, + X86_VPSHLDWZrrik = 12454, + X86_VPSHLDWZrrikz = 12455, + X86_VPSHLDmr = 12456, + X86_VPSHLDrm = 12457, + X86_VPSHLDrr = 12458, + X86_VPSHLDrr_REV = 12459, + X86_VPSHLQmr = 12460, + X86_VPSHLQrm = 12461, + X86_VPSHLQrr = 12462, + X86_VPSHLQrr_REV = 12463, + X86_VPSHLWmr = 12464, + X86_VPSHLWrm = 12465, + X86_VPSHLWrr = 12466, + X86_VPSHLWrr_REV = 12467, + X86_VPSHRDDZ128rmbi = 12468, + X86_VPSHRDDZ128rmbik = 12469, + X86_VPSHRDDZ128rmbikz = 12470, + X86_VPSHRDDZ128rmi = 12471, + X86_VPSHRDDZ128rmik = 12472, + X86_VPSHRDDZ128rmikz = 12473, + X86_VPSHRDDZ128rri = 12474, + X86_VPSHRDDZ128rrik = 12475, + X86_VPSHRDDZ128rrikz = 12476, + X86_VPSHRDDZ256rmbi = 12477, + X86_VPSHRDDZ256rmbik = 12478, + X86_VPSHRDDZ256rmbikz = 12479, + X86_VPSHRDDZ256rmi = 12480, + X86_VPSHRDDZ256rmik = 12481, + X86_VPSHRDDZ256rmikz = 12482, + X86_VPSHRDDZ256rri = 12483, + X86_VPSHRDDZ256rrik = 12484, + X86_VPSHRDDZ256rrikz = 12485, + X86_VPSHRDDZrmbi = 12486, + X86_VPSHRDDZrmbik = 12487, + X86_VPSHRDDZrmbikz = 12488, + X86_VPSHRDDZrmi = 12489, + X86_VPSHRDDZrmik = 12490, + X86_VPSHRDDZrmikz = 12491, + X86_VPSHRDDZrri = 12492, + X86_VPSHRDDZrrik = 12493, + X86_VPSHRDDZrrikz = 12494, + X86_VPSHRDQZ128rmbi = 12495, + X86_VPSHRDQZ128rmbik = 12496, + X86_VPSHRDQZ128rmbikz = 12497, + X86_VPSHRDQZ128rmi = 12498, + X86_VPSHRDQZ128rmik = 12499, + X86_VPSHRDQZ128rmikz = 12500, + X86_VPSHRDQZ128rri = 12501, + X86_VPSHRDQZ128rrik = 12502, + X86_VPSHRDQZ128rrikz = 12503, + X86_VPSHRDQZ256rmbi = 12504, + X86_VPSHRDQZ256rmbik = 12505, + X86_VPSHRDQZ256rmbikz = 12506, + X86_VPSHRDQZ256rmi = 12507, + X86_VPSHRDQZ256rmik = 12508, + X86_VPSHRDQZ256rmikz = 12509, + X86_VPSHRDQZ256rri = 12510, + X86_VPSHRDQZ256rrik = 12511, + X86_VPSHRDQZ256rrikz = 12512, + X86_VPSHRDQZrmbi = 12513, + X86_VPSHRDQZrmbik = 12514, + X86_VPSHRDQZrmbikz = 12515, + X86_VPSHRDQZrmi = 12516, + X86_VPSHRDQZrmik = 12517, + X86_VPSHRDQZrmikz = 12518, + X86_VPSHRDQZrri = 12519, + X86_VPSHRDQZrrik = 12520, + X86_VPSHRDQZrrikz = 12521, + X86_VPSHRDVDZ128m = 12522, + X86_VPSHRDVDZ128mb = 12523, + X86_VPSHRDVDZ128mbk = 12524, + X86_VPSHRDVDZ128mbkz = 12525, + X86_VPSHRDVDZ128mk = 12526, + X86_VPSHRDVDZ128mkz = 12527, + X86_VPSHRDVDZ128r = 12528, + X86_VPSHRDVDZ128rk = 12529, + X86_VPSHRDVDZ128rkz = 12530, + X86_VPSHRDVDZ256m = 12531, + X86_VPSHRDVDZ256mb = 12532, + X86_VPSHRDVDZ256mbk = 12533, + X86_VPSHRDVDZ256mbkz = 12534, + X86_VPSHRDVDZ256mk = 12535, + X86_VPSHRDVDZ256mkz = 12536, + X86_VPSHRDVDZ256r = 12537, + X86_VPSHRDVDZ256rk = 12538, + X86_VPSHRDVDZ256rkz = 12539, + X86_VPSHRDVDZm = 12540, + X86_VPSHRDVDZmb = 12541, + X86_VPSHRDVDZmbk = 12542, + X86_VPSHRDVDZmbkz = 12543, + X86_VPSHRDVDZmk = 12544, + X86_VPSHRDVDZmkz = 12545, + X86_VPSHRDVDZr = 12546, + X86_VPSHRDVDZrk = 12547, + X86_VPSHRDVDZrkz = 12548, + X86_VPSHRDVQZ128m = 12549, + X86_VPSHRDVQZ128mb = 12550, + X86_VPSHRDVQZ128mbk = 12551, + X86_VPSHRDVQZ128mbkz = 12552, + X86_VPSHRDVQZ128mk = 12553, + X86_VPSHRDVQZ128mkz = 12554, + X86_VPSHRDVQZ128r = 12555, + X86_VPSHRDVQZ128rk = 12556, + X86_VPSHRDVQZ128rkz = 12557, + X86_VPSHRDVQZ256m = 12558, + X86_VPSHRDVQZ256mb = 12559, + X86_VPSHRDVQZ256mbk = 12560, + X86_VPSHRDVQZ256mbkz = 12561, + X86_VPSHRDVQZ256mk = 12562, + X86_VPSHRDVQZ256mkz = 12563, + X86_VPSHRDVQZ256r = 12564, + X86_VPSHRDVQZ256rk = 12565, + X86_VPSHRDVQZ256rkz = 12566, + X86_VPSHRDVQZm = 12567, + X86_VPSHRDVQZmb = 12568, + X86_VPSHRDVQZmbk = 12569, + X86_VPSHRDVQZmbkz = 12570, + X86_VPSHRDVQZmk = 12571, + X86_VPSHRDVQZmkz = 12572, + X86_VPSHRDVQZr = 12573, + X86_VPSHRDVQZrk = 12574, + X86_VPSHRDVQZrkz = 12575, + X86_VPSHRDVWZ128m = 12576, + X86_VPSHRDVWZ128mk = 12577, + X86_VPSHRDVWZ128mkz = 12578, + X86_VPSHRDVWZ128r = 12579, + X86_VPSHRDVWZ128rk = 12580, + X86_VPSHRDVWZ128rkz = 12581, + X86_VPSHRDVWZ256m = 12582, + X86_VPSHRDVWZ256mk = 12583, + X86_VPSHRDVWZ256mkz = 12584, + X86_VPSHRDVWZ256r = 12585, + X86_VPSHRDVWZ256rk = 12586, + X86_VPSHRDVWZ256rkz = 12587, + X86_VPSHRDVWZm = 12588, + X86_VPSHRDVWZmk = 12589, + X86_VPSHRDVWZmkz = 12590, + X86_VPSHRDVWZr = 12591, + X86_VPSHRDVWZrk = 12592, + X86_VPSHRDVWZrkz = 12593, + X86_VPSHRDWZ128rmi = 12594, + X86_VPSHRDWZ128rmik = 12595, + X86_VPSHRDWZ128rmikz = 12596, + X86_VPSHRDWZ128rri = 12597, + X86_VPSHRDWZ128rrik = 12598, + X86_VPSHRDWZ128rrikz = 12599, + X86_VPSHRDWZ256rmi = 12600, + X86_VPSHRDWZ256rmik = 12601, + X86_VPSHRDWZ256rmikz = 12602, + X86_VPSHRDWZ256rri = 12603, + X86_VPSHRDWZ256rrik = 12604, + X86_VPSHRDWZ256rrikz = 12605, + X86_VPSHRDWZrmi = 12606, + X86_VPSHRDWZrmik = 12607, + X86_VPSHRDWZrmikz = 12608, + X86_VPSHRDWZrri = 12609, + X86_VPSHRDWZrrik = 12610, + X86_VPSHRDWZrrikz = 12611, + X86_VPSHUFBITQMBZ128rm = 12612, + X86_VPSHUFBITQMBZ128rmk = 12613, + X86_VPSHUFBITQMBZ128rr = 12614, + X86_VPSHUFBITQMBZ128rrk = 12615, + X86_VPSHUFBITQMBZ256rm = 12616, + X86_VPSHUFBITQMBZ256rmk = 12617, + X86_VPSHUFBITQMBZ256rr = 12618, + X86_VPSHUFBITQMBZ256rrk = 12619, + X86_VPSHUFBITQMBZrm = 12620, + X86_VPSHUFBITQMBZrmk = 12621, + X86_VPSHUFBITQMBZrr = 12622, + X86_VPSHUFBITQMBZrrk = 12623, + X86_VPSHUFBYrm = 12624, + X86_VPSHUFBYrr = 12625, + X86_VPSHUFBZ128rm = 12626, + X86_VPSHUFBZ128rmk = 12627, + X86_VPSHUFBZ128rmkz = 12628, + X86_VPSHUFBZ128rr = 12629, + X86_VPSHUFBZ128rrk = 12630, + X86_VPSHUFBZ128rrkz = 12631, + X86_VPSHUFBZ256rm = 12632, + X86_VPSHUFBZ256rmk = 12633, + X86_VPSHUFBZ256rmkz = 12634, + X86_VPSHUFBZ256rr = 12635, + X86_VPSHUFBZ256rrk = 12636, + X86_VPSHUFBZ256rrkz = 12637, + X86_VPSHUFBZrm = 12638, + X86_VPSHUFBZrmk = 12639, + X86_VPSHUFBZrmkz = 12640, + X86_VPSHUFBZrr = 12641, + X86_VPSHUFBZrrk = 12642, + X86_VPSHUFBZrrkz = 12643, + X86_VPSHUFBrm = 12644, + X86_VPSHUFBrr = 12645, + X86_VPSHUFDYmi = 12646, + X86_VPSHUFDYri = 12647, + X86_VPSHUFDZ128mbi = 12648, + X86_VPSHUFDZ128mbik = 12649, + X86_VPSHUFDZ128mbikz = 12650, + X86_VPSHUFDZ128mi = 12651, + X86_VPSHUFDZ128mik = 12652, + X86_VPSHUFDZ128mikz = 12653, + X86_VPSHUFDZ128ri = 12654, + X86_VPSHUFDZ128rik = 12655, + X86_VPSHUFDZ128rikz = 12656, + X86_VPSHUFDZ256mbi = 12657, + X86_VPSHUFDZ256mbik = 12658, + X86_VPSHUFDZ256mbikz = 12659, + X86_VPSHUFDZ256mi = 12660, + X86_VPSHUFDZ256mik = 12661, + X86_VPSHUFDZ256mikz = 12662, + X86_VPSHUFDZ256ri = 12663, + X86_VPSHUFDZ256rik = 12664, + X86_VPSHUFDZ256rikz = 12665, + X86_VPSHUFDZmbi = 12666, + X86_VPSHUFDZmbik = 12667, + X86_VPSHUFDZmbikz = 12668, + X86_VPSHUFDZmi = 12669, + X86_VPSHUFDZmik = 12670, + X86_VPSHUFDZmikz = 12671, + X86_VPSHUFDZri = 12672, + X86_VPSHUFDZrik = 12673, + X86_VPSHUFDZrikz = 12674, + X86_VPSHUFDmi = 12675, + X86_VPSHUFDri = 12676, + X86_VPSHUFHWYmi = 12677, + X86_VPSHUFHWYri = 12678, + X86_VPSHUFHWZ128mi = 12679, + X86_VPSHUFHWZ128mik = 12680, + X86_VPSHUFHWZ128mikz = 12681, + X86_VPSHUFHWZ128ri = 12682, + X86_VPSHUFHWZ128rik = 12683, + X86_VPSHUFHWZ128rikz = 12684, + X86_VPSHUFHWZ256mi = 12685, + X86_VPSHUFHWZ256mik = 12686, + X86_VPSHUFHWZ256mikz = 12687, + X86_VPSHUFHWZ256ri = 12688, + X86_VPSHUFHWZ256rik = 12689, + X86_VPSHUFHWZ256rikz = 12690, + X86_VPSHUFHWZmi = 12691, + X86_VPSHUFHWZmik = 12692, + X86_VPSHUFHWZmikz = 12693, + X86_VPSHUFHWZri = 12694, + X86_VPSHUFHWZrik = 12695, + X86_VPSHUFHWZrikz = 12696, + X86_VPSHUFHWmi = 12697, + X86_VPSHUFHWri = 12698, + X86_VPSHUFLWYmi = 12699, + X86_VPSHUFLWYri = 12700, + X86_VPSHUFLWZ128mi = 12701, + X86_VPSHUFLWZ128mik = 12702, + X86_VPSHUFLWZ128mikz = 12703, + X86_VPSHUFLWZ128ri = 12704, + X86_VPSHUFLWZ128rik = 12705, + X86_VPSHUFLWZ128rikz = 12706, + X86_VPSHUFLWZ256mi = 12707, + X86_VPSHUFLWZ256mik = 12708, + X86_VPSHUFLWZ256mikz = 12709, + X86_VPSHUFLWZ256ri = 12710, + X86_VPSHUFLWZ256rik = 12711, + X86_VPSHUFLWZ256rikz = 12712, + X86_VPSHUFLWZmi = 12713, + X86_VPSHUFLWZmik = 12714, + X86_VPSHUFLWZmikz = 12715, + X86_VPSHUFLWZri = 12716, + X86_VPSHUFLWZrik = 12717, + X86_VPSHUFLWZrikz = 12718, + X86_VPSHUFLWmi = 12719, + X86_VPSHUFLWri = 12720, + X86_VPSIGNBYrm = 12721, + X86_VPSIGNBYrr = 12722, + X86_VPSIGNBrm = 12723, + X86_VPSIGNBrr = 12724, + X86_VPSIGNDYrm = 12725, + X86_VPSIGNDYrr = 12726, + X86_VPSIGNDrm = 12727, + X86_VPSIGNDrr = 12728, + X86_VPSIGNWYrm = 12729, + X86_VPSIGNWYrr = 12730, + X86_VPSIGNWrm = 12731, + X86_VPSIGNWrr = 12732, + X86_VPSLLDQYri = 12733, + X86_VPSLLDQZ128rm = 12734, + X86_VPSLLDQZ128rr = 12735, + X86_VPSLLDQZ256rm = 12736, + X86_VPSLLDQZ256rr = 12737, + X86_VPSLLDQZrm = 12738, + X86_VPSLLDQZrr = 12739, + X86_VPSLLDQri = 12740, + X86_VPSLLDYri = 12741, + X86_VPSLLDYrm = 12742, + X86_VPSLLDYrr = 12743, + X86_VPSLLDZ128mbi = 12744, + X86_VPSLLDZ128mbik = 12745, + X86_VPSLLDZ128mbikz = 12746, + X86_VPSLLDZ128mi = 12747, + X86_VPSLLDZ128mik = 12748, + X86_VPSLLDZ128mikz = 12749, + X86_VPSLLDZ128ri = 12750, + X86_VPSLLDZ128rik = 12751, + X86_VPSLLDZ128rikz = 12752, + X86_VPSLLDZ128rm = 12753, + X86_VPSLLDZ128rmk = 12754, + X86_VPSLLDZ128rmkz = 12755, + X86_VPSLLDZ128rr = 12756, + X86_VPSLLDZ128rrk = 12757, + X86_VPSLLDZ128rrkz = 12758, + X86_VPSLLDZ256mbi = 12759, + X86_VPSLLDZ256mbik = 12760, + X86_VPSLLDZ256mbikz = 12761, + X86_VPSLLDZ256mi = 12762, + X86_VPSLLDZ256mik = 12763, + X86_VPSLLDZ256mikz = 12764, + X86_VPSLLDZ256ri = 12765, + X86_VPSLLDZ256rik = 12766, + X86_VPSLLDZ256rikz = 12767, + X86_VPSLLDZ256rm = 12768, + X86_VPSLLDZ256rmk = 12769, + X86_VPSLLDZ256rmkz = 12770, + X86_VPSLLDZ256rr = 12771, + X86_VPSLLDZ256rrk = 12772, + X86_VPSLLDZ256rrkz = 12773, + X86_VPSLLDZmbi = 12774, + X86_VPSLLDZmbik = 12775, + X86_VPSLLDZmbikz = 12776, + X86_VPSLLDZmi = 12777, + X86_VPSLLDZmik = 12778, + X86_VPSLLDZmikz = 12779, + X86_VPSLLDZri = 12780, + X86_VPSLLDZrik = 12781, + X86_VPSLLDZrikz = 12782, + X86_VPSLLDZrm = 12783, + X86_VPSLLDZrmk = 12784, + X86_VPSLLDZrmkz = 12785, + X86_VPSLLDZrr = 12786, + X86_VPSLLDZrrk = 12787, + X86_VPSLLDZrrkz = 12788, + X86_VPSLLDri = 12789, + X86_VPSLLDrm = 12790, + X86_VPSLLDrr = 12791, + X86_VPSLLQYri = 12792, + X86_VPSLLQYrm = 12793, + X86_VPSLLQYrr = 12794, + X86_VPSLLQZ128mbi = 12795, + X86_VPSLLQZ128mbik = 12796, + X86_VPSLLQZ128mbikz = 12797, + X86_VPSLLQZ128mi = 12798, + X86_VPSLLQZ128mik = 12799, + X86_VPSLLQZ128mikz = 12800, + X86_VPSLLQZ128ri = 12801, + X86_VPSLLQZ128rik = 12802, + X86_VPSLLQZ128rikz = 12803, + X86_VPSLLQZ128rm = 12804, + X86_VPSLLQZ128rmk = 12805, + X86_VPSLLQZ128rmkz = 12806, + X86_VPSLLQZ128rr = 12807, + X86_VPSLLQZ128rrk = 12808, + X86_VPSLLQZ128rrkz = 12809, + X86_VPSLLQZ256mbi = 12810, + X86_VPSLLQZ256mbik = 12811, + X86_VPSLLQZ256mbikz = 12812, + X86_VPSLLQZ256mi = 12813, + X86_VPSLLQZ256mik = 12814, + X86_VPSLLQZ256mikz = 12815, + X86_VPSLLQZ256ri = 12816, + X86_VPSLLQZ256rik = 12817, + X86_VPSLLQZ256rikz = 12818, + X86_VPSLLQZ256rm = 12819, + X86_VPSLLQZ256rmk = 12820, + X86_VPSLLQZ256rmkz = 12821, + X86_VPSLLQZ256rr = 12822, + X86_VPSLLQZ256rrk = 12823, + X86_VPSLLQZ256rrkz = 12824, + X86_VPSLLQZmbi = 12825, + X86_VPSLLQZmbik = 12826, + X86_VPSLLQZmbikz = 12827, + X86_VPSLLQZmi = 12828, + X86_VPSLLQZmik = 12829, + X86_VPSLLQZmikz = 12830, + X86_VPSLLQZri = 12831, + X86_VPSLLQZrik = 12832, + X86_VPSLLQZrikz = 12833, + X86_VPSLLQZrm = 12834, + X86_VPSLLQZrmk = 12835, + X86_VPSLLQZrmkz = 12836, + X86_VPSLLQZrr = 12837, + X86_VPSLLQZrrk = 12838, + X86_VPSLLQZrrkz = 12839, + X86_VPSLLQri = 12840, + X86_VPSLLQrm = 12841, + X86_VPSLLQrr = 12842, + X86_VPSLLVDYrm = 12843, + X86_VPSLLVDYrr = 12844, + X86_VPSLLVDZ128rm = 12845, + X86_VPSLLVDZ128rmb = 12846, + X86_VPSLLVDZ128rmbk = 12847, + X86_VPSLLVDZ128rmbkz = 12848, + X86_VPSLLVDZ128rmk = 12849, + X86_VPSLLVDZ128rmkz = 12850, + X86_VPSLLVDZ128rr = 12851, + X86_VPSLLVDZ128rrk = 12852, + X86_VPSLLVDZ128rrkz = 12853, + X86_VPSLLVDZ256rm = 12854, + X86_VPSLLVDZ256rmb = 12855, + X86_VPSLLVDZ256rmbk = 12856, + X86_VPSLLVDZ256rmbkz = 12857, + X86_VPSLLVDZ256rmk = 12858, + X86_VPSLLVDZ256rmkz = 12859, + X86_VPSLLVDZ256rr = 12860, + X86_VPSLLVDZ256rrk = 12861, + X86_VPSLLVDZ256rrkz = 12862, + X86_VPSLLVDZrm = 12863, + X86_VPSLLVDZrmb = 12864, + X86_VPSLLVDZrmbk = 12865, + X86_VPSLLVDZrmbkz = 12866, + X86_VPSLLVDZrmk = 12867, + X86_VPSLLVDZrmkz = 12868, + X86_VPSLLVDZrr = 12869, + X86_VPSLLVDZrrk = 12870, + X86_VPSLLVDZrrkz = 12871, + X86_VPSLLVDrm = 12872, + X86_VPSLLVDrr = 12873, + X86_VPSLLVQYrm = 12874, + X86_VPSLLVQYrr = 12875, + X86_VPSLLVQZ128rm = 12876, + X86_VPSLLVQZ128rmb = 12877, + X86_VPSLLVQZ128rmbk = 12878, + X86_VPSLLVQZ128rmbkz = 12879, + X86_VPSLLVQZ128rmk = 12880, + X86_VPSLLVQZ128rmkz = 12881, + X86_VPSLLVQZ128rr = 12882, + X86_VPSLLVQZ128rrk = 12883, + X86_VPSLLVQZ128rrkz = 12884, + X86_VPSLLVQZ256rm = 12885, + X86_VPSLLVQZ256rmb = 12886, + X86_VPSLLVQZ256rmbk = 12887, + X86_VPSLLVQZ256rmbkz = 12888, + X86_VPSLLVQZ256rmk = 12889, + X86_VPSLLVQZ256rmkz = 12890, + X86_VPSLLVQZ256rr = 12891, + X86_VPSLLVQZ256rrk = 12892, + X86_VPSLLVQZ256rrkz = 12893, + X86_VPSLLVQZrm = 12894, + X86_VPSLLVQZrmb = 12895, + X86_VPSLLVQZrmbk = 12896, + X86_VPSLLVQZrmbkz = 12897, + X86_VPSLLVQZrmk = 12898, + X86_VPSLLVQZrmkz = 12899, + X86_VPSLLVQZrr = 12900, + X86_VPSLLVQZrrk = 12901, + X86_VPSLLVQZrrkz = 12902, + X86_VPSLLVQrm = 12903, + X86_VPSLLVQrr = 12904, + X86_VPSLLVWZ128rm = 12905, + X86_VPSLLVWZ128rmk = 12906, + X86_VPSLLVWZ128rmkz = 12907, + X86_VPSLLVWZ128rr = 12908, + X86_VPSLLVWZ128rrk = 12909, + X86_VPSLLVWZ128rrkz = 12910, + X86_VPSLLVWZ256rm = 12911, + X86_VPSLLVWZ256rmk = 12912, + X86_VPSLLVWZ256rmkz = 12913, + X86_VPSLLVWZ256rr = 12914, + X86_VPSLLVWZ256rrk = 12915, + X86_VPSLLVWZ256rrkz = 12916, + X86_VPSLLVWZrm = 12917, + X86_VPSLLVWZrmk = 12918, + X86_VPSLLVWZrmkz = 12919, + X86_VPSLLVWZrr = 12920, + X86_VPSLLVWZrrk = 12921, + X86_VPSLLVWZrrkz = 12922, + X86_VPSLLWYri = 12923, + X86_VPSLLWYrm = 12924, + X86_VPSLLWYrr = 12925, + X86_VPSLLWZ128mi = 12926, + X86_VPSLLWZ128mik = 12927, + X86_VPSLLWZ128mikz = 12928, + X86_VPSLLWZ128ri = 12929, + X86_VPSLLWZ128rik = 12930, + X86_VPSLLWZ128rikz = 12931, + X86_VPSLLWZ128rm = 12932, + X86_VPSLLWZ128rmk = 12933, + X86_VPSLLWZ128rmkz = 12934, + X86_VPSLLWZ128rr = 12935, + X86_VPSLLWZ128rrk = 12936, + X86_VPSLLWZ128rrkz = 12937, + X86_VPSLLWZ256mi = 12938, + X86_VPSLLWZ256mik = 12939, + X86_VPSLLWZ256mikz = 12940, + X86_VPSLLWZ256ri = 12941, + X86_VPSLLWZ256rik = 12942, + X86_VPSLLWZ256rikz = 12943, + X86_VPSLLWZ256rm = 12944, + X86_VPSLLWZ256rmk = 12945, + X86_VPSLLWZ256rmkz = 12946, + X86_VPSLLWZ256rr = 12947, + X86_VPSLLWZ256rrk = 12948, + X86_VPSLLWZ256rrkz = 12949, + X86_VPSLLWZmi = 12950, + X86_VPSLLWZmik = 12951, + X86_VPSLLWZmikz = 12952, + X86_VPSLLWZri = 12953, + X86_VPSLLWZrik = 12954, + X86_VPSLLWZrikz = 12955, + X86_VPSLLWZrm = 12956, + X86_VPSLLWZrmk = 12957, + X86_VPSLLWZrmkz = 12958, + X86_VPSLLWZrr = 12959, + X86_VPSLLWZrrk = 12960, + X86_VPSLLWZrrkz = 12961, + X86_VPSLLWri = 12962, + X86_VPSLLWrm = 12963, + X86_VPSLLWrr = 12964, + X86_VPSRADYri = 12965, + X86_VPSRADYrm = 12966, + X86_VPSRADYrr = 12967, + X86_VPSRADZ128mbi = 12968, + X86_VPSRADZ128mbik = 12969, + X86_VPSRADZ128mbikz = 12970, + X86_VPSRADZ128mi = 12971, + X86_VPSRADZ128mik = 12972, + X86_VPSRADZ128mikz = 12973, + X86_VPSRADZ128ri = 12974, + X86_VPSRADZ128rik = 12975, + X86_VPSRADZ128rikz = 12976, + X86_VPSRADZ128rm = 12977, + X86_VPSRADZ128rmk = 12978, + X86_VPSRADZ128rmkz = 12979, + X86_VPSRADZ128rr = 12980, + X86_VPSRADZ128rrk = 12981, + X86_VPSRADZ128rrkz = 12982, + X86_VPSRADZ256mbi = 12983, + X86_VPSRADZ256mbik = 12984, + X86_VPSRADZ256mbikz = 12985, + X86_VPSRADZ256mi = 12986, + X86_VPSRADZ256mik = 12987, + X86_VPSRADZ256mikz = 12988, + X86_VPSRADZ256ri = 12989, + X86_VPSRADZ256rik = 12990, + X86_VPSRADZ256rikz = 12991, + X86_VPSRADZ256rm = 12992, + X86_VPSRADZ256rmk = 12993, + X86_VPSRADZ256rmkz = 12994, + X86_VPSRADZ256rr = 12995, + X86_VPSRADZ256rrk = 12996, + X86_VPSRADZ256rrkz = 12997, + X86_VPSRADZmbi = 12998, + X86_VPSRADZmbik = 12999, + X86_VPSRADZmbikz = 13000, + X86_VPSRADZmi = 13001, + X86_VPSRADZmik = 13002, + X86_VPSRADZmikz = 13003, + X86_VPSRADZri = 13004, + X86_VPSRADZrik = 13005, + X86_VPSRADZrikz = 13006, + X86_VPSRADZrm = 13007, + X86_VPSRADZrmk = 13008, + X86_VPSRADZrmkz = 13009, + X86_VPSRADZrr = 13010, + X86_VPSRADZrrk = 13011, + X86_VPSRADZrrkz = 13012, + X86_VPSRADri = 13013, + X86_VPSRADrm = 13014, + X86_VPSRADrr = 13015, + X86_VPSRAQZ128mbi = 13016, + X86_VPSRAQZ128mbik = 13017, + X86_VPSRAQZ128mbikz = 13018, + X86_VPSRAQZ128mi = 13019, + X86_VPSRAQZ128mik = 13020, + X86_VPSRAQZ128mikz = 13021, + X86_VPSRAQZ128ri = 13022, + X86_VPSRAQZ128rik = 13023, + X86_VPSRAQZ128rikz = 13024, + X86_VPSRAQZ128rm = 13025, + X86_VPSRAQZ128rmk = 13026, + X86_VPSRAQZ128rmkz = 13027, + X86_VPSRAQZ128rr = 13028, + X86_VPSRAQZ128rrk = 13029, + X86_VPSRAQZ128rrkz = 13030, + X86_VPSRAQZ256mbi = 13031, + X86_VPSRAQZ256mbik = 13032, + X86_VPSRAQZ256mbikz = 13033, + X86_VPSRAQZ256mi = 13034, + X86_VPSRAQZ256mik = 13035, + X86_VPSRAQZ256mikz = 13036, + X86_VPSRAQZ256ri = 13037, + X86_VPSRAQZ256rik = 13038, + X86_VPSRAQZ256rikz = 13039, + X86_VPSRAQZ256rm = 13040, + X86_VPSRAQZ256rmk = 13041, + X86_VPSRAQZ256rmkz = 13042, + X86_VPSRAQZ256rr = 13043, + X86_VPSRAQZ256rrk = 13044, + X86_VPSRAQZ256rrkz = 13045, + X86_VPSRAQZmbi = 13046, + X86_VPSRAQZmbik = 13047, + X86_VPSRAQZmbikz = 13048, + X86_VPSRAQZmi = 13049, + X86_VPSRAQZmik = 13050, + X86_VPSRAQZmikz = 13051, + X86_VPSRAQZri = 13052, + X86_VPSRAQZrik = 13053, + X86_VPSRAQZrikz = 13054, + X86_VPSRAQZrm = 13055, + X86_VPSRAQZrmk = 13056, + X86_VPSRAQZrmkz = 13057, + X86_VPSRAQZrr = 13058, + X86_VPSRAQZrrk = 13059, + X86_VPSRAQZrrkz = 13060, + X86_VPSRAVDYrm = 13061, + X86_VPSRAVDYrr = 13062, + X86_VPSRAVDZ128rm = 13063, + X86_VPSRAVDZ128rmb = 13064, + X86_VPSRAVDZ128rmbk = 13065, + X86_VPSRAVDZ128rmbkz = 13066, + X86_VPSRAVDZ128rmk = 13067, + X86_VPSRAVDZ128rmkz = 13068, + X86_VPSRAVDZ128rr = 13069, + X86_VPSRAVDZ128rrk = 13070, + X86_VPSRAVDZ128rrkz = 13071, + X86_VPSRAVDZ256rm = 13072, + X86_VPSRAVDZ256rmb = 13073, + X86_VPSRAVDZ256rmbk = 13074, + X86_VPSRAVDZ256rmbkz = 13075, + X86_VPSRAVDZ256rmk = 13076, + X86_VPSRAVDZ256rmkz = 13077, + X86_VPSRAVDZ256rr = 13078, + X86_VPSRAVDZ256rrk = 13079, + X86_VPSRAVDZ256rrkz = 13080, + X86_VPSRAVDZrm = 13081, + X86_VPSRAVDZrmb = 13082, + X86_VPSRAVDZrmbk = 13083, + X86_VPSRAVDZrmbkz = 13084, + X86_VPSRAVDZrmk = 13085, + X86_VPSRAVDZrmkz = 13086, + X86_VPSRAVDZrr = 13087, + X86_VPSRAVDZrrk = 13088, + X86_VPSRAVDZrrkz = 13089, + X86_VPSRAVDrm = 13090, + X86_VPSRAVDrr = 13091, + X86_VPSRAVQZ128rm = 13092, + X86_VPSRAVQZ128rmb = 13093, + X86_VPSRAVQZ128rmbk = 13094, + X86_VPSRAVQZ128rmbkz = 13095, + X86_VPSRAVQZ128rmk = 13096, + X86_VPSRAVQZ128rmkz = 13097, + X86_VPSRAVQZ128rr = 13098, + X86_VPSRAVQZ128rrk = 13099, + X86_VPSRAVQZ128rrkz = 13100, + X86_VPSRAVQZ256rm = 13101, + X86_VPSRAVQZ256rmb = 13102, + X86_VPSRAVQZ256rmbk = 13103, + X86_VPSRAVQZ256rmbkz = 13104, + X86_VPSRAVQZ256rmk = 13105, + X86_VPSRAVQZ256rmkz = 13106, + X86_VPSRAVQZ256rr = 13107, + X86_VPSRAVQZ256rrk = 13108, + X86_VPSRAVQZ256rrkz = 13109, + X86_VPSRAVQZrm = 13110, + X86_VPSRAVQZrmb = 13111, + X86_VPSRAVQZrmbk = 13112, + X86_VPSRAVQZrmbkz = 13113, + X86_VPSRAVQZrmk = 13114, + X86_VPSRAVQZrmkz = 13115, + X86_VPSRAVQZrr = 13116, + X86_VPSRAVQZrrk = 13117, + X86_VPSRAVQZrrkz = 13118, + X86_VPSRAVWZ128rm = 13119, + X86_VPSRAVWZ128rmk = 13120, + X86_VPSRAVWZ128rmkz = 13121, + X86_VPSRAVWZ128rr = 13122, + X86_VPSRAVWZ128rrk = 13123, + X86_VPSRAVWZ128rrkz = 13124, + X86_VPSRAVWZ256rm = 13125, + X86_VPSRAVWZ256rmk = 13126, + X86_VPSRAVWZ256rmkz = 13127, + X86_VPSRAVWZ256rr = 13128, + X86_VPSRAVWZ256rrk = 13129, + X86_VPSRAVWZ256rrkz = 13130, + X86_VPSRAVWZrm = 13131, + X86_VPSRAVWZrmk = 13132, + X86_VPSRAVWZrmkz = 13133, + X86_VPSRAVWZrr = 13134, + X86_VPSRAVWZrrk = 13135, + X86_VPSRAVWZrrkz = 13136, + X86_VPSRAWYri = 13137, + X86_VPSRAWYrm = 13138, + X86_VPSRAWYrr = 13139, + X86_VPSRAWZ128mi = 13140, + X86_VPSRAWZ128mik = 13141, + X86_VPSRAWZ128mikz = 13142, + X86_VPSRAWZ128ri = 13143, + X86_VPSRAWZ128rik = 13144, + X86_VPSRAWZ128rikz = 13145, + X86_VPSRAWZ128rm = 13146, + X86_VPSRAWZ128rmk = 13147, + X86_VPSRAWZ128rmkz = 13148, + X86_VPSRAWZ128rr = 13149, + X86_VPSRAWZ128rrk = 13150, + X86_VPSRAWZ128rrkz = 13151, + X86_VPSRAWZ256mi = 13152, + X86_VPSRAWZ256mik = 13153, + X86_VPSRAWZ256mikz = 13154, + X86_VPSRAWZ256ri = 13155, + X86_VPSRAWZ256rik = 13156, + X86_VPSRAWZ256rikz = 13157, + X86_VPSRAWZ256rm = 13158, + X86_VPSRAWZ256rmk = 13159, + X86_VPSRAWZ256rmkz = 13160, + X86_VPSRAWZ256rr = 13161, + X86_VPSRAWZ256rrk = 13162, + X86_VPSRAWZ256rrkz = 13163, + X86_VPSRAWZmi = 13164, + X86_VPSRAWZmik = 13165, + X86_VPSRAWZmikz = 13166, + X86_VPSRAWZri = 13167, + X86_VPSRAWZrik = 13168, + X86_VPSRAWZrikz = 13169, + X86_VPSRAWZrm = 13170, + X86_VPSRAWZrmk = 13171, + X86_VPSRAWZrmkz = 13172, + X86_VPSRAWZrr = 13173, + X86_VPSRAWZrrk = 13174, + X86_VPSRAWZrrkz = 13175, + X86_VPSRAWri = 13176, + X86_VPSRAWrm = 13177, + X86_VPSRAWrr = 13178, + X86_VPSRLDQYri = 13179, + X86_VPSRLDQZ128rm = 13180, + X86_VPSRLDQZ128rr = 13181, + X86_VPSRLDQZ256rm = 13182, + X86_VPSRLDQZ256rr = 13183, + X86_VPSRLDQZrm = 13184, + X86_VPSRLDQZrr = 13185, + X86_VPSRLDQri = 13186, + X86_VPSRLDYri = 13187, + X86_VPSRLDYrm = 13188, + X86_VPSRLDYrr = 13189, + X86_VPSRLDZ128mbi = 13190, + X86_VPSRLDZ128mbik = 13191, + X86_VPSRLDZ128mbikz = 13192, + X86_VPSRLDZ128mi = 13193, + X86_VPSRLDZ128mik = 13194, + X86_VPSRLDZ128mikz = 13195, + X86_VPSRLDZ128ri = 13196, + X86_VPSRLDZ128rik = 13197, + X86_VPSRLDZ128rikz = 13198, + X86_VPSRLDZ128rm = 13199, + X86_VPSRLDZ128rmk = 13200, + X86_VPSRLDZ128rmkz = 13201, + X86_VPSRLDZ128rr = 13202, + X86_VPSRLDZ128rrk = 13203, + X86_VPSRLDZ128rrkz = 13204, + X86_VPSRLDZ256mbi = 13205, + X86_VPSRLDZ256mbik = 13206, + X86_VPSRLDZ256mbikz = 13207, + X86_VPSRLDZ256mi = 13208, + X86_VPSRLDZ256mik = 13209, + X86_VPSRLDZ256mikz = 13210, + X86_VPSRLDZ256ri = 13211, + X86_VPSRLDZ256rik = 13212, + X86_VPSRLDZ256rikz = 13213, + X86_VPSRLDZ256rm = 13214, + X86_VPSRLDZ256rmk = 13215, + X86_VPSRLDZ256rmkz = 13216, + X86_VPSRLDZ256rr = 13217, + X86_VPSRLDZ256rrk = 13218, + X86_VPSRLDZ256rrkz = 13219, + X86_VPSRLDZmbi = 13220, + X86_VPSRLDZmbik = 13221, + X86_VPSRLDZmbikz = 13222, + X86_VPSRLDZmi = 13223, + X86_VPSRLDZmik = 13224, + X86_VPSRLDZmikz = 13225, + X86_VPSRLDZri = 13226, + X86_VPSRLDZrik = 13227, + X86_VPSRLDZrikz = 13228, + X86_VPSRLDZrm = 13229, + X86_VPSRLDZrmk = 13230, + X86_VPSRLDZrmkz = 13231, + X86_VPSRLDZrr = 13232, + X86_VPSRLDZrrk = 13233, + X86_VPSRLDZrrkz = 13234, + X86_VPSRLDri = 13235, + X86_VPSRLDrm = 13236, + X86_VPSRLDrr = 13237, + X86_VPSRLQYri = 13238, + X86_VPSRLQYrm = 13239, + X86_VPSRLQYrr = 13240, + X86_VPSRLQZ128mbi = 13241, + X86_VPSRLQZ128mbik = 13242, + X86_VPSRLQZ128mbikz = 13243, + X86_VPSRLQZ128mi = 13244, + X86_VPSRLQZ128mik = 13245, + X86_VPSRLQZ128mikz = 13246, + X86_VPSRLQZ128ri = 13247, + X86_VPSRLQZ128rik = 13248, + X86_VPSRLQZ128rikz = 13249, + X86_VPSRLQZ128rm = 13250, + X86_VPSRLQZ128rmk = 13251, + X86_VPSRLQZ128rmkz = 13252, + X86_VPSRLQZ128rr = 13253, + X86_VPSRLQZ128rrk = 13254, + X86_VPSRLQZ128rrkz = 13255, + X86_VPSRLQZ256mbi = 13256, + X86_VPSRLQZ256mbik = 13257, + X86_VPSRLQZ256mbikz = 13258, + X86_VPSRLQZ256mi = 13259, + X86_VPSRLQZ256mik = 13260, + X86_VPSRLQZ256mikz = 13261, + X86_VPSRLQZ256ri = 13262, + X86_VPSRLQZ256rik = 13263, + X86_VPSRLQZ256rikz = 13264, + X86_VPSRLQZ256rm = 13265, + X86_VPSRLQZ256rmk = 13266, + X86_VPSRLQZ256rmkz = 13267, + X86_VPSRLQZ256rr = 13268, + X86_VPSRLQZ256rrk = 13269, + X86_VPSRLQZ256rrkz = 13270, + X86_VPSRLQZmbi = 13271, + X86_VPSRLQZmbik = 13272, + X86_VPSRLQZmbikz = 13273, + X86_VPSRLQZmi = 13274, + X86_VPSRLQZmik = 13275, + X86_VPSRLQZmikz = 13276, + X86_VPSRLQZri = 13277, + X86_VPSRLQZrik = 13278, + X86_VPSRLQZrikz = 13279, + X86_VPSRLQZrm = 13280, + X86_VPSRLQZrmk = 13281, + X86_VPSRLQZrmkz = 13282, + X86_VPSRLQZrr = 13283, + X86_VPSRLQZrrk = 13284, + X86_VPSRLQZrrkz = 13285, + X86_VPSRLQri = 13286, + X86_VPSRLQrm = 13287, + X86_VPSRLQrr = 13288, + X86_VPSRLVDYrm = 13289, + X86_VPSRLVDYrr = 13290, + X86_VPSRLVDZ128rm = 13291, + X86_VPSRLVDZ128rmb = 13292, + X86_VPSRLVDZ128rmbk = 13293, + X86_VPSRLVDZ128rmbkz = 13294, + X86_VPSRLVDZ128rmk = 13295, + X86_VPSRLVDZ128rmkz = 13296, + X86_VPSRLVDZ128rr = 13297, + X86_VPSRLVDZ128rrk = 13298, + X86_VPSRLVDZ128rrkz = 13299, + X86_VPSRLVDZ256rm = 13300, + X86_VPSRLVDZ256rmb = 13301, + X86_VPSRLVDZ256rmbk = 13302, + X86_VPSRLVDZ256rmbkz = 13303, + X86_VPSRLVDZ256rmk = 13304, + X86_VPSRLVDZ256rmkz = 13305, + X86_VPSRLVDZ256rr = 13306, + X86_VPSRLVDZ256rrk = 13307, + X86_VPSRLVDZ256rrkz = 13308, + X86_VPSRLVDZrm = 13309, + X86_VPSRLVDZrmb = 13310, + X86_VPSRLVDZrmbk = 13311, + X86_VPSRLVDZrmbkz = 13312, + X86_VPSRLVDZrmk = 13313, + X86_VPSRLVDZrmkz = 13314, + X86_VPSRLVDZrr = 13315, + X86_VPSRLVDZrrk = 13316, + X86_VPSRLVDZrrkz = 13317, + X86_VPSRLVDrm = 13318, + X86_VPSRLVDrr = 13319, + X86_VPSRLVQYrm = 13320, + X86_VPSRLVQYrr = 13321, + X86_VPSRLVQZ128rm = 13322, + X86_VPSRLVQZ128rmb = 13323, + X86_VPSRLVQZ128rmbk = 13324, + X86_VPSRLVQZ128rmbkz = 13325, + X86_VPSRLVQZ128rmk = 13326, + X86_VPSRLVQZ128rmkz = 13327, + X86_VPSRLVQZ128rr = 13328, + X86_VPSRLVQZ128rrk = 13329, + X86_VPSRLVQZ128rrkz = 13330, + X86_VPSRLVQZ256rm = 13331, + X86_VPSRLVQZ256rmb = 13332, + X86_VPSRLVQZ256rmbk = 13333, + X86_VPSRLVQZ256rmbkz = 13334, + X86_VPSRLVQZ256rmk = 13335, + X86_VPSRLVQZ256rmkz = 13336, + X86_VPSRLVQZ256rr = 13337, + X86_VPSRLVQZ256rrk = 13338, + X86_VPSRLVQZ256rrkz = 13339, + X86_VPSRLVQZrm = 13340, + X86_VPSRLVQZrmb = 13341, + X86_VPSRLVQZrmbk = 13342, + X86_VPSRLVQZrmbkz = 13343, + X86_VPSRLVQZrmk = 13344, + X86_VPSRLVQZrmkz = 13345, + X86_VPSRLVQZrr = 13346, + X86_VPSRLVQZrrk = 13347, + X86_VPSRLVQZrrkz = 13348, + X86_VPSRLVQrm = 13349, + X86_VPSRLVQrr = 13350, + X86_VPSRLVWZ128rm = 13351, + X86_VPSRLVWZ128rmk = 13352, + X86_VPSRLVWZ128rmkz = 13353, + X86_VPSRLVWZ128rr = 13354, + X86_VPSRLVWZ128rrk = 13355, + X86_VPSRLVWZ128rrkz = 13356, + X86_VPSRLVWZ256rm = 13357, + X86_VPSRLVWZ256rmk = 13358, + X86_VPSRLVWZ256rmkz = 13359, + X86_VPSRLVWZ256rr = 13360, + X86_VPSRLVWZ256rrk = 13361, + X86_VPSRLVWZ256rrkz = 13362, + X86_VPSRLVWZrm = 13363, + X86_VPSRLVWZrmk = 13364, + X86_VPSRLVWZrmkz = 13365, + X86_VPSRLVWZrr = 13366, + X86_VPSRLVWZrrk = 13367, + X86_VPSRLVWZrrkz = 13368, + X86_VPSRLWYri = 13369, + X86_VPSRLWYrm = 13370, + X86_VPSRLWYrr = 13371, + X86_VPSRLWZ128mi = 13372, + X86_VPSRLWZ128mik = 13373, + X86_VPSRLWZ128mikz = 13374, + X86_VPSRLWZ128ri = 13375, + X86_VPSRLWZ128rik = 13376, + X86_VPSRLWZ128rikz = 13377, + X86_VPSRLWZ128rm = 13378, + X86_VPSRLWZ128rmk = 13379, + X86_VPSRLWZ128rmkz = 13380, + X86_VPSRLWZ128rr = 13381, + X86_VPSRLWZ128rrk = 13382, + X86_VPSRLWZ128rrkz = 13383, + X86_VPSRLWZ256mi = 13384, + X86_VPSRLWZ256mik = 13385, + X86_VPSRLWZ256mikz = 13386, + X86_VPSRLWZ256ri = 13387, + X86_VPSRLWZ256rik = 13388, + X86_VPSRLWZ256rikz = 13389, + X86_VPSRLWZ256rm = 13390, + X86_VPSRLWZ256rmk = 13391, + X86_VPSRLWZ256rmkz = 13392, + X86_VPSRLWZ256rr = 13393, + X86_VPSRLWZ256rrk = 13394, + X86_VPSRLWZ256rrkz = 13395, + X86_VPSRLWZmi = 13396, + X86_VPSRLWZmik = 13397, + X86_VPSRLWZmikz = 13398, + X86_VPSRLWZri = 13399, + X86_VPSRLWZrik = 13400, + X86_VPSRLWZrikz = 13401, + X86_VPSRLWZrm = 13402, + X86_VPSRLWZrmk = 13403, + X86_VPSRLWZrmkz = 13404, + X86_VPSRLWZrr = 13405, + X86_VPSRLWZrrk = 13406, + X86_VPSRLWZrrkz = 13407, + X86_VPSRLWri = 13408, + X86_VPSRLWrm = 13409, + X86_VPSRLWrr = 13410, + X86_VPSUBBYrm = 13411, + X86_VPSUBBYrr = 13412, + X86_VPSUBBZ128rm = 13413, + X86_VPSUBBZ128rmk = 13414, + X86_VPSUBBZ128rmkz = 13415, + X86_VPSUBBZ128rr = 13416, + X86_VPSUBBZ128rrk = 13417, + X86_VPSUBBZ128rrkz = 13418, + X86_VPSUBBZ256rm = 13419, + X86_VPSUBBZ256rmk = 13420, + X86_VPSUBBZ256rmkz = 13421, + X86_VPSUBBZ256rr = 13422, + X86_VPSUBBZ256rrk = 13423, + X86_VPSUBBZ256rrkz = 13424, + X86_VPSUBBZrm = 13425, + X86_VPSUBBZrmk = 13426, + X86_VPSUBBZrmkz = 13427, + X86_VPSUBBZrr = 13428, + X86_VPSUBBZrrk = 13429, + X86_VPSUBBZrrkz = 13430, + X86_VPSUBBrm = 13431, + X86_VPSUBBrr = 13432, + X86_VPSUBDYrm = 13433, + X86_VPSUBDYrr = 13434, + X86_VPSUBDZ128rm = 13435, + X86_VPSUBDZ128rmb = 13436, + X86_VPSUBDZ128rmbk = 13437, + X86_VPSUBDZ128rmbkz = 13438, + X86_VPSUBDZ128rmk = 13439, + X86_VPSUBDZ128rmkz = 13440, + X86_VPSUBDZ128rr = 13441, + X86_VPSUBDZ128rrk = 13442, + X86_VPSUBDZ128rrkz = 13443, + X86_VPSUBDZ256rm = 13444, + X86_VPSUBDZ256rmb = 13445, + X86_VPSUBDZ256rmbk = 13446, + X86_VPSUBDZ256rmbkz = 13447, + X86_VPSUBDZ256rmk = 13448, + X86_VPSUBDZ256rmkz = 13449, + X86_VPSUBDZ256rr = 13450, + X86_VPSUBDZ256rrk = 13451, + X86_VPSUBDZ256rrkz = 13452, + X86_VPSUBDZrm = 13453, + X86_VPSUBDZrmb = 13454, + X86_VPSUBDZrmbk = 13455, + X86_VPSUBDZrmbkz = 13456, + X86_VPSUBDZrmk = 13457, + X86_VPSUBDZrmkz = 13458, + X86_VPSUBDZrr = 13459, + X86_VPSUBDZrrk = 13460, + X86_VPSUBDZrrkz = 13461, + X86_VPSUBDrm = 13462, + X86_VPSUBDrr = 13463, + X86_VPSUBQYrm = 13464, + X86_VPSUBQYrr = 13465, + X86_VPSUBQZ128rm = 13466, + X86_VPSUBQZ128rmb = 13467, + X86_VPSUBQZ128rmbk = 13468, + X86_VPSUBQZ128rmbkz = 13469, + X86_VPSUBQZ128rmk = 13470, + X86_VPSUBQZ128rmkz = 13471, + X86_VPSUBQZ128rr = 13472, + X86_VPSUBQZ128rrk = 13473, + X86_VPSUBQZ128rrkz = 13474, + X86_VPSUBQZ256rm = 13475, + X86_VPSUBQZ256rmb = 13476, + X86_VPSUBQZ256rmbk = 13477, + X86_VPSUBQZ256rmbkz = 13478, + X86_VPSUBQZ256rmk = 13479, + X86_VPSUBQZ256rmkz = 13480, + X86_VPSUBQZ256rr = 13481, + X86_VPSUBQZ256rrk = 13482, + X86_VPSUBQZ256rrkz = 13483, + X86_VPSUBQZrm = 13484, + X86_VPSUBQZrmb = 13485, + X86_VPSUBQZrmbk = 13486, + X86_VPSUBQZrmbkz = 13487, + X86_VPSUBQZrmk = 13488, + X86_VPSUBQZrmkz = 13489, + X86_VPSUBQZrr = 13490, + X86_VPSUBQZrrk = 13491, + X86_VPSUBQZrrkz = 13492, + X86_VPSUBQrm = 13493, + X86_VPSUBQrr = 13494, + X86_VPSUBSBYrm = 13495, + X86_VPSUBSBYrr = 13496, + X86_VPSUBSBZ128rm = 13497, + X86_VPSUBSBZ128rmk = 13498, + X86_VPSUBSBZ128rmkz = 13499, + X86_VPSUBSBZ128rr = 13500, + X86_VPSUBSBZ128rrk = 13501, + X86_VPSUBSBZ128rrkz = 13502, + X86_VPSUBSBZ256rm = 13503, + X86_VPSUBSBZ256rmk = 13504, + X86_VPSUBSBZ256rmkz = 13505, + X86_VPSUBSBZ256rr = 13506, + X86_VPSUBSBZ256rrk = 13507, + X86_VPSUBSBZ256rrkz = 13508, + X86_VPSUBSBZrm = 13509, + X86_VPSUBSBZrmk = 13510, + X86_VPSUBSBZrmkz = 13511, + X86_VPSUBSBZrr = 13512, + X86_VPSUBSBZrrk = 13513, + X86_VPSUBSBZrrkz = 13514, + X86_VPSUBSBrm = 13515, + X86_VPSUBSBrr = 13516, + X86_VPSUBSWYrm = 13517, + X86_VPSUBSWYrr = 13518, + X86_VPSUBSWZ128rm = 13519, + X86_VPSUBSWZ128rmk = 13520, + X86_VPSUBSWZ128rmkz = 13521, + X86_VPSUBSWZ128rr = 13522, + X86_VPSUBSWZ128rrk = 13523, + X86_VPSUBSWZ128rrkz = 13524, + X86_VPSUBSWZ256rm = 13525, + X86_VPSUBSWZ256rmk = 13526, + X86_VPSUBSWZ256rmkz = 13527, + X86_VPSUBSWZ256rr = 13528, + X86_VPSUBSWZ256rrk = 13529, + X86_VPSUBSWZ256rrkz = 13530, + X86_VPSUBSWZrm = 13531, + X86_VPSUBSWZrmk = 13532, + X86_VPSUBSWZrmkz = 13533, + X86_VPSUBSWZrr = 13534, + X86_VPSUBSWZrrk = 13535, + X86_VPSUBSWZrrkz = 13536, + X86_VPSUBSWrm = 13537, + X86_VPSUBSWrr = 13538, + X86_VPSUBUSBYrm = 13539, + X86_VPSUBUSBYrr = 13540, + X86_VPSUBUSBZ128rm = 13541, + X86_VPSUBUSBZ128rmk = 13542, + X86_VPSUBUSBZ128rmkz = 13543, + X86_VPSUBUSBZ128rr = 13544, + X86_VPSUBUSBZ128rrk = 13545, + X86_VPSUBUSBZ128rrkz = 13546, + X86_VPSUBUSBZ256rm = 13547, + X86_VPSUBUSBZ256rmk = 13548, + X86_VPSUBUSBZ256rmkz = 13549, + X86_VPSUBUSBZ256rr = 13550, + X86_VPSUBUSBZ256rrk = 13551, + X86_VPSUBUSBZ256rrkz = 13552, + X86_VPSUBUSBZrm = 13553, + X86_VPSUBUSBZrmk = 13554, + X86_VPSUBUSBZrmkz = 13555, + X86_VPSUBUSBZrr = 13556, + X86_VPSUBUSBZrrk = 13557, + X86_VPSUBUSBZrrkz = 13558, + X86_VPSUBUSBrm = 13559, + X86_VPSUBUSBrr = 13560, + X86_VPSUBUSWYrm = 13561, + X86_VPSUBUSWYrr = 13562, + X86_VPSUBUSWZ128rm = 13563, + X86_VPSUBUSWZ128rmk = 13564, + X86_VPSUBUSWZ128rmkz = 13565, + X86_VPSUBUSWZ128rr = 13566, + X86_VPSUBUSWZ128rrk = 13567, + X86_VPSUBUSWZ128rrkz = 13568, + X86_VPSUBUSWZ256rm = 13569, + X86_VPSUBUSWZ256rmk = 13570, + X86_VPSUBUSWZ256rmkz = 13571, + X86_VPSUBUSWZ256rr = 13572, + X86_VPSUBUSWZ256rrk = 13573, + X86_VPSUBUSWZ256rrkz = 13574, + X86_VPSUBUSWZrm = 13575, + X86_VPSUBUSWZrmk = 13576, + X86_VPSUBUSWZrmkz = 13577, + X86_VPSUBUSWZrr = 13578, + X86_VPSUBUSWZrrk = 13579, + X86_VPSUBUSWZrrkz = 13580, + X86_VPSUBUSWrm = 13581, + X86_VPSUBUSWrr = 13582, + X86_VPSUBWYrm = 13583, + X86_VPSUBWYrr = 13584, + X86_VPSUBWZ128rm = 13585, + X86_VPSUBWZ128rmk = 13586, + X86_VPSUBWZ128rmkz = 13587, + X86_VPSUBWZ128rr = 13588, + X86_VPSUBWZ128rrk = 13589, + X86_VPSUBWZ128rrkz = 13590, + X86_VPSUBWZ256rm = 13591, + X86_VPSUBWZ256rmk = 13592, + X86_VPSUBWZ256rmkz = 13593, + X86_VPSUBWZ256rr = 13594, + X86_VPSUBWZ256rrk = 13595, + X86_VPSUBWZ256rrkz = 13596, + X86_VPSUBWZrm = 13597, + X86_VPSUBWZrmk = 13598, + X86_VPSUBWZrmkz = 13599, + X86_VPSUBWZrr = 13600, + X86_VPSUBWZrrk = 13601, + X86_VPSUBWZrrkz = 13602, + X86_VPSUBWrm = 13603, + X86_VPSUBWrr = 13604, + X86_VPTERNLOGDZ128rmbi = 13605, + X86_VPTERNLOGDZ128rmbik = 13606, + X86_VPTERNLOGDZ128rmbikz = 13607, + X86_VPTERNLOGDZ128rmi = 13608, + X86_VPTERNLOGDZ128rmik = 13609, + X86_VPTERNLOGDZ128rmikz = 13610, + X86_VPTERNLOGDZ128rri = 13611, + X86_VPTERNLOGDZ128rrik = 13612, + X86_VPTERNLOGDZ128rrikz = 13613, + X86_VPTERNLOGDZ256rmbi = 13614, + X86_VPTERNLOGDZ256rmbik = 13615, + X86_VPTERNLOGDZ256rmbikz = 13616, + X86_VPTERNLOGDZ256rmi = 13617, + X86_VPTERNLOGDZ256rmik = 13618, + X86_VPTERNLOGDZ256rmikz = 13619, + X86_VPTERNLOGDZ256rri = 13620, + X86_VPTERNLOGDZ256rrik = 13621, + X86_VPTERNLOGDZ256rrikz = 13622, + X86_VPTERNLOGDZrmbi = 13623, + X86_VPTERNLOGDZrmbik = 13624, + X86_VPTERNLOGDZrmbikz = 13625, + X86_VPTERNLOGDZrmi = 13626, + X86_VPTERNLOGDZrmik = 13627, + X86_VPTERNLOGDZrmikz = 13628, + X86_VPTERNLOGDZrri = 13629, + X86_VPTERNLOGDZrrik = 13630, + X86_VPTERNLOGDZrrikz = 13631, + X86_VPTERNLOGQZ128rmbi = 13632, + X86_VPTERNLOGQZ128rmbik = 13633, + X86_VPTERNLOGQZ128rmbikz = 13634, + X86_VPTERNLOGQZ128rmi = 13635, + X86_VPTERNLOGQZ128rmik = 13636, + X86_VPTERNLOGQZ128rmikz = 13637, + X86_VPTERNLOGQZ128rri = 13638, + X86_VPTERNLOGQZ128rrik = 13639, + X86_VPTERNLOGQZ128rrikz = 13640, + X86_VPTERNLOGQZ256rmbi = 13641, + X86_VPTERNLOGQZ256rmbik = 13642, + X86_VPTERNLOGQZ256rmbikz = 13643, + X86_VPTERNLOGQZ256rmi = 13644, + X86_VPTERNLOGQZ256rmik = 13645, + X86_VPTERNLOGQZ256rmikz = 13646, + X86_VPTERNLOGQZ256rri = 13647, + X86_VPTERNLOGQZ256rrik = 13648, + X86_VPTERNLOGQZ256rrikz = 13649, + X86_VPTERNLOGQZrmbi = 13650, + X86_VPTERNLOGQZrmbik = 13651, + X86_VPTERNLOGQZrmbikz = 13652, + X86_VPTERNLOGQZrmi = 13653, + X86_VPTERNLOGQZrmik = 13654, + X86_VPTERNLOGQZrmikz = 13655, + X86_VPTERNLOGQZrri = 13656, + X86_VPTERNLOGQZrrik = 13657, + X86_VPTERNLOGQZrrikz = 13658, + X86_VPTESTMBZ128rm = 13659, + X86_VPTESTMBZ128rmk = 13660, + X86_VPTESTMBZ128rr = 13661, + X86_VPTESTMBZ128rrk = 13662, + X86_VPTESTMBZ256rm = 13663, + X86_VPTESTMBZ256rmk = 13664, + X86_VPTESTMBZ256rr = 13665, + X86_VPTESTMBZ256rrk = 13666, + X86_VPTESTMBZrm = 13667, + X86_VPTESTMBZrmk = 13668, + X86_VPTESTMBZrr = 13669, + X86_VPTESTMBZrrk = 13670, + X86_VPTESTMDZ128rm = 13671, + X86_VPTESTMDZ128rmb = 13672, + X86_VPTESTMDZ128rmbk = 13673, + X86_VPTESTMDZ128rmk = 13674, + X86_VPTESTMDZ128rr = 13675, + X86_VPTESTMDZ128rrk = 13676, + X86_VPTESTMDZ256rm = 13677, + X86_VPTESTMDZ256rmb = 13678, + X86_VPTESTMDZ256rmbk = 13679, + X86_VPTESTMDZ256rmk = 13680, + X86_VPTESTMDZ256rr = 13681, + X86_VPTESTMDZ256rrk = 13682, + X86_VPTESTMDZrm = 13683, + X86_VPTESTMDZrmb = 13684, + X86_VPTESTMDZrmbk = 13685, + X86_VPTESTMDZrmk = 13686, + X86_VPTESTMDZrr = 13687, + X86_VPTESTMDZrrk = 13688, + X86_VPTESTMQZ128rm = 13689, + X86_VPTESTMQZ128rmb = 13690, + X86_VPTESTMQZ128rmbk = 13691, + X86_VPTESTMQZ128rmk = 13692, + X86_VPTESTMQZ128rr = 13693, + X86_VPTESTMQZ128rrk = 13694, + X86_VPTESTMQZ256rm = 13695, + X86_VPTESTMQZ256rmb = 13696, + X86_VPTESTMQZ256rmbk = 13697, + X86_VPTESTMQZ256rmk = 13698, + X86_VPTESTMQZ256rr = 13699, + X86_VPTESTMQZ256rrk = 13700, + X86_VPTESTMQZrm = 13701, + X86_VPTESTMQZrmb = 13702, + X86_VPTESTMQZrmbk = 13703, + X86_VPTESTMQZrmk = 13704, + X86_VPTESTMQZrr = 13705, + X86_VPTESTMQZrrk = 13706, + X86_VPTESTMWZ128rm = 13707, + X86_VPTESTMWZ128rmk = 13708, + X86_VPTESTMWZ128rr = 13709, + X86_VPTESTMWZ128rrk = 13710, + X86_VPTESTMWZ256rm = 13711, + X86_VPTESTMWZ256rmk = 13712, + X86_VPTESTMWZ256rr = 13713, + X86_VPTESTMWZ256rrk = 13714, + X86_VPTESTMWZrm = 13715, + X86_VPTESTMWZrmk = 13716, + X86_VPTESTMWZrr = 13717, + X86_VPTESTMWZrrk = 13718, + X86_VPTESTNMBZ128rm = 13719, + X86_VPTESTNMBZ128rmk = 13720, + X86_VPTESTNMBZ128rr = 13721, + X86_VPTESTNMBZ128rrk = 13722, + X86_VPTESTNMBZ256rm = 13723, + X86_VPTESTNMBZ256rmk = 13724, + X86_VPTESTNMBZ256rr = 13725, + X86_VPTESTNMBZ256rrk = 13726, + X86_VPTESTNMBZrm = 13727, + X86_VPTESTNMBZrmk = 13728, + X86_VPTESTNMBZrr = 13729, + X86_VPTESTNMBZrrk = 13730, + X86_VPTESTNMDZ128rm = 13731, + X86_VPTESTNMDZ128rmb = 13732, + X86_VPTESTNMDZ128rmbk = 13733, + X86_VPTESTNMDZ128rmk = 13734, + X86_VPTESTNMDZ128rr = 13735, + X86_VPTESTNMDZ128rrk = 13736, + X86_VPTESTNMDZ256rm = 13737, + X86_VPTESTNMDZ256rmb = 13738, + X86_VPTESTNMDZ256rmbk = 13739, + X86_VPTESTNMDZ256rmk = 13740, + X86_VPTESTNMDZ256rr = 13741, + X86_VPTESTNMDZ256rrk = 13742, + X86_VPTESTNMDZrm = 13743, + X86_VPTESTNMDZrmb = 13744, + X86_VPTESTNMDZrmbk = 13745, + X86_VPTESTNMDZrmk = 13746, + X86_VPTESTNMDZrr = 13747, + X86_VPTESTNMDZrrk = 13748, + X86_VPTESTNMQZ128rm = 13749, + X86_VPTESTNMQZ128rmb = 13750, + X86_VPTESTNMQZ128rmbk = 13751, + X86_VPTESTNMQZ128rmk = 13752, + X86_VPTESTNMQZ128rr = 13753, + X86_VPTESTNMQZ128rrk = 13754, + X86_VPTESTNMQZ256rm = 13755, + X86_VPTESTNMQZ256rmb = 13756, + X86_VPTESTNMQZ256rmbk = 13757, + X86_VPTESTNMQZ256rmk = 13758, + X86_VPTESTNMQZ256rr = 13759, + X86_VPTESTNMQZ256rrk = 13760, + X86_VPTESTNMQZrm = 13761, + X86_VPTESTNMQZrmb = 13762, + X86_VPTESTNMQZrmbk = 13763, + X86_VPTESTNMQZrmk = 13764, + X86_VPTESTNMQZrr = 13765, + X86_VPTESTNMQZrrk = 13766, + X86_VPTESTNMWZ128rm = 13767, + X86_VPTESTNMWZ128rmk = 13768, + X86_VPTESTNMWZ128rr = 13769, + X86_VPTESTNMWZ128rrk = 13770, + X86_VPTESTNMWZ256rm = 13771, + X86_VPTESTNMWZ256rmk = 13772, + X86_VPTESTNMWZ256rr = 13773, + X86_VPTESTNMWZ256rrk = 13774, + X86_VPTESTNMWZrm = 13775, + X86_VPTESTNMWZrmk = 13776, + X86_VPTESTNMWZrr = 13777, + X86_VPTESTNMWZrrk = 13778, + X86_VPTESTYrm = 13779, + X86_VPTESTYrr = 13780, + X86_VPTESTrm = 13781, + X86_VPTESTrr = 13782, + X86_VPUNPCKHBWYrm = 13783, + X86_VPUNPCKHBWYrr = 13784, + X86_VPUNPCKHBWZ128rm = 13785, + X86_VPUNPCKHBWZ128rmk = 13786, + X86_VPUNPCKHBWZ128rmkz = 13787, + X86_VPUNPCKHBWZ128rr = 13788, + X86_VPUNPCKHBWZ128rrk = 13789, + X86_VPUNPCKHBWZ128rrkz = 13790, + X86_VPUNPCKHBWZ256rm = 13791, + X86_VPUNPCKHBWZ256rmk = 13792, + X86_VPUNPCKHBWZ256rmkz = 13793, + X86_VPUNPCKHBWZ256rr = 13794, + X86_VPUNPCKHBWZ256rrk = 13795, + X86_VPUNPCKHBWZ256rrkz = 13796, + X86_VPUNPCKHBWZrm = 13797, + X86_VPUNPCKHBWZrmk = 13798, + X86_VPUNPCKHBWZrmkz = 13799, + X86_VPUNPCKHBWZrr = 13800, + X86_VPUNPCKHBWZrrk = 13801, + X86_VPUNPCKHBWZrrkz = 13802, + X86_VPUNPCKHBWrm = 13803, + X86_VPUNPCKHBWrr = 13804, + X86_VPUNPCKHDQYrm = 13805, + X86_VPUNPCKHDQYrr = 13806, + X86_VPUNPCKHDQZ128rm = 13807, + X86_VPUNPCKHDQZ128rmb = 13808, + X86_VPUNPCKHDQZ128rmbk = 13809, + X86_VPUNPCKHDQZ128rmbkz = 13810, + X86_VPUNPCKHDQZ128rmk = 13811, + X86_VPUNPCKHDQZ128rmkz = 13812, + X86_VPUNPCKHDQZ128rr = 13813, + X86_VPUNPCKHDQZ128rrk = 13814, + X86_VPUNPCKHDQZ128rrkz = 13815, + X86_VPUNPCKHDQZ256rm = 13816, + X86_VPUNPCKHDQZ256rmb = 13817, + X86_VPUNPCKHDQZ256rmbk = 13818, + X86_VPUNPCKHDQZ256rmbkz = 13819, + X86_VPUNPCKHDQZ256rmk = 13820, + X86_VPUNPCKHDQZ256rmkz = 13821, + X86_VPUNPCKHDQZ256rr = 13822, + X86_VPUNPCKHDQZ256rrk = 13823, + X86_VPUNPCKHDQZ256rrkz = 13824, + X86_VPUNPCKHDQZrm = 13825, + X86_VPUNPCKHDQZrmb = 13826, + X86_VPUNPCKHDQZrmbk = 13827, + X86_VPUNPCKHDQZrmbkz = 13828, + X86_VPUNPCKHDQZrmk = 13829, + X86_VPUNPCKHDQZrmkz = 13830, + X86_VPUNPCKHDQZrr = 13831, + X86_VPUNPCKHDQZrrk = 13832, + X86_VPUNPCKHDQZrrkz = 13833, + X86_VPUNPCKHDQrm = 13834, + X86_VPUNPCKHDQrr = 13835, + X86_VPUNPCKHQDQYrm = 13836, + X86_VPUNPCKHQDQYrr = 13837, + X86_VPUNPCKHQDQZ128rm = 13838, + X86_VPUNPCKHQDQZ128rmb = 13839, + X86_VPUNPCKHQDQZ128rmbk = 13840, + X86_VPUNPCKHQDQZ128rmbkz = 13841, + X86_VPUNPCKHQDQZ128rmk = 13842, + X86_VPUNPCKHQDQZ128rmkz = 13843, + X86_VPUNPCKHQDQZ128rr = 13844, + X86_VPUNPCKHQDQZ128rrk = 13845, + X86_VPUNPCKHQDQZ128rrkz = 13846, + X86_VPUNPCKHQDQZ256rm = 13847, + X86_VPUNPCKHQDQZ256rmb = 13848, + X86_VPUNPCKHQDQZ256rmbk = 13849, + X86_VPUNPCKHQDQZ256rmbkz = 13850, + X86_VPUNPCKHQDQZ256rmk = 13851, + X86_VPUNPCKHQDQZ256rmkz = 13852, + X86_VPUNPCKHQDQZ256rr = 13853, + X86_VPUNPCKHQDQZ256rrk = 13854, + X86_VPUNPCKHQDQZ256rrkz = 13855, + X86_VPUNPCKHQDQZrm = 13856, + X86_VPUNPCKHQDQZrmb = 13857, + X86_VPUNPCKHQDQZrmbk = 13858, + X86_VPUNPCKHQDQZrmbkz = 13859, + X86_VPUNPCKHQDQZrmk = 13860, + X86_VPUNPCKHQDQZrmkz = 13861, + X86_VPUNPCKHQDQZrr = 13862, + X86_VPUNPCKHQDQZrrk = 13863, + X86_VPUNPCKHQDQZrrkz = 13864, + X86_VPUNPCKHQDQrm = 13865, + X86_VPUNPCKHQDQrr = 13866, + X86_VPUNPCKHWDYrm = 13867, + X86_VPUNPCKHWDYrr = 13868, + X86_VPUNPCKHWDZ128rm = 13869, + X86_VPUNPCKHWDZ128rmk = 13870, + X86_VPUNPCKHWDZ128rmkz = 13871, + X86_VPUNPCKHWDZ128rr = 13872, + X86_VPUNPCKHWDZ128rrk = 13873, + X86_VPUNPCKHWDZ128rrkz = 13874, + X86_VPUNPCKHWDZ256rm = 13875, + X86_VPUNPCKHWDZ256rmk = 13876, + X86_VPUNPCKHWDZ256rmkz = 13877, + X86_VPUNPCKHWDZ256rr = 13878, + X86_VPUNPCKHWDZ256rrk = 13879, + X86_VPUNPCKHWDZ256rrkz = 13880, + X86_VPUNPCKHWDZrm = 13881, + X86_VPUNPCKHWDZrmk = 13882, + X86_VPUNPCKHWDZrmkz = 13883, + X86_VPUNPCKHWDZrr = 13884, + X86_VPUNPCKHWDZrrk = 13885, + X86_VPUNPCKHWDZrrkz = 13886, + X86_VPUNPCKHWDrm = 13887, + X86_VPUNPCKHWDrr = 13888, + X86_VPUNPCKLBWYrm = 13889, + X86_VPUNPCKLBWYrr = 13890, + X86_VPUNPCKLBWZ128rm = 13891, + X86_VPUNPCKLBWZ128rmk = 13892, + X86_VPUNPCKLBWZ128rmkz = 13893, + X86_VPUNPCKLBWZ128rr = 13894, + X86_VPUNPCKLBWZ128rrk = 13895, + X86_VPUNPCKLBWZ128rrkz = 13896, + X86_VPUNPCKLBWZ256rm = 13897, + X86_VPUNPCKLBWZ256rmk = 13898, + X86_VPUNPCKLBWZ256rmkz = 13899, + X86_VPUNPCKLBWZ256rr = 13900, + X86_VPUNPCKLBWZ256rrk = 13901, + X86_VPUNPCKLBWZ256rrkz = 13902, + X86_VPUNPCKLBWZrm = 13903, + X86_VPUNPCKLBWZrmk = 13904, + X86_VPUNPCKLBWZrmkz = 13905, + X86_VPUNPCKLBWZrr = 13906, + X86_VPUNPCKLBWZrrk = 13907, + X86_VPUNPCKLBWZrrkz = 13908, + X86_VPUNPCKLBWrm = 13909, + X86_VPUNPCKLBWrr = 13910, + X86_VPUNPCKLDQYrm = 13911, + X86_VPUNPCKLDQYrr = 13912, + X86_VPUNPCKLDQZ128rm = 13913, + X86_VPUNPCKLDQZ128rmb = 13914, + X86_VPUNPCKLDQZ128rmbk = 13915, + X86_VPUNPCKLDQZ128rmbkz = 13916, + X86_VPUNPCKLDQZ128rmk = 13917, + X86_VPUNPCKLDQZ128rmkz = 13918, + X86_VPUNPCKLDQZ128rr = 13919, + X86_VPUNPCKLDQZ128rrk = 13920, + X86_VPUNPCKLDQZ128rrkz = 13921, + X86_VPUNPCKLDQZ256rm = 13922, + X86_VPUNPCKLDQZ256rmb = 13923, + X86_VPUNPCKLDQZ256rmbk = 13924, + X86_VPUNPCKLDQZ256rmbkz = 13925, + X86_VPUNPCKLDQZ256rmk = 13926, + X86_VPUNPCKLDQZ256rmkz = 13927, + X86_VPUNPCKLDQZ256rr = 13928, + X86_VPUNPCKLDQZ256rrk = 13929, + X86_VPUNPCKLDQZ256rrkz = 13930, + X86_VPUNPCKLDQZrm = 13931, + X86_VPUNPCKLDQZrmb = 13932, + X86_VPUNPCKLDQZrmbk = 13933, + X86_VPUNPCKLDQZrmbkz = 13934, + X86_VPUNPCKLDQZrmk = 13935, + X86_VPUNPCKLDQZrmkz = 13936, + X86_VPUNPCKLDQZrr = 13937, + X86_VPUNPCKLDQZrrk = 13938, + X86_VPUNPCKLDQZrrkz = 13939, + X86_VPUNPCKLDQrm = 13940, + X86_VPUNPCKLDQrr = 13941, + X86_VPUNPCKLQDQYrm = 13942, + X86_VPUNPCKLQDQYrr = 13943, + X86_VPUNPCKLQDQZ128rm = 13944, + X86_VPUNPCKLQDQZ128rmb = 13945, + X86_VPUNPCKLQDQZ128rmbk = 13946, + X86_VPUNPCKLQDQZ128rmbkz = 13947, + X86_VPUNPCKLQDQZ128rmk = 13948, + X86_VPUNPCKLQDQZ128rmkz = 13949, + X86_VPUNPCKLQDQZ128rr = 13950, + X86_VPUNPCKLQDQZ128rrk = 13951, + X86_VPUNPCKLQDQZ128rrkz = 13952, + X86_VPUNPCKLQDQZ256rm = 13953, + X86_VPUNPCKLQDQZ256rmb = 13954, + X86_VPUNPCKLQDQZ256rmbk = 13955, + X86_VPUNPCKLQDQZ256rmbkz = 13956, + X86_VPUNPCKLQDQZ256rmk = 13957, + X86_VPUNPCKLQDQZ256rmkz = 13958, + X86_VPUNPCKLQDQZ256rr = 13959, + X86_VPUNPCKLQDQZ256rrk = 13960, + X86_VPUNPCKLQDQZ256rrkz = 13961, + X86_VPUNPCKLQDQZrm = 13962, + X86_VPUNPCKLQDQZrmb = 13963, + X86_VPUNPCKLQDQZrmbk = 13964, + X86_VPUNPCKLQDQZrmbkz = 13965, + X86_VPUNPCKLQDQZrmk = 13966, + X86_VPUNPCKLQDQZrmkz = 13967, + X86_VPUNPCKLQDQZrr = 13968, + X86_VPUNPCKLQDQZrrk = 13969, + X86_VPUNPCKLQDQZrrkz = 13970, + X86_VPUNPCKLQDQrm = 13971, + X86_VPUNPCKLQDQrr = 13972, + X86_VPUNPCKLWDYrm = 13973, + X86_VPUNPCKLWDYrr = 13974, + X86_VPUNPCKLWDZ128rm = 13975, + X86_VPUNPCKLWDZ128rmk = 13976, + X86_VPUNPCKLWDZ128rmkz = 13977, + X86_VPUNPCKLWDZ128rr = 13978, + X86_VPUNPCKLWDZ128rrk = 13979, + X86_VPUNPCKLWDZ128rrkz = 13980, + X86_VPUNPCKLWDZ256rm = 13981, + X86_VPUNPCKLWDZ256rmk = 13982, + X86_VPUNPCKLWDZ256rmkz = 13983, + X86_VPUNPCKLWDZ256rr = 13984, + X86_VPUNPCKLWDZ256rrk = 13985, + X86_VPUNPCKLWDZ256rrkz = 13986, + X86_VPUNPCKLWDZrm = 13987, + X86_VPUNPCKLWDZrmk = 13988, + X86_VPUNPCKLWDZrmkz = 13989, + X86_VPUNPCKLWDZrr = 13990, + X86_VPUNPCKLWDZrrk = 13991, + X86_VPUNPCKLWDZrrkz = 13992, + X86_VPUNPCKLWDrm = 13993, + X86_VPUNPCKLWDrr = 13994, + X86_VPXORDZ128rm = 13995, + X86_VPXORDZ128rmb = 13996, + X86_VPXORDZ128rmbk = 13997, + X86_VPXORDZ128rmbkz = 13998, + X86_VPXORDZ128rmk = 13999, + X86_VPXORDZ128rmkz = 14000, + X86_VPXORDZ128rr = 14001, + X86_VPXORDZ128rrk = 14002, + X86_VPXORDZ128rrkz = 14003, + X86_VPXORDZ256rm = 14004, + X86_VPXORDZ256rmb = 14005, + X86_VPXORDZ256rmbk = 14006, + X86_VPXORDZ256rmbkz = 14007, + X86_VPXORDZ256rmk = 14008, + X86_VPXORDZ256rmkz = 14009, + X86_VPXORDZ256rr = 14010, + X86_VPXORDZ256rrk = 14011, + X86_VPXORDZ256rrkz = 14012, + X86_VPXORDZrm = 14013, + X86_VPXORDZrmb = 14014, + X86_VPXORDZrmbk = 14015, + X86_VPXORDZrmbkz = 14016, + X86_VPXORDZrmk = 14017, + X86_VPXORDZrmkz = 14018, + X86_VPXORDZrr = 14019, + X86_VPXORDZrrk = 14020, + X86_VPXORDZrrkz = 14021, + X86_VPXORQZ128rm = 14022, + X86_VPXORQZ128rmb = 14023, + X86_VPXORQZ128rmbk = 14024, + X86_VPXORQZ128rmbkz = 14025, + X86_VPXORQZ128rmk = 14026, + X86_VPXORQZ128rmkz = 14027, + X86_VPXORQZ128rr = 14028, + X86_VPXORQZ128rrk = 14029, + X86_VPXORQZ128rrkz = 14030, + X86_VPXORQZ256rm = 14031, + X86_VPXORQZ256rmb = 14032, + X86_VPXORQZ256rmbk = 14033, + X86_VPXORQZ256rmbkz = 14034, + X86_VPXORQZ256rmk = 14035, + X86_VPXORQZ256rmkz = 14036, + X86_VPXORQZ256rr = 14037, + X86_VPXORQZ256rrk = 14038, + X86_VPXORQZ256rrkz = 14039, + X86_VPXORQZrm = 14040, + X86_VPXORQZrmb = 14041, + X86_VPXORQZrmbk = 14042, + X86_VPXORQZrmbkz = 14043, + X86_VPXORQZrmk = 14044, + X86_VPXORQZrmkz = 14045, + X86_VPXORQZrr = 14046, + X86_VPXORQZrrk = 14047, + X86_VPXORQZrrkz = 14048, + X86_VPXORYrm = 14049, + X86_VPXORYrr = 14050, + X86_VPXORrm = 14051, + X86_VPXORrr = 14052, + X86_VRANGEPDZ128rmbi = 14053, + X86_VRANGEPDZ128rmbik = 14054, + X86_VRANGEPDZ128rmbikz = 14055, + X86_VRANGEPDZ128rmi = 14056, + X86_VRANGEPDZ128rmik = 14057, + X86_VRANGEPDZ128rmikz = 14058, + X86_VRANGEPDZ128rri = 14059, + X86_VRANGEPDZ128rrik = 14060, + X86_VRANGEPDZ128rrikz = 14061, + X86_VRANGEPDZ256rmbi = 14062, + X86_VRANGEPDZ256rmbik = 14063, + X86_VRANGEPDZ256rmbikz = 14064, + X86_VRANGEPDZ256rmi = 14065, + X86_VRANGEPDZ256rmik = 14066, + X86_VRANGEPDZ256rmikz = 14067, + X86_VRANGEPDZ256rri = 14068, + X86_VRANGEPDZ256rrik = 14069, + X86_VRANGEPDZ256rrikz = 14070, + X86_VRANGEPDZrmbi = 14071, + X86_VRANGEPDZrmbik = 14072, + X86_VRANGEPDZrmbikz = 14073, + X86_VRANGEPDZrmi = 14074, + X86_VRANGEPDZrmik = 14075, + X86_VRANGEPDZrmikz = 14076, + X86_VRANGEPDZrri = 14077, + X86_VRANGEPDZrrib = 14078, + X86_VRANGEPDZrribk = 14079, + X86_VRANGEPDZrribkz = 14080, + X86_VRANGEPDZrrik = 14081, + X86_VRANGEPDZrrikz = 14082, + X86_VRANGEPSZ128rmbi = 14083, + X86_VRANGEPSZ128rmbik = 14084, + X86_VRANGEPSZ128rmbikz = 14085, + X86_VRANGEPSZ128rmi = 14086, + X86_VRANGEPSZ128rmik = 14087, + X86_VRANGEPSZ128rmikz = 14088, + X86_VRANGEPSZ128rri = 14089, + X86_VRANGEPSZ128rrik = 14090, + X86_VRANGEPSZ128rrikz = 14091, + X86_VRANGEPSZ256rmbi = 14092, + X86_VRANGEPSZ256rmbik = 14093, + X86_VRANGEPSZ256rmbikz = 14094, + X86_VRANGEPSZ256rmi = 14095, + X86_VRANGEPSZ256rmik = 14096, + X86_VRANGEPSZ256rmikz = 14097, + X86_VRANGEPSZ256rri = 14098, + X86_VRANGEPSZ256rrik = 14099, + X86_VRANGEPSZ256rrikz = 14100, + X86_VRANGEPSZrmbi = 14101, + X86_VRANGEPSZrmbik = 14102, + X86_VRANGEPSZrmbikz = 14103, + X86_VRANGEPSZrmi = 14104, + X86_VRANGEPSZrmik = 14105, + X86_VRANGEPSZrmikz = 14106, + X86_VRANGEPSZrri = 14107, + X86_VRANGEPSZrrib = 14108, + X86_VRANGEPSZrribk = 14109, + X86_VRANGEPSZrribkz = 14110, + X86_VRANGEPSZrrik = 14111, + X86_VRANGEPSZrrikz = 14112, + X86_VRANGESDZrmi = 14113, + X86_VRANGESDZrmik = 14114, + X86_VRANGESDZrmikz = 14115, + X86_VRANGESDZrri = 14116, + X86_VRANGESDZrrib = 14117, + X86_VRANGESDZrribk = 14118, + X86_VRANGESDZrribkz = 14119, + X86_VRANGESDZrrik = 14120, + X86_VRANGESDZrrikz = 14121, + X86_VRANGESSZrmi = 14122, + X86_VRANGESSZrmik = 14123, + X86_VRANGESSZrmikz = 14124, + X86_VRANGESSZrri = 14125, + X86_VRANGESSZrrib = 14126, + X86_VRANGESSZrribk = 14127, + X86_VRANGESSZrribkz = 14128, + X86_VRANGESSZrrik = 14129, + X86_VRANGESSZrrikz = 14130, + X86_VRCP14PDZ128m = 14131, + X86_VRCP14PDZ128mb = 14132, + X86_VRCP14PDZ128mbk = 14133, + X86_VRCP14PDZ128mbkz = 14134, + X86_VRCP14PDZ128mk = 14135, + X86_VRCP14PDZ128mkz = 14136, + X86_VRCP14PDZ128r = 14137, + X86_VRCP14PDZ128rk = 14138, + X86_VRCP14PDZ128rkz = 14139, + X86_VRCP14PDZ256m = 14140, + X86_VRCP14PDZ256mb = 14141, + X86_VRCP14PDZ256mbk = 14142, + X86_VRCP14PDZ256mbkz = 14143, + X86_VRCP14PDZ256mk = 14144, + X86_VRCP14PDZ256mkz = 14145, + X86_VRCP14PDZ256r = 14146, + X86_VRCP14PDZ256rk = 14147, + X86_VRCP14PDZ256rkz = 14148, + X86_VRCP14PDZm = 14149, + X86_VRCP14PDZmb = 14150, + X86_VRCP14PDZmbk = 14151, + X86_VRCP14PDZmbkz = 14152, + X86_VRCP14PDZmk = 14153, + X86_VRCP14PDZmkz = 14154, + X86_VRCP14PDZr = 14155, + X86_VRCP14PDZrk = 14156, + X86_VRCP14PDZrkz = 14157, + X86_VRCP14PSZ128m = 14158, + X86_VRCP14PSZ128mb = 14159, + X86_VRCP14PSZ128mbk = 14160, + X86_VRCP14PSZ128mbkz = 14161, + X86_VRCP14PSZ128mk = 14162, + X86_VRCP14PSZ128mkz = 14163, + X86_VRCP14PSZ128r = 14164, + X86_VRCP14PSZ128rk = 14165, + X86_VRCP14PSZ128rkz = 14166, + X86_VRCP14PSZ256m = 14167, + X86_VRCP14PSZ256mb = 14168, + X86_VRCP14PSZ256mbk = 14169, + X86_VRCP14PSZ256mbkz = 14170, + X86_VRCP14PSZ256mk = 14171, + X86_VRCP14PSZ256mkz = 14172, + X86_VRCP14PSZ256r = 14173, + X86_VRCP14PSZ256rk = 14174, + X86_VRCP14PSZ256rkz = 14175, + X86_VRCP14PSZm = 14176, + X86_VRCP14PSZmb = 14177, + X86_VRCP14PSZmbk = 14178, + X86_VRCP14PSZmbkz = 14179, + X86_VRCP14PSZmk = 14180, + X86_VRCP14PSZmkz = 14181, + X86_VRCP14PSZr = 14182, + X86_VRCP14PSZrk = 14183, + X86_VRCP14PSZrkz = 14184, + X86_VRCP14SDZrm = 14185, + X86_VRCP14SDZrmk = 14186, + X86_VRCP14SDZrmkz = 14187, + X86_VRCP14SDZrr = 14188, + X86_VRCP14SDZrrk = 14189, + X86_VRCP14SDZrrkz = 14190, + X86_VRCP14SSZrm = 14191, + X86_VRCP14SSZrmk = 14192, + X86_VRCP14SSZrmkz = 14193, + X86_VRCP14SSZrr = 14194, + X86_VRCP14SSZrrk = 14195, + X86_VRCP14SSZrrkz = 14196, + X86_VRCP28PDZm = 14197, + X86_VRCP28PDZmb = 14198, + X86_VRCP28PDZmbk = 14199, + X86_VRCP28PDZmbkz = 14200, + X86_VRCP28PDZmk = 14201, + X86_VRCP28PDZmkz = 14202, + X86_VRCP28PDZr = 14203, + X86_VRCP28PDZrb = 14204, + X86_VRCP28PDZrbk = 14205, + X86_VRCP28PDZrbkz = 14206, + X86_VRCP28PDZrk = 14207, + X86_VRCP28PDZrkz = 14208, + X86_VRCP28PSZm = 14209, + X86_VRCP28PSZmb = 14210, + X86_VRCP28PSZmbk = 14211, + X86_VRCP28PSZmbkz = 14212, + X86_VRCP28PSZmk = 14213, + X86_VRCP28PSZmkz = 14214, + X86_VRCP28PSZr = 14215, + X86_VRCP28PSZrb = 14216, + X86_VRCP28PSZrbk = 14217, + X86_VRCP28PSZrbkz = 14218, + X86_VRCP28PSZrk = 14219, + X86_VRCP28PSZrkz = 14220, + X86_VRCP28SDZm = 14221, + X86_VRCP28SDZmk = 14222, + X86_VRCP28SDZmkz = 14223, + X86_VRCP28SDZr = 14224, + X86_VRCP28SDZrb = 14225, + X86_VRCP28SDZrbk = 14226, + X86_VRCP28SDZrbkz = 14227, + X86_VRCP28SDZrk = 14228, + X86_VRCP28SDZrkz = 14229, + X86_VRCP28SSZm = 14230, + X86_VRCP28SSZmk = 14231, + X86_VRCP28SSZmkz = 14232, + X86_VRCP28SSZr = 14233, + X86_VRCP28SSZrb = 14234, + X86_VRCP28SSZrbk = 14235, + X86_VRCP28SSZrbkz = 14236, + X86_VRCP28SSZrk = 14237, + X86_VRCP28SSZrkz = 14238, + X86_VRCPPSYm = 14239, + X86_VRCPPSYr = 14240, + X86_VRCPPSm = 14241, + X86_VRCPPSr = 14242, + X86_VRCPSSm = 14243, + X86_VRCPSSm_Int = 14244, + X86_VRCPSSr = 14245, + X86_VRCPSSr_Int = 14246, + X86_VREDUCEPDZ128rmbi = 14247, + X86_VREDUCEPDZ128rmbik = 14248, + X86_VREDUCEPDZ128rmbikz = 14249, + X86_VREDUCEPDZ128rmi = 14250, + X86_VREDUCEPDZ128rmik = 14251, + X86_VREDUCEPDZ128rmikz = 14252, + X86_VREDUCEPDZ128rri = 14253, + X86_VREDUCEPDZ128rrik = 14254, + X86_VREDUCEPDZ128rrikz = 14255, + X86_VREDUCEPDZ256rmbi = 14256, + X86_VREDUCEPDZ256rmbik = 14257, + X86_VREDUCEPDZ256rmbikz = 14258, + X86_VREDUCEPDZ256rmi = 14259, + X86_VREDUCEPDZ256rmik = 14260, + X86_VREDUCEPDZ256rmikz = 14261, + X86_VREDUCEPDZ256rri = 14262, + X86_VREDUCEPDZ256rrik = 14263, + X86_VREDUCEPDZ256rrikz = 14264, + X86_VREDUCEPDZrmbi = 14265, + X86_VREDUCEPDZrmbik = 14266, + X86_VREDUCEPDZrmbikz = 14267, + X86_VREDUCEPDZrmi = 14268, + X86_VREDUCEPDZrmik = 14269, + X86_VREDUCEPDZrmikz = 14270, + X86_VREDUCEPDZrri = 14271, + X86_VREDUCEPDZrrib = 14272, + X86_VREDUCEPDZrribk = 14273, + X86_VREDUCEPDZrribkz = 14274, + X86_VREDUCEPDZrrik = 14275, + X86_VREDUCEPDZrrikz = 14276, + X86_VREDUCEPSZ128rmbi = 14277, + X86_VREDUCEPSZ128rmbik = 14278, + X86_VREDUCEPSZ128rmbikz = 14279, + X86_VREDUCEPSZ128rmi = 14280, + X86_VREDUCEPSZ128rmik = 14281, + X86_VREDUCEPSZ128rmikz = 14282, + X86_VREDUCEPSZ128rri = 14283, + X86_VREDUCEPSZ128rrik = 14284, + X86_VREDUCEPSZ128rrikz = 14285, + X86_VREDUCEPSZ256rmbi = 14286, + X86_VREDUCEPSZ256rmbik = 14287, + X86_VREDUCEPSZ256rmbikz = 14288, + X86_VREDUCEPSZ256rmi = 14289, + X86_VREDUCEPSZ256rmik = 14290, + X86_VREDUCEPSZ256rmikz = 14291, + X86_VREDUCEPSZ256rri = 14292, + X86_VREDUCEPSZ256rrik = 14293, + X86_VREDUCEPSZ256rrikz = 14294, + X86_VREDUCEPSZrmbi = 14295, + X86_VREDUCEPSZrmbik = 14296, + X86_VREDUCEPSZrmbikz = 14297, + X86_VREDUCEPSZrmi = 14298, + X86_VREDUCEPSZrmik = 14299, + X86_VREDUCEPSZrmikz = 14300, + X86_VREDUCEPSZrri = 14301, + X86_VREDUCEPSZrrib = 14302, + X86_VREDUCEPSZrribk = 14303, + X86_VREDUCEPSZrribkz = 14304, + X86_VREDUCEPSZrrik = 14305, + X86_VREDUCEPSZrrikz = 14306, + X86_VREDUCESDZrmi = 14307, + X86_VREDUCESDZrmik = 14308, + X86_VREDUCESDZrmikz = 14309, + X86_VREDUCESDZrri = 14310, + X86_VREDUCESDZrrib = 14311, + X86_VREDUCESDZrribk = 14312, + X86_VREDUCESDZrribkz = 14313, + X86_VREDUCESDZrrik = 14314, + X86_VREDUCESDZrrikz = 14315, + X86_VREDUCESSZrmi = 14316, + X86_VREDUCESSZrmik = 14317, + X86_VREDUCESSZrmikz = 14318, + X86_VREDUCESSZrri = 14319, + X86_VREDUCESSZrrib = 14320, + X86_VREDUCESSZrribk = 14321, + X86_VREDUCESSZrribkz = 14322, + X86_VREDUCESSZrrik = 14323, + X86_VREDUCESSZrrikz = 14324, + X86_VRNDSCALEPDZ128rmbi = 14325, + X86_VRNDSCALEPDZ128rmbik = 14326, + X86_VRNDSCALEPDZ128rmbikz = 14327, + X86_VRNDSCALEPDZ128rmi = 14328, + X86_VRNDSCALEPDZ128rmik = 14329, + X86_VRNDSCALEPDZ128rmikz = 14330, + X86_VRNDSCALEPDZ128rri = 14331, + X86_VRNDSCALEPDZ128rrik = 14332, + X86_VRNDSCALEPDZ128rrikz = 14333, + X86_VRNDSCALEPDZ256rmbi = 14334, + X86_VRNDSCALEPDZ256rmbik = 14335, + X86_VRNDSCALEPDZ256rmbikz = 14336, + X86_VRNDSCALEPDZ256rmi = 14337, + X86_VRNDSCALEPDZ256rmik = 14338, + X86_VRNDSCALEPDZ256rmikz = 14339, + X86_VRNDSCALEPDZ256rri = 14340, + X86_VRNDSCALEPDZ256rrik = 14341, + X86_VRNDSCALEPDZ256rrikz = 14342, + X86_VRNDSCALEPDZrmbi = 14343, + X86_VRNDSCALEPDZrmbik = 14344, + X86_VRNDSCALEPDZrmbikz = 14345, + X86_VRNDSCALEPDZrmi = 14346, + X86_VRNDSCALEPDZrmik = 14347, + X86_VRNDSCALEPDZrmikz = 14348, + X86_VRNDSCALEPDZrri = 14349, + X86_VRNDSCALEPDZrrib = 14350, + X86_VRNDSCALEPDZrribk = 14351, + X86_VRNDSCALEPDZrribkz = 14352, + X86_VRNDSCALEPDZrrik = 14353, + X86_VRNDSCALEPDZrrikz = 14354, + X86_VRNDSCALEPSZ128rmbi = 14355, + X86_VRNDSCALEPSZ128rmbik = 14356, + X86_VRNDSCALEPSZ128rmbikz = 14357, + X86_VRNDSCALEPSZ128rmi = 14358, + X86_VRNDSCALEPSZ128rmik = 14359, + X86_VRNDSCALEPSZ128rmikz = 14360, + X86_VRNDSCALEPSZ128rri = 14361, + X86_VRNDSCALEPSZ128rrik = 14362, + X86_VRNDSCALEPSZ128rrikz = 14363, + X86_VRNDSCALEPSZ256rmbi = 14364, + X86_VRNDSCALEPSZ256rmbik = 14365, + X86_VRNDSCALEPSZ256rmbikz = 14366, + X86_VRNDSCALEPSZ256rmi = 14367, + X86_VRNDSCALEPSZ256rmik = 14368, + X86_VRNDSCALEPSZ256rmikz = 14369, + X86_VRNDSCALEPSZ256rri = 14370, + X86_VRNDSCALEPSZ256rrik = 14371, + X86_VRNDSCALEPSZ256rrikz = 14372, + X86_VRNDSCALEPSZrmbi = 14373, + X86_VRNDSCALEPSZrmbik = 14374, + X86_VRNDSCALEPSZrmbikz = 14375, + X86_VRNDSCALEPSZrmi = 14376, + X86_VRNDSCALEPSZrmik = 14377, + X86_VRNDSCALEPSZrmikz = 14378, + X86_VRNDSCALEPSZrri = 14379, + X86_VRNDSCALEPSZrrib = 14380, + X86_VRNDSCALEPSZrribk = 14381, + X86_VRNDSCALEPSZrribkz = 14382, + X86_VRNDSCALEPSZrrik = 14383, + X86_VRNDSCALEPSZrrikz = 14384, + X86_VRNDSCALESDZm = 14385, + X86_VRNDSCALESDZm_Int = 14386, + X86_VRNDSCALESDZm_Intk = 14387, + X86_VRNDSCALESDZm_Intkz = 14388, + X86_VRNDSCALESDZr = 14389, + X86_VRNDSCALESDZr_Int = 14390, + X86_VRNDSCALESDZr_Intk = 14391, + X86_VRNDSCALESDZr_Intkz = 14392, + X86_VRNDSCALESDZrb_Int = 14393, + X86_VRNDSCALESDZrb_Intk = 14394, + X86_VRNDSCALESDZrb_Intkz = 14395, + X86_VRNDSCALESSZm = 14396, + X86_VRNDSCALESSZm_Int = 14397, + X86_VRNDSCALESSZm_Intk = 14398, + X86_VRNDSCALESSZm_Intkz = 14399, + X86_VRNDSCALESSZr = 14400, + X86_VRNDSCALESSZr_Int = 14401, + X86_VRNDSCALESSZr_Intk = 14402, + X86_VRNDSCALESSZr_Intkz = 14403, + X86_VRNDSCALESSZrb_Int = 14404, + X86_VRNDSCALESSZrb_Intk = 14405, + X86_VRNDSCALESSZrb_Intkz = 14406, + X86_VROUNDPDYm = 14407, + X86_VROUNDPDYr = 14408, + X86_VROUNDPDm = 14409, + X86_VROUNDPDr = 14410, + X86_VROUNDPSYm = 14411, + X86_VROUNDPSYr = 14412, + X86_VROUNDPSm = 14413, + X86_VROUNDPSr = 14414, + X86_VROUNDSDm = 14415, + X86_VROUNDSDm_Int = 14416, + X86_VROUNDSDr = 14417, + X86_VROUNDSDr_Int = 14418, + X86_VROUNDSSm = 14419, + X86_VROUNDSSm_Int = 14420, + X86_VROUNDSSr = 14421, + X86_VROUNDSSr_Int = 14422, + X86_VRSQRT14PDZ128m = 14423, + X86_VRSQRT14PDZ128mb = 14424, + X86_VRSQRT14PDZ128mbk = 14425, + X86_VRSQRT14PDZ128mbkz = 14426, + X86_VRSQRT14PDZ128mk = 14427, + X86_VRSQRT14PDZ128mkz = 14428, + X86_VRSQRT14PDZ128r = 14429, + X86_VRSQRT14PDZ128rk = 14430, + X86_VRSQRT14PDZ128rkz = 14431, + X86_VRSQRT14PDZ256m = 14432, + X86_VRSQRT14PDZ256mb = 14433, + X86_VRSQRT14PDZ256mbk = 14434, + X86_VRSQRT14PDZ256mbkz = 14435, + X86_VRSQRT14PDZ256mk = 14436, + X86_VRSQRT14PDZ256mkz = 14437, + X86_VRSQRT14PDZ256r = 14438, + X86_VRSQRT14PDZ256rk = 14439, + X86_VRSQRT14PDZ256rkz = 14440, + X86_VRSQRT14PDZm = 14441, + X86_VRSQRT14PDZmb = 14442, + X86_VRSQRT14PDZmbk = 14443, + X86_VRSQRT14PDZmbkz = 14444, + X86_VRSQRT14PDZmk = 14445, + X86_VRSQRT14PDZmkz = 14446, + X86_VRSQRT14PDZr = 14447, + X86_VRSQRT14PDZrk = 14448, + X86_VRSQRT14PDZrkz = 14449, + X86_VRSQRT14PSZ128m = 14450, + X86_VRSQRT14PSZ128mb = 14451, + X86_VRSQRT14PSZ128mbk = 14452, + X86_VRSQRT14PSZ128mbkz = 14453, + X86_VRSQRT14PSZ128mk = 14454, + X86_VRSQRT14PSZ128mkz = 14455, + X86_VRSQRT14PSZ128r = 14456, + X86_VRSQRT14PSZ128rk = 14457, + X86_VRSQRT14PSZ128rkz = 14458, + X86_VRSQRT14PSZ256m = 14459, + X86_VRSQRT14PSZ256mb = 14460, + X86_VRSQRT14PSZ256mbk = 14461, + X86_VRSQRT14PSZ256mbkz = 14462, + X86_VRSQRT14PSZ256mk = 14463, + X86_VRSQRT14PSZ256mkz = 14464, + X86_VRSQRT14PSZ256r = 14465, + X86_VRSQRT14PSZ256rk = 14466, + X86_VRSQRT14PSZ256rkz = 14467, + X86_VRSQRT14PSZm = 14468, + X86_VRSQRT14PSZmb = 14469, + X86_VRSQRT14PSZmbk = 14470, + X86_VRSQRT14PSZmbkz = 14471, + X86_VRSQRT14PSZmk = 14472, + X86_VRSQRT14PSZmkz = 14473, + X86_VRSQRT14PSZr = 14474, + X86_VRSQRT14PSZrk = 14475, + X86_VRSQRT14PSZrkz = 14476, + X86_VRSQRT14SDZrm = 14477, + X86_VRSQRT14SDZrmk = 14478, + X86_VRSQRT14SDZrmkz = 14479, + X86_VRSQRT14SDZrr = 14480, + X86_VRSQRT14SDZrrk = 14481, + X86_VRSQRT14SDZrrkz = 14482, + X86_VRSQRT14SSZrm = 14483, + X86_VRSQRT14SSZrmk = 14484, + X86_VRSQRT14SSZrmkz = 14485, + X86_VRSQRT14SSZrr = 14486, + X86_VRSQRT14SSZrrk = 14487, + X86_VRSQRT14SSZrrkz = 14488, + X86_VRSQRT28PDZm = 14489, + X86_VRSQRT28PDZmb = 14490, + X86_VRSQRT28PDZmbk = 14491, + X86_VRSQRT28PDZmbkz = 14492, + X86_VRSQRT28PDZmk = 14493, + X86_VRSQRT28PDZmkz = 14494, + X86_VRSQRT28PDZr = 14495, + X86_VRSQRT28PDZrb = 14496, + X86_VRSQRT28PDZrbk = 14497, + X86_VRSQRT28PDZrbkz = 14498, + X86_VRSQRT28PDZrk = 14499, + X86_VRSQRT28PDZrkz = 14500, + X86_VRSQRT28PSZm = 14501, + X86_VRSQRT28PSZmb = 14502, + X86_VRSQRT28PSZmbk = 14503, + X86_VRSQRT28PSZmbkz = 14504, + X86_VRSQRT28PSZmk = 14505, + X86_VRSQRT28PSZmkz = 14506, + X86_VRSQRT28PSZr = 14507, + X86_VRSQRT28PSZrb = 14508, + X86_VRSQRT28PSZrbk = 14509, + X86_VRSQRT28PSZrbkz = 14510, + X86_VRSQRT28PSZrk = 14511, + X86_VRSQRT28PSZrkz = 14512, + X86_VRSQRT28SDZm = 14513, + X86_VRSQRT28SDZmk = 14514, + X86_VRSQRT28SDZmkz = 14515, + X86_VRSQRT28SDZr = 14516, + X86_VRSQRT28SDZrb = 14517, + X86_VRSQRT28SDZrbk = 14518, + X86_VRSQRT28SDZrbkz = 14519, + X86_VRSQRT28SDZrk = 14520, + X86_VRSQRT28SDZrkz = 14521, + X86_VRSQRT28SSZm = 14522, + X86_VRSQRT28SSZmk = 14523, + X86_VRSQRT28SSZmkz = 14524, + X86_VRSQRT28SSZr = 14525, + X86_VRSQRT28SSZrb = 14526, + X86_VRSQRT28SSZrbk = 14527, + X86_VRSQRT28SSZrbkz = 14528, + X86_VRSQRT28SSZrk = 14529, + X86_VRSQRT28SSZrkz = 14530, + X86_VRSQRTPSYm = 14531, + X86_VRSQRTPSYr = 14532, + X86_VRSQRTPSm = 14533, + X86_VRSQRTPSr = 14534, + X86_VRSQRTSSm = 14535, + X86_VRSQRTSSm_Int = 14536, + X86_VRSQRTSSr = 14537, + X86_VRSQRTSSr_Int = 14538, + X86_VSCALEFPDZ128rm = 14539, + X86_VSCALEFPDZ128rmb = 14540, + X86_VSCALEFPDZ128rmbk = 14541, + X86_VSCALEFPDZ128rmbkz = 14542, + X86_VSCALEFPDZ128rmk = 14543, + X86_VSCALEFPDZ128rmkz = 14544, + X86_VSCALEFPDZ128rr = 14545, + X86_VSCALEFPDZ128rrk = 14546, + X86_VSCALEFPDZ128rrkz = 14547, + X86_VSCALEFPDZ256rm = 14548, + X86_VSCALEFPDZ256rmb = 14549, + X86_VSCALEFPDZ256rmbk = 14550, + X86_VSCALEFPDZ256rmbkz = 14551, + X86_VSCALEFPDZ256rmk = 14552, + X86_VSCALEFPDZ256rmkz = 14553, + X86_VSCALEFPDZ256rr = 14554, + X86_VSCALEFPDZ256rrk = 14555, + X86_VSCALEFPDZ256rrkz = 14556, + X86_VSCALEFPDZrm = 14557, + X86_VSCALEFPDZrmb = 14558, + X86_VSCALEFPDZrmbk = 14559, + X86_VSCALEFPDZrmbkz = 14560, + X86_VSCALEFPDZrmk = 14561, + X86_VSCALEFPDZrmkz = 14562, + X86_VSCALEFPDZrr = 14563, + X86_VSCALEFPDZrrb = 14564, + X86_VSCALEFPDZrrbk = 14565, + X86_VSCALEFPDZrrbkz = 14566, + X86_VSCALEFPDZrrk = 14567, + X86_VSCALEFPDZrrkz = 14568, + X86_VSCALEFPSZ128rm = 14569, + X86_VSCALEFPSZ128rmb = 14570, + X86_VSCALEFPSZ128rmbk = 14571, + X86_VSCALEFPSZ128rmbkz = 14572, + X86_VSCALEFPSZ128rmk = 14573, + X86_VSCALEFPSZ128rmkz = 14574, + X86_VSCALEFPSZ128rr = 14575, + X86_VSCALEFPSZ128rrk = 14576, + X86_VSCALEFPSZ128rrkz = 14577, + X86_VSCALEFPSZ256rm = 14578, + X86_VSCALEFPSZ256rmb = 14579, + X86_VSCALEFPSZ256rmbk = 14580, + X86_VSCALEFPSZ256rmbkz = 14581, + X86_VSCALEFPSZ256rmk = 14582, + X86_VSCALEFPSZ256rmkz = 14583, + X86_VSCALEFPSZ256rr = 14584, + X86_VSCALEFPSZ256rrk = 14585, + X86_VSCALEFPSZ256rrkz = 14586, + X86_VSCALEFPSZrm = 14587, + X86_VSCALEFPSZrmb = 14588, + X86_VSCALEFPSZrmbk = 14589, + X86_VSCALEFPSZrmbkz = 14590, + X86_VSCALEFPSZrmk = 14591, + X86_VSCALEFPSZrmkz = 14592, + X86_VSCALEFPSZrr = 14593, + X86_VSCALEFPSZrrb = 14594, + X86_VSCALEFPSZrrbk = 14595, + X86_VSCALEFPSZrrbkz = 14596, + X86_VSCALEFPSZrrk = 14597, + X86_VSCALEFPSZrrkz = 14598, + X86_VSCALEFSDZrm = 14599, + X86_VSCALEFSDZrmk = 14600, + X86_VSCALEFSDZrmkz = 14601, + X86_VSCALEFSDZrr = 14602, + X86_VSCALEFSDZrrb_Int = 14603, + X86_VSCALEFSDZrrb_Intk = 14604, + X86_VSCALEFSDZrrb_Intkz = 14605, + X86_VSCALEFSDZrrk = 14606, + X86_VSCALEFSDZrrkz = 14607, + X86_VSCALEFSSZrm = 14608, + X86_VSCALEFSSZrmk = 14609, + X86_VSCALEFSSZrmkz = 14610, + X86_VSCALEFSSZrr = 14611, + X86_VSCALEFSSZrrb_Int = 14612, + X86_VSCALEFSSZrrb_Intk = 14613, + X86_VSCALEFSSZrrb_Intkz = 14614, + X86_VSCALEFSSZrrk = 14615, + X86_VSCALEFSSZrrkz = 14616, + X86_VSCATTERDPDZ128mr = 14617, + X86_VSCATTERDPDZ256mr = 14618, + X86_VSCATTERDPDZmr = 14619, + X86_VSCATTERDPSZ128mr = 14620, + X86_VSCATTERDPSZ256mr = 14621, + X86_VSCATTERDPSZmr = 14622, + X86_VSCATTERPF0DPDm = 14623, + X86_VSCATTERPF0DPSm = 14624, + X86_VSCATTERPF0QPDm = 14625, + X86_VSCATTERPF0QPSm = 14626, + X86_VSCATTERPF1DPDm = 14627, + X86_VSCATTERPF1DPSm = 14628, + X86_VSCATTERPF1QPDm = 14629, + X86_VSCATTERPF1QPSm = 14630, + X86_VSCATTERQPDZ128mr = 14631, + X86_VSCATTERQPDZ256mr = 14632, + X86_VSCATTERQPDZmr = 14633, + X86_VSCATTERQPSZ128mr = 14634, + X86_VSCATTERQPSZ256mr = 14635, + X86_VSCATTERQPSZmr = 14636, + X86_VSHUFF32X4Z256rmbi = 14637, + X86_VSHUFF32X4Z256rmbik = 14638, + X86_VSHUFF32X4Z256rmbikz = 14639, + X86_VSHUFF32X4Z256rmi = 14640, + X86_VSHUFF32X4Z256rmik = 14641, + X86_VSHUFF32X4Z256rmikz = 14642, + X86_VSHUFF32X4Z256rri = 14643, + X86_VSHUFF32X4Z256rrik = 14644, + X86_VSHUFF32X4Z256rrikz = 14645, + X86_VSHUFF32X4Zrmbi = 14646, + X86_VSHUFF32X4Zrmbik = 14647, + X86_VSHUFF32X4Zrmbikz = 14648, + X86_VSHUFF32X4Zrmi = 14649, + X86_VSHUFF32X4Zrmik = 14650, + X86_VSHUFF32X4Zrmikz = 14651, + X86_VSHUFF32X4Zrri = 14652, + X86_VSHUFF32X4Zrrik = 14653, + X86_VSHUFF32X4Zrrikz = 14654, + X86_VSHUFF64X2Z256rmbi = 14655, + X86_VSHUFF64X2Z256rmbik = 14656, + X86_VSHUFF64X2Z256rmbikz = 14657, + X86_VSHUFF64X2Z256rmi = 14658, + X86_VSHUFF64X2Z256rmik = 14659, + X86_VSHUFF64X2Z256rmikz = 14660, + X86_VSHUFF64X2Z256rri = 14661, + X86_VSHUFF64X2Z256rrik = 14662, + X86_VSHUFF64X2Z256rrikz = 14663, + X86_VSHUFF64X2Zrmbi = 14664, + X86_VSHUFF64X2Zrmbik = 14665, + X86_VSHUFF64X2Zrmbikz = 14666, + X86_VSHUFF64X2Zrmi = 14667, + X86_VSHUFF64X2Zrmik = 14668, + X86_VSHUFF64X2Zrmikz = 14669, + X86_VSHUFF64X2Zrri = 14670, + X86_VSHUFF64X2Zrrik = 14671, + X86_VSHUFF64X2Zrrikz = 14672, + X86_VSHUFI32X4Z256rmbi = 14673, + X86_VSHUFI32X4Z256rmbik = 14674, + X86_VSHUFI32X4Z256rmbikz = 14675, + X86_VSHUFI32X4Z256rmi = 14676, + X86_VSHUFI32X4Z256rmik = 14677, + X86_VSHUFI32X4Z256rmikz = 14678, + X86_VSHUFI32X4Z256rri = 14679, + X86_VSHUFI32X4Z256rrik = 14680, + X86_VSHUFI32X4Z256rrikz = 14681, + X86_VSHUFI32X4Zrmbi = 14682, + X86_VSHUFI32X4Zrmbik = 14683, + X86_VSHUFI32X4Zrmbikz = 14684, + X86_VSHUFI32X4Zrmi = 14685, + X86_VSHUFI32X4Zrmik = 14686, + X86_VSHUFI32X4Zrmikz = 14687, + X86_VSHUFI32X4Zrri = 14688, + X86_VSHUFI32X4Zrrik = 14689, + X86_VSHUFI32X4Zrrikz = 14690, + X86_VSHUFI64X2Z256rmbi = 14691, + X86_VSHUFI64X2Z256rmbik = 14692, + X86_VSHUFI64X2Z256rmbikz = 14693, + X86_VSHUFI64X2Z256rmi = 14694, + X86_VSHUFI64X2Z256rmik = 14695, + X86_VSHUFI64X2Z256rmikz = 14696, + X86_VSHUFI64X2Z256rri = 14697, + X86_VSHUFI64X2Z256rrik = 14698, + X86_VSHUFI64X2Z256rrikz = 14699, + X86_VSHUFI64X2Zrmbi = 14700, + X86_VSHUFI64X2Zrmbik = 14701, + X86_VSHUFI64X2Zrmbikz = 14702, + X86_VSHUFI64X2Zrmi = 14703, + X86_VSHUFI64X2Zrmik = 14704, + X86_VSHUFI64X2Zrmikz = 14705, + X86_VSHUFI64X2Zrri = 14706, + X86_VSHUFI64X2Zrrik = 14707, + X86_VSHUFI64X2Zrrikz = 14708, + X86_VSHUFPDYrmi = 14709, + X86_VSHUFPDYrri = 14710, + X86_VSHUFPDZ128rmbi = 14711, + X86_VSHUFPDZ128rmbik = 14712, + X86_VSHUFPDZ128rmbikz = 14713, + X86_VSHUFPDZ128rmi = 14714, + X86_VSHUFPDZ128rmik = 14715, + X86_VSHUFPDZ128rmikz = 14716, + X86_VSHUFPDZ128rri = 14717, + X86_VSHUFPDZ128rrik = 14718, + X86_VSHUFPDZ128rrikz = 14719, + X86_VSHUFPDZ256rmbi = 14720, + X86_VSHUFPDZ256rmbik = 14721, + X86_VSHUFPDZ256rmbikz = 14722, + X86_VSHUFPDZ256rmi = 14723, + X86_VSHUFPDZ256rmik = 14724, + X86_VSHUFPDZ256rmikz = 14725, + X86_VSHUFPDZ256rri = 14726, + X86_VSHUFPDZ256rrik = 14727, + X86_VSHUFPDZ256rrikz = 14728, + X86_VSHUFPDZrmbi = 14729, + X86_VSHUFPDZrmbik = 14730, + X86_VSHUFPDZrmbikz = 14731, + X86_VSHUFPDZrmi = 14732, + X86_VSHUFPDZrmik = 14733, + X86_VSHUFPDZrmikz = 14734, + X86_VSHUFPDZrri = 14735, + X86_VSHUFPDZrrik = 14736, + X86_VSHUFPDZrrikz = 14737, + X86_VSHUFPDrmi = 14738, + X86_VSHUFPDrri = 14739, + X86_VSHUFPSYrmi = 14740, + X86_VSHUFPSYrri = 14741, + X86_VSHUFPSZ128rmbi = 14742, + X86_VSHUFPSZ128rmbik = 14743, + X86_VSHUFPSZ128rmbikz = 14744, + X86_VSHUFPSZ128rmi = 14745, + X86_VSHUFPSZ128rmik = 14746, + X86_VSHUFPSZ128rmikz = 14747, + X86_VSHUFPSZ128rri = 14748, + X86_VSHUFPSZ128rrik = 14749, + X86_VSHUFPSZ128rrikz = 14750, + X86_VSHUFPSZ256rmbi = 14751, + X86_VSHUFPSZ256rmbik = 14752, + X86_VSHUFPSZ256rmbikz = 14753, + X86_VSHUFPSZ256rmi = 14754, + X86_VSHUFPSZ256rmik = 14755, + X86_VSHUFPSZ256rmikz = 14756, + X86_VSHUFPSZ256rri = 14757, + X86_VSHUFPSZ256rrik = 14758, + X86_VSHUFPSZ256rrikz = 14759, + X86_VSHUFPSZrmbi = 14760, + X86_VSHUFPSZrmbik = 14761, + X86_VSHUFPSZrmbikz = 14762, + X86_VSHUFPSZrmi = 14763, + X86_VSHUFPSZrmik = 14764, + X86_VSHUFPSZrmikz = 14765, + X86_VSHUFPSZrri = 14766, + X86_VSHUFPSZrrik = 14767, + X86_VSHUFPSZrrikz = 14768, + X86_VSHUFPSrmi = 14769, + X86_VSHUFPSrri = 14770, + X86_VSQRTPDYm = 14771, + X86_VSQRTPDYr = 14772, + X86_VSQRTPDZ128m = 14773, + X86_VSQRTPDZ128mb = 14774, + X86_VSQRTPDZ128mbk = 14775, + X86_VSQRTPDZ128mbkz = 14776, + X86_VSQRTPDZ128mk = 14777, + X86_VSQRTPDZ128mkz = 14778, + X86_VSQRTPDZ128r = 14779, + X86_VSQRTPDZ128rk = 14780, + X86_VSQRTPDZ128rkz = 14781, + X86_VSQRTPDZ256m = 14782, + X86_VSQRTPDZ256mb = 14783, + X86_VSQRTPDZ256mbk = 14784, + X86_VSQRTPDZ256mbkz = 14785, + X86_VSQRTPDZ256mk = 14786, + X86_VSQRTPDZ256mkz = 14787, + X86_VSQRTPDZ256r = 14788, + X86_VSQRTPDZ256rk = 14789, + X86_VSQRTPDZ256rkz = 14790, + X86_VSQRTPDZm = 14791, + X86_VSQRTPDZmb = 14792, + X86_VSQRTPDZmbk = 14793, + X86_VSQRTPDZmbkz = 14794, + X86_VSQRTPDZmk = 14795, + X86_VSQRTPDZmkz = 14796, + X86_VSQRTPDZr = 14797, + X86_VSQRTPDZrb = 14798, + X86_VSQRTPDZrbk = 14799, + X86_VSQRTPDZrbkz = 14800, + X86_VSQRTPDZrk = 14801, + X86_VSQRTPDZrkz = 14802, + X86_VSQRTPDm = 14803, + X86_VSQRTPDr = 14804, + X86_VSQRTPSYm = 14805, + X86_VSQRTPSYr = 14806, + X86_VSQRTPSZ128m = 14807, + X86_VSQRTPSZ128mb = 14808, + X86_VSQRTPSZ128mbk = 14809, + X86_VSQRTPSZ128mbkz = 14810, + X86_VSQRTPSZ128mk = 14811, + X86_VSQRTPSZ128mkz = 14812, + X86_VSQRTPSZ128r = 14813, + X86_VSQRTPSZ128rk = 14814, + X86_VSQRTPSZ128rkz = 14815, + X86_VSQRTPSZ256m = 14816, + X86_VSQRTPSZ256mb = 14817, + X86_VSQRTPSZ256mbk = 14818, + X86_VSQRTPSZ256mbkz = 14819, + X86_VSQRTPSZ256mk = 14820, + X86_VSQRTPSZ256mkz = 14821, + X86_VSQRTPSZ256r = 14822, + X86_VSQRTPSZ256rk = 14823, + X86_VSQRTPSZ256rkz = 14824, + X86_VSQRTPSZm = 14825, + X86_VSQRTPSZmb = 14826, + X86_VSQRTPSZmbk = 14827, + X86_VSQRTPSZmbkz = 14828, + X86_VSQRTPSZmk = 14829, + X86_VSQRTPSZmkz = 14830, + X86_VSQRTPSZr = 14831, + X86_VSQRTPSZrb = 14832, + X86_VSQRTPSZrbk = 14833, + X86_VSQRTPSZrbkz = 14834, + X86_VSQRTPSZrk = 14835, + X86_VSQRTPSZrkz = 14836, + X86_VSQRTPSm = 14837, + X86_VSQRTPSr = 14838, + X86_VSQRTSDZm = 14839, + X86_VSQRTSDZm_Int = 14840, + X86_VSQRTSDZm_Intk = 14841, + X86_VSQRTSDZm_Intkz = 14842, + X86_VSQRTSDZr = 14843, + X86_VSQRTSDZr_Int = 14844, + X86_VSQRTSDZr_Intk = 14845, + X86_VSQRTSDZr_Intkz = 14846, + X86_VSQRTSDZrb_Int = 14847, + X86_VSQRTSDZrb_Intk = 14848, + X86_VSQRTSDZrb_Intkz = 14849, + X86_VSQRTSDm = 14850, + X86_VSQRTSDm_Int = 14851, + X86_VSQRTSDr = 14852, + X86_VSQRTSDr_Int = 14853, + X86_VSQRTSSZm = 14854, + X86_VSQRTSSZm_Int = 14855, + X86_VSQRTSSZm_Intk = 14856, + X86_VSQRTSSZm_Intkz = 14857, + X86_VSQRTSSZr = 14858, + X86_VSQRTSSZr_Int = 14859, + X86_VSQRTSSZr_Intk = 14860, + X86_VSQRTSSZr_Intkz = 14861, + X86_VSQRTSSZrb_Int = 14862, + X86_VSQRTSSZrb_Intk = 14863, + X86_VSQRTSSZrb_Intkz = 14864, + X86_VSQRTSSm = 14865, + X86_VSQRTSSm_Int = 14866, + X86_VSQRTSSr = 14867, + X86_VSQRTSSr_Int = 14868, + X86_VSTMXCSR = 14869, + X86_VSUBPDYrm = 14870, + X86_VSUBPDYrr = 14871, + X86_VSUBPDZ128rm = 14872, + X86_VSUBPDZ128rmb = 14873, + X86_VSUBPDZ128rmbk = 14874, + X86_VSUBPDZ128rmbkz = 14875, + X86_VSUBPDZ128rmk = 14876, + X86_VSUBPDZ128rmkz = 14877, + X86_VSUBPDZ128rr = 14878, + X86_VSUBPDZ128rrk = 14879, + X86_VSUBPDZ128rrkz = 14880, + X86_VSUBPDZ256rm = 14881, + X86_VSUBPDZ256rmb = 14882, + X86_VSUBPDZ256rmbk = 14883, + X86_VSUBPDZ256rmbkz = 14884, + X86_VSUBPDZ256rmk = 14885, + X86_VSUBPDZ256rmkz = 14886, + X86_VSUBPDZ256rr = 14887, + X86_VSUBPDZ256rrk = 14888, + X86_VSUBPDZ256rrkz = 14889, + X86_VSUBPDZrm = 14890, + X86_VSUBPDZrmb = 14891, + X86_VSUBPDZrmbk = 14892, + X86_VSUBPDZrmbkz = 14893, + X86_VSUBPDZrmk = 14894, + X86_VSUBPDZrmkz = 14895, + X86_VSUBPDZrr = 14896, + X86_VSUBPDZrrb = 14897, + X86_VSUBPDZrrbk = 14898, + X86_VSUBPDZrrbkz = 14899, + X86_VSUBPDZrrk = 14900, + X86_VSUBPDZrrkz = 14901, + X86_VSUBPDrm = 14902, + X86_VSUBPDrr = 14903, + X86_VSUBPSYrm = 14904, + X86_VSUBPSYrr = 14905, + X86_VSUBPSZ128rm = 14906, + X86_VSUBPSZ128rmb = 14907, + X86_VSUBPSZ128rmbk = 14908, + X86_VSUBPSZ128rmbkz = 14909, + X86_VSUBPSZ128rmk = 14910, + X86_VSUBPSZ128rmkz = 14911, + X86_VSUBPSZ128rr = 14912, + X86_VSUBPSZ128rrk = 14913, + X86_VSUBPSZ128rrkz = 14914, + X86_VSUBPSZ256rm = 14915, + X86_VSUBPSZ256rmb = 14916, + X86_VSUBPSZ256rmbk = 14917, + X86_VSUBPSZ256rmbkz = 14918, + X86_VSUBPSZ256rmk = 14919, + X86_VSUBPSZ256rmkz = 14920, + X86_VSUBPSZ256rr = 14921, + X86_VSUBPSZ256rrk = 14922, + X86_VSUBPSZ256rrkz = 14923, + X86_VSUBPSZrm = 14924, + X86_VSUBPSZrmb = 14925, + X86_VSUBPSZrmbk = 14926, + X86_VSUBPSZrmbkz = 14927, + X86_VSUBPSZrmk = 14928, + X86_VSUBPSZrmkz = 14929, + X86_VSUBPSZrr = 14930, + X86_VSUBPSZrrb = 14931, + X86_VSUBPSZrrbk = 14932, + X86_VSUBPSZrrbkz = 14933, + X86_VSUBPSZrrk = 14934, + X86_VSUBPSZrrkz = 14935, + X86_VSUBPSrm = 14936, + X86_VSUBPSrr = 14937, + X86_VSUBSDZrm = 14938, + X86_VSUBSDZrm_Int = 14939, + X86_VSUBSDZrm_Intk = 14940, + X86_VSUBSDZrm_Intkz = 14941, + X86_VSUBSDZrr = 14942, + X86_VSUBSDZrr_Int = 14943, + X86_VSUBSDZrr_Intk = 14944, + X86_VSUBSDZrr_Intkz = 14945, + X86_VSUBSDZrrb_Int = 14946, + X86_VSUBSDZrrb_Intk = 14947, + X86_VSUBSDZrrb_Intkz = 14948, + X86_VSUBSDrm = 14949, + X86_VSUBSDrm_Int = 14950, + X86_VSUBSDrr = 14951, + X86_VSUBSDrr_Int = 14952, + X86_VSUBSSZrm = 14953, + X86_VSUBSSZrm_Int = 14954, + X86_VSUBSSZrm_Intk = 14955, + X86_VSUBSSZrm_Intkz = 14956, + X86_VSUBSSZrr = 14957, + X86_VSUBSSZrr_Int = 14958, + X86_VSUBSSZrr_Intk = 14959, + X86_VSUBSSZrr_Intkz = 14960, + X86_VSUBSSZrrb_Int = 14961, + X86_VSUBSSZrrb_Intk = 14962, + X86_VSUBSSZrrb_Intkz = 14963, + X86_VSUBSSrm = 14964, + X86_VSUBSSrm_Int = 14965, + X86_VSUBSSrr = 14966, + X86_VSUBSSrr_Int = 14967, + X86_VTESTPDYrm = 14968, + X86_VTESTPDYrr = 14969, + X86_VTESTPDrm = 14970, + X86_VTESTPDrr = 14971, + X86_VTESTPSYrm = 14972, + X86_VTESTPSYrr = 14973, + X86_VTESTPSrm = 14974, + X86_VTESTPSrr = 14975, + X86_VUCOMISDZrm = 14976, + X86_VUCOMISDZrm_Int = 14977, + X86_VUCOMISDZrr = 14978, + X86_VUCOMISDZrr_Int = 14979, + X86_VUCOMISDZrrb = 14980, + X86_VUCOMISDrm = 14981, + X86_VUCOMISDrm_Int = 14982, + X86_VUCOMISDrr = 14983, + X86_VUCOMISDrr_Int = 14984, + X86_VUCOMISSZrm = 14985, + X86_VUCOMISSZrm_Int = 14986, + X86_VUCOMISSZrr = 14987, + X86_VUCOMISSZrr_Int = 14988, + X86_VUCOMISSZrrb = 14989, + X86_VUCOMISSrm = 14990, + X86_VUCOMISSrm_Int = 14991, + X86_VUCOMISSrr = 14992, + X86_VUCOMISSrr_Int = 14993, + X86_VUNPCKHPDYrm = 14994, + X86_VUNPCKHPDYrr = 14995, + X86_VUNPCKHPDZ128rm = 14996, + X86_VUNPCKHPDZ128rmb = 14997, + X86_VUNPCKHPDZ128rmbk = 14998, + X86_VUNPCKHPDZ128rmbkz = 14999, + X86_VUNPCKHPDZ128rmk = 15000, + X86_VUNPCKHPDZ128rmkz = 15001, + X86_VUNPCKHPDZ128rr = 15002, + X86_VUNPCKHPDZ128rrk = 15003, + X86_VUNPCKHPDZ128rrkz = 15004, + X86_VUNPCKHPDZ256rm = 15005, + X86_VUNPCKHPDZ256rmb = 15006, + X86_VUNPCKHPDZ256rmbk = 15007, + X86_VUNPCKHPDZ256rmbkz = 15008, + X86_VUNPCKHPDZ256rmk = 15009, + X86_VUNPCKHPDZ256rmkz = 15010, + X86_VUNPCKHPDZ256rr = 15011, + X86_VUNPCKHPDZ256rrk = 15012, + X86_VUNPCKHPDZ256rrkz = 15013, + X86_VUNPCKHPDZrm = 15014, + X86_VUNPCKHPDZrmb = 15015, + X86_VUNPCKHPDZrmbk = 15016, + X86_VUNPCKHPDZrmbkz = 15017, + X86_VUNPCKHPDZrmk = 15018, + X86_VUNPCKHPDZrmkz = 15019, + X86_VUNPCKHPDZrr = 15020, + X86_VUNPCKHPDZrrk = 15021, + X86_VUNPCKHPDZrrkz = 15022, + X86_VUNPCKHPDrm = 15023, + X86_VUNPCKHPDrr = 15024, + X86_VUNPCKHPSYrm = 15025, + X86_VUNPCKHPSYrr = 15026, + X86_VUNPCKHPSZ128rm = 15027, + X86_VUNPCKHPSZ128rmb = 15028, + X86_VUNPCKHPSZ128rmbk = 15029, + X86_VUNPCKHPSZ128rmbkz = 15030, + X86_VUNPCKHPSZ128rmk = 15031, + X86_VUNPCKHPSZ128rmkz = 15032, + X86_VUNPCKHPSZ128rr = 15033, + X86_VUNPCKHPSZ128rrk = 15034, + X86_VUNPCKHPSZ128rrkz = 15035, + X86_VUNPCKHPSZ256rm = 15036, + X86_VUNPCKHPSZ256rmb = 15037, + X86_VUNPCKHPSZ256rmbk = 15038, + X86_VUNPCKHPSZ256rmbkz = 15039, + X86_VUNPCKHPSZ256rmk = 15040, + X86_VUNPCKHPSZ256rmkz = 15041, + X86_VUNPCKHPSZ256rr = 15042, + X86_VUNPCKHPSZ256rrk = 15043, + X86_VUNPCKHPSZ256rrkz = 15044, + X86_VUNPCKHPSZrm = 15045, + X86_VUNPCKHPSZrmb = 15046, + X86_VUNPCKHPSZrmbk = 15047, + X86_VUNPCKHPSZrmbkz = 15048, + X86_VUNPCKHPSZrmk = 15049, + X86_VUNPCKHPSZrmkz = 15050, + X86_VUNPCKHPSZrr = 15051, + X86_VUNPCKHPSZrrk = 15052, + X86_VUNPCKHPSZrrkz = 15053, + X86_VUNPCKHPSrm = 15054, + X86_VUNPCKHPSrr = 15055, + X86_VUNPCKLPDYrm = 15056, + X86_VUNPCKLPDYrr = 15057, + X86_VUNPCKLPDZ128rm = 15058, + X86_VUNPCKLPDZ128rmb = 15059, + X86_VUNPCKLPDZ128rmbk = 15060, + X86_VUNPCKLPDZ128rmbkz = 15061, + X86_VUNPCKLPDZ128rmk = 15062, + X86_VUNPCKLPDZ128rmkz = 15063, + X86_VUNPCKLPDZ128rr = 15064, + X86_VUNPCKLPDZ128rrk = 15065, + X86_VUNPCKLPDZ128rrkz = 15066, + X86_VUNPCKLPDZ256rm = 15067, + X86_VUNPCKLPDZ256rmb = 15068, + X86_VUNPCKLPDZ256rmbk = 15069, + X86_VUNPCKLPDZ256rmbkz = 15070, + X86_VUNPCKLPDZ256rmk = 15071, + X86_VUNPCKLPDZ256rmkz = 15072, + X86_VUNPCKLPDZ256rr = 15073, + X86_VUNPCKLPDZ256rrk = 15074, + X86_VUNPCKLPDZ256rrkz = 15075, + X86_VUNPCKLPDZrm = 15076, + X86_VUNPCKLPDZrmb = 15077, + X86_VUNPCKLPDZrmbk = 15078, + X86_VUNPCKLPDZrmbkz = 15079, + X86_VUNPCKLPDZrmk = 15080, + X86_VUNPCKLPDZrmkz = 15081, + X86_VUNPCKLPDZrr = 15082, + X86_VUNPCKLPDZrrk = 15083, + X86_VUNPCKLPDZrrkz = 15084, + X86_VUNPCKLPDrm = 15085, + X86_VUNPCKLPDrr = 15086, + X86_VUNPCKLPSYrm = 15087, + X86_VUNPCKLPSYrr = 15088, + X86_VUNPCKLPSZ128rm = 15089, + X86_VUNPCKLPSZ128rmb = 15090, + X86_VUNPCKLPSZ128rmbk = 15091, + X86_VUNPCKLPSZ128rmbkz = 15092, + X86_VUNPCKLPSZ128rmk = 15093, + X86_VUNPCKLPSZ128rmkz = 15094, + X86_VUNPCKLPSZ128rr = 15095, + X86_VUNPCKLPSZ128rrk = 15096, + X86_VUNPCKLPSZ128rrkz = 15097, + X86_VUNPCKLPSZ256rm = 15098, + X86_VUNPCKLPSZ256rmb = 15099, + X86_VUNPCKLPSZ256rmbk = 15100, + X86_VUNPCKLPSZ256rmbkz = 15101, + X86_VUNPCKLPSZ256rmk = 15102, + X86_VUNPCKLPSZ256rmkz = 15103, + X86_VUNPCKLPSZ256rr = 15104, + X86_VUNPCKLPSZ256rrk = 15105, + X86_VUNPCKLPSZ256rrkz = 15106, + X86_VUNPCKLPSZrm = 15107, + X86_VUNPCKLPSZrmb = 15108, + X86_VUNPCKLPSZrmbk = 15109, + X86_VUNPCKLPSZrmbkz = 15110, + X86_VUNPCKLPSZrmk = 15111, + X86_VUNPCKLPSZrmkz = 15112, + X86_VUNPCKLPSZrr = 15113, + X86_VUNPCKLPSZrrk = 15114, + X86_VUNPCKLPSZrrkz = 15115, + X86_VUNPCKLPSrm = 15116, + X86_VUNPCKLPSrr = 15117, + X86_VXORPDYrm = 15118, + X86_VXORPDYrr = 15119, + X86_VXORPDZ128rm = 15120, + X86_VXORPDZ128rmb = 15121, + X86_VXORPDZ128rmbk = 15122, + X86_VXORPDZ128rmbkz = 15123, + X86_VXORPDZ128rmk = 15124, + X86_VXORPDZ128rmkz = 15125, + X86_VXORPDZ128rr = 15126, + X86_VXORPDZ128rrk = 15127, + X86_VXORPDZ128rrkz = 15128, + X86_VXORPDZ256rm = 15129, + X86_VXORPDZ256rmb = 15130, + X86_VXORPDZ256rmbk = 15131, + X86_VXORPDZ256rmbkz = 15132, + X86_VXORPDZ256rmk = 15133, + X86_VXORPDZ256rmkz = 15134, + X86_VXORPDZ256rr = 15135, + X86_VXORPDZ256rrk = 15136, + X86_VXORPDZ256rrkz = 15137, + X86_VXORPDZrm = 15138, + X86_VXORPDZrmb = 15139, + X86_VXORPDZrmbk = 15140, + X86_VXORPDZrmbkz = 15141, + X86_VXORPDZrmk = 15142, + X86_VXORPDZrmkz = 15143, + X86_VXORPDZrr = 15144, + X86_VXORPDZrrk = 15145, + X86_VXORPDZrrkz = 15146, + X86_VXORPDrm = 15147, + X86_VXORPDrr = 15148, + X86_VXORPSYrm = 15149, + X86_VXORPSYrr = 15150, + X86_VXORPSZ128rm = 15151, + X86_VXORPSZ128rmb = 15152, + X86_VXORPSZ128rmbk = 15153, + X86_VXORPSZ128rmbkz = 15154, + X86_VXORPSZ128rmk = 15155, + X86_VXORPSZ128rmkz = 15156, + X86_VXORPSZ128rr = 15157, + X86_VXORPSZ128rrk = 15158, + X86_VXORPSZ128rrkz = 15159, + X86_VXORPSZ256rm = 15160, + X86_VXORPSZ256rmb = 15161, + X86_VXORPSZ256rmbk = 15162, + X86_VXORPSZ256rmbkz = 15163, + X86_VXORPSZ256rmk = 15164, + X86_VXORPSZ256rmkz = 15165, + X86_VXORPSZ256rr = 15166, + X86_VXORPSZ256rrk = 15167, + X86_VXORPSZ256rrkz = 15168, + X86_VXORPSZrm = 15169, + X86_VXORPSZrmb = 15170, + X86_VXORPSZrmbk = 15171, + X86_VXORPSZrmbkz = 15172, + X86_VXORPSZrmk = 15173, + X86_VXORPSZrmkz = 15174, + X86_VXORPSZrr = 15175, + X86_VXORPSZrrk = 15176, + X86_VXORPSZrrkz = 15177, + X86_VXORPSrm = 15178, + X86_VXORPSrr = 15179, + X86_VZEROALL = 15180, + X86_VZEROUPPER = 15181, + X86_WAIT = 15182, + X86_WBINVD = 15183, + X86_WBNOINVD = 15184, + X86_WRFSBASE = 15185, + X86_WRFSBASE64 = 15186, + X86_WRGSBASE = 15187, + X86_WRGSBASE64 = 15188, + X86_WRMSR = 15189, + X86_WRPKRUr = 15190, + X86_WRSSD = 15191, + X86_WRSSQ = 15192, + X86_WRUSSD = 15193, + X86_WRUSSQ = 15194, + X86_XABORT = 15195, + X86_XACQUIRE_PREFIX = 15196, + X86_XADD16rm = 15197, + X86_XADD16rr = 15198, + X86_XADD32rm = 15199, + X86_XADD32rr = 15200, + X86_XADD64rm = 15201, + X86_XADD64rr = 15202, + X86_XADD8rm = 15203, + X86_XADD8rr = 15204, + X86_XBEGIN_2 = 15205, + X86_XBEGIN_4 = 15206, + X86_XCHG16ar = 15207, + X86_XCHG16rm = 15208, + X86_XCHG16rr = 15209, + X86_XCHG32ar = 15210, + X86_XCHG32rm = 15211, + X86_XCHG32rr = 15212, + X86_XCHG64ar = 15213, + X86_XCHG64rm = 15214, + X86_XCHG64rr = 15215, + X86_XCHG8rm = 15216, + X86_XCHG8rr = 15217, + X86_XCH_F = 15218, + X86_XCRYPTCBC = 15219, + X86_XCRYPTCFB = 15220, + X86_XCRYPTCTR = 15221, + X86_XCRYPTECB = 15222, + X86_XCRYPTOFB = 15223, + X86_XEND = 15224, + X86_XGETBV = 15225, + X86_XLAT = 15226, + X86_XOR16i16 = 15227, + X86_XOR16mi = 15228, + X86_XOR16mi8 = 15229, + X86_XOR16mr = 15230, + X86_XOR16ri = 15231, + X86_XOR16ri8 = 15232, + X86_XOR16rm = 15233, + X86_XOR16rr = 15234, + X86_XOR16rr_REV = 15235, + X86_XOR32i32 = 15236, + X86_XOR32mi = 15237, + X86_XOR32mi8 = 15238, + X86_XOR32mr = 15239, + X86_XOR32ri = 15240, + X86_XOR32ri8 = 15241, + X86_XOR32rm = 15242, + X86_XOR32rr = 15243, + X86_XOR32rr_REV = 15244, + X86_XOR64i32 = 15245, + X86_XOR64mi32 = 15246, + X86_XOR64mi8 = 15247, + X86_XOR64mr = 15248, + X86_XOR64ri32 = 15249, + X86_XOR64ri8 = 15250, + X86_XOR64rm = 15251, + X86_XOR64rr = 15252, + X86_XOR64rr_REV = 15253, + X86_XOR8i8 = 15254, + X86_XOR8mi = 15255, + X86_XOR8mi8 = 15256, + X86_XOR8mr = 15257, + X86_XOR8ri = 15258, + X86_XOR8ri8 = 15259, + X86_XOR8rm = 15260, + X86_XOR8rr = 15261, + X86_XOR8rr_REV = 15262, + X86_XORPDrm = 15263, + X86_XORPDrr = 15264, + X86_XORPSrm = 15265, + X86_XORPSrr = 15266, + X86_XRELEASE_PREFIX = 15267, + X86_XRSTOR = 15268, + X86_XRSTOR64 = 15269, + X86_XRSTORS = 15270, + X86_XRSTORS64 = 15271, + X86_XSAVE = 15272, + X86_XSAVE64 = 15273, + X86_XSAVEC = 15274, + X86_XSAVEC64 = 15275, + X86_XSAVEOPT = 15276, + X86_XSAVEOPT64 = 15277, + X86_XSAVES = 15278, + X86_XSAVES64 = 15279, + X86_XSETBV = 15280, + X86_XSHA1 = 15281, + X86_XSHA256 = 15282, + X86_XSTORE = 15283, + X86_XTEST = 15284, + X86_INSTRUCTION_LIST_END = 15285 +}; + +#endif // GET_INSTRINFO_ENUM |