diff options
Diffstat (limited to 'capstone/arch/X86/X86MappingInsnName.inc')
| -rw-r--r-- | capstone/arch/X86/X86MappingInsnName.inc | 1527 |
1 files changed, 1527 insertions, 0 deletions
diff --git a/capstone/arch/X86/X86MappingInsnName.inc b/capstone/arch/X86/X86MappingInsnName.inc new file mode 100644 index 000000000..81adb4339 --- /dev/null +++ b/capstone/arch/X86/X86MappingInsnName.inc @@ -0,0 +1,1527 @@ +/* Capstone Disassembly Engine, http://www.capstone-engine.org */ +/* This is auto-gen data for Capstone disassembly engine (www.capstone-engine.org) */ +/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */ + + "aaa", // X86_INS_AAA + "aad", // X86_INS_AAD + "aam", // X86_INS_AAM + "aas", // X86_INS_AAS + "fabs", // X86_INS_FABS + "adc", // X86_INS_ADC + "adcx", // X86_INS_ADCX + "add", // X86_INS_ADD + "addpd", // X86_INS_ADDPD + "addps", // X86_INS_ADDPS + "addsd", // X86_INS_ADDSD + "addss", // X86_INS_ADDSS + "addsubpd", // X86_INS_ADDSUBPD + "addsubps", // X86_INS_ADDSUBPS + "fadd", // X86_INS_FADD + "fiadd", // X86_INS_FIADD + "adox", // X86_INS_ADOX + "aesdeclast", // X86_INS_AESDECLAST + "aesdec", // X86_INS_AESDEC + "aesenclast", // X86_INS_AESENCLAST + "aesenc", // X86_INS_AESENC + "aesimc", // X86_INS_AESIMC + "aeskeygenassist", // X86_INS_AESKEYGENASSIST + "and", // X86_INS_AND + "andn", // X86_INS_ANDN + "andnpd", // X86_INS_ANDNPD + "andnps", // X86_INS_ANDNPS + "andpd", // X86_INS_ANDPD + "andps", // X86_INS_ANDPS + "arpl", // X86_INS_ARPL + "bextr", // X86_INS_BEXTR + "blcfill", // X86_INS_BLCFILL + "blci", // X86_INS_BLCI + "blcic", // X86_INS_BLCIC + "blcmsk", // X86_INS_BLCMSK + "blcs", // X86_INS_BLCS + "blendpd", // X86_INS_BLENDPD + "blendps", // X86_INS_BLENDPS + "blendvpd", // X86_INS_BLENDVPD + "blendvps", // X86_INS_BLENDVPS + "blsfill", // X86_INS_BLSFILL + "blsi", // X86_INS_BLSI + "blsic", // X86_INS_BLSIC + "blsmsk", // X86_INS_BLSMSK + "blsr", // X86_INS_BLSR + "bndcl", // X86_INS_BNDCL + "bndcn", // X86_INS_BNDCN + "bndcu", // X86_INS_BNDCU + "bndldx", // X86_INS_BNDLDX + "bndmk", // X86_INS_BNDMK + "bndmov", // X86_INS_BNDMOV + "bndstx", // X86_INS_BNDSTX + "bound", // X86_INS_BOUND + "bsf", // X86_INS_BSF + "bsr", // X86_INS_BSR + "bswap", // X86_INS_BSWAP + "bt", // X86_INS_BT + "btc", // X86_INS_BTC + "btr", // X86_INS_BTR + "bts", // X86_INS_BTS + "bzhi", // X86_INS_BZHI + "call", // X86_INS_CALL + "cbw", // X86_INS_CBW + "cdq", // X86_INS_CDQ + "cdqe", // X86_INS_CDQE + "fchs", // X86_INS_FCHS + "clac", // X86_INS_CLAC + "clc", // X86_INS_CLC + "cld", // X86_INS_CLD + "cldemote", // X86_INS_CLDEMOTE + "clflush", // X86_INS_CLFLUSH + "clflushopt", // X86_INS_CLFLUSHOPT + "clgi", // X86_INS_CLGI + "cli", // X86_INS_CLI + "clrssbsy", // X86_INS_CLRSSBSY + "clts", // X86_INS_CLTS + "clwb", // X86_INS_CLWB + "clzero", // X86_INS_CLZERO + "cmc", // X86_INS_CMC + "cmova", // X86_INS_CMOVA + "cmovae", // X86_INS_CMOVAE + "cmovb", // X86_INS_CMOVB + "cmovbe", // X86_INS_CMOVBE + "fcmovbe", // X86_INS_FCMOVBE + "fcmovb", // X86_INS_FCMOVB + "cmove", // X86_INS_CMOVE + "fcmove", // X86_INS_FCMOVE + "cmovg", // X86_INS_CMOVG + "cmovge", // X86_INS_CMOVGE + "cmovl", // X86_INS_CMOVL + "cmovle", // X86_INS_CMOVLE + "fcmovnbe", // X86_INS_FCMOVNBE + "fcmovnb", // X86_INS_FCMOVNB + "cmovne", // X86_INS_CMOVNE + "fcmovne", // X86_INS_FCMOVNE + "cmovno", // X86_INS_CMOVNO + "cmovnp", // X86_INS_CMOVNP + "fcmovnu", // X86_INS_FCMOVNU + "fcmovnp", // X86_INS_FCMOVNP + "cmovns", // X86_INS_CMOVNS + "cmovo", // X86_INS_CMOVO + "cmovp", // X86_INS_CMOVP + "fcmovu", // X86_INS_FCMOVU + "cmovs", // X86_INS_CMOVS + "cmp", // X86_INS_CMP + "cmppd", // X86_INS_CMPPD + "cmpps", // X86_INS_CMPPS + "cmpsb", // X86_INS_CMPSB + "cmpsd", // X86_INS_CMPSD + "cmpsq", // X86_INS_CMPSQ + "cmpss", // X86_INS_CMPSS + "cmpsw", // X86_INS_CMPSW + "cmpxchg16b", // X86_INS_CMPXCHG16B + "cmpxchg", // X86_INS_CMPXCHG + "cmpxchg8b", // X86_INS_CMPXCHG8B + "comisd", // X86_INS_COMISD + "comiss", // X86_INS_COMISS + "fcomp", // X86_INS_FCOMP + "fcompi", // X86_INS_FCOMPI + "fcomi", // X86_INS_FCOMI + "fcom", // X86_INS_FCOM + "fcos", // X86_INS_FCOS + "cpuid", // X86_INS_CPUID + "cqo", // X86_INS_CQO + "crc32", // X86_INS_CRC32 + "cvtdq2pd", // X86_INS_CVTDQ2PD + "cvtdq2ps", // X86_INS_CVTDQ2PS + "cvtpd2dq", // X86_INS_CVTPD2DQ + "cvtpd2ps", // X86_INS_CVTPD2PS + "cvtps2dq", // X86_INS_CVTPS2DQ + "cvtps2pd", // X86_INS_CVTPS2PD + "cvtsd2si", // X86_INS_CVTSD2SI + "cvtsd2ss", // X86_INS_CVTSD2SS + "cvtsi2sd", // X86_INS_CVTSI2SD + "cvtsi2ss", // X86_INS_CVTSI2SS + "cvtss2sd", // X86_INS_CVTSS2SD + "cvtss2si", // X86_INS_CVTSS2SI + "cvttpd2dq", // X86_INS_CVTTPD2DQ + "cvttps2dq", // X86_INS_CVTTPS2DQ + "cvttsd2si", // X86_INS_CVTTSD2SI + "cvttss2si", // X86_INS_CVTTSS2SI + "cwd", // X86_INS_CWD + "cwde", // X86_INS_CWDE + "daa", // X86_INS_DAA + "das", // X86_INS_DAS + "data16", // X86_INS_DATA16 + "dec", // X86_INS_DEC + "div", // X86_INS_DIV + "divpd", // X86_INS_DIVPD + "divps", // X86_INS_DIVPS + "fdivr", // X86_INS_FDIVR + "fidivr", // X86_INS_FIDIVR + "fdivrp", // X86_INS_FDIVRP + "divsd", // X86_INS_DIVSD + "divss", // X86_INS_DIVSS + "fdiv", // X86_INS_FDIV + "fidiv", // X86_INS_FIDIV + "fdivp", // X86_INS_FDIVP + "dppd", // X86_INS_DPPD + "dpps", // X86_INS_DPPS + "encls", // X86_INS_ENCLS + "enclu", // X86_INS_ENCLU + "enclv", // X86_INS_ENCLV + "endbr32", // X86_INS_ENDBR32 + "endbr64", // X86_INS_ENDBR64 + "enter", // X86_INS_ENTER + "extractps", // X86_INS_EXTRACTPS + "extrq", // X86_INS_EXTRQ + "f2xm1", // X86_INS_F2XM1 + "lcall", // X86_INS_LCALL + "ljmp", // X86_INS_LJMP + "jmp", // X86_INS_JMP + "fbld", // X86_INS_FBLD + "fbstp", // X86_INS_FBSTP + "fcompp", // X86_INS_FCOMPP + "fdecstp", // X86_INS_FDECSTP + "fdisi8087_nop", // X86_INS_FDISI8087_NOP + "femms", // X86_INS_FEMMS + "feni8087_nop", // X86_INS_FENI8087_NOP + "ffree", // X86_INS_FFREE + "ffreep", // X86_INS_FFREEP + "ficom", // X86_INS_FICOM + "ficomp", // X86_INS_FICOMP + "fincstp", // X86_INS_FINCSTP + "fldcw", // X86_INS_FLDCW + "fldenv", // X86_INS_FLDENV + "fldl2e", // X86_INS_FLDL2E + "fldl2t", // X86_INS_FLDL2T + "fldlg2", // X86_INS_FLDLG2 + "fldln2", // X86_INS_FLDLN2 + "fldpi", // X86_INS_FLDPI + "fnclex", // X86_INS_FNCLEX + "fninit", // X86_INS_FNINIT + "fnop", // X86_INS_FNOP + "fnstcw", // X86_INS_FNSTCW + "fnstsw", // X86_INS_FNSTSW + "fpatan", // X86_INS_FPATAN + "fstpnce", // X86_INS_FSTPNCE + "fprem", // X86_INS_FPREM + "fprem1", // X86_INS_FPREM1 + "fptan", // X86_INS_FPTAN + "frndint", // X86_INS_FRNDINT + "frstor", // X86_INS_FRSTOR + "fnsave", // X86_INS_FNSAVE + "fscale", // X86_INS_FSCALE + "fsetpm", // X86_INS_FSETPM + "fsincos", // X86_INS_FSINCOS + "fnstenv", // X86_INS_FNSTENV + "fxam", // X86_INS_FXAM + "fxrstor", // X86_INS_FXRSTOR + "fxrstor64", // X86_INS_FXRSTOR64 + "fxsave", // X86_INS_FXSAVE + "fxsave64", // X86_INS_FXSAVE64 + "fxtract", // X86_INS_FXTRACT + "fyl2x", // X86_INS_FYL2X + "fyl2xp1", // X86_INS_FYL2XP1 + "getsec", // X86_INS_GETSEC + "gf2p8affineinvqb", // X86_INS_GF2P8AFFINEINVQB + "gf2p8affineqb", // X86_INS_GF2P8AFFINEQB + "gf2p8mulb", // X86_INS_GF2P8MULB + "haddpd", // X86_INS_HADDPD + "haddps", // X86_INS_HADDPS + "hlt", // X86_INS_HLT + "hsubpd", // X86_INS_HSUBPD + "hsubps", // X86_INS_HSUBPS + "idiv", // X86_INS_IDIV + "fild", // X86_INS_FILD + "imul", // X86_INS_IMUL + "in", // X86_INS_IN + "inc", // X86_INS_INC + "incsspd", // X86_INS_INCSSPD + "incsspq", // X86_INS_INCSSPQ + "insb", // X86_INS_INSB + "insertps", // X86_INS_INSERTPS + "insertq", // X86_INS_INSERTQ + "insd", // X86_INS_INSD + "insw", // X86_INS_INSW + "int", // X86_INS_INT + "int1", // X86_INS_INT1 + "int3", // X86_INS_INT3 + "into", // X86_INS_INTO + "invd", // X86_INS_INVD + "invept", // X86_INS_INVEPT + "invlpg", // X86_INS_INVLPG + "invlpga", // X86_INS_INVLPGA + "invpcid", // X86_INS_INVPCID + "invvpid", // X86_INS_INVVPID + "iret", // X86_INS_IRET + "iretd", // X86_INS_IRETD + "iretq", // X86_INS_IRETQ + "fisttp", // X86_INS_FISTTP + "fist", // X86_INS_FIST + "fistp", // X86_INS_FISTP + "jae", // X86_INS_JAE + "ja", // X86_INS_JA + "jbe", // X86_INS_JBE + "jb", // X86_INS_JB + "jcxz", // X86_INS_JCXZ + "jecxz", // X86_INS_JECXZ + "je", // X86_INS_JE + "jge", // X86_INS_JGE + "jg", // X86_INS_JG + "jle", // X86_INS_JLE + "jl", // X86_INS_JL + "jne", // X86_INS_JNE + "jno", // X86_INS_JNO + "jnp", // X86_INS_JNP + "jns", // X86_INS_JNS + "jo", // X86_INS_JO + "jp", // X86_INS_JP + "jrcxz", // X86_INS_JRCXZ + "js", // X86_INS_JS + "kaddb", // X86_INS_KADDB + "kaddd", // X86_INS_KADDD + "kaddq", // X86_INS_KADDQ + "kaddw", // X86_INS_KADDW + "kandb", // X86_INS_KANDB + "kandd", // X86_INS_KANDD + "kandnb", // X86_INS_KANDNB + "kandnd", // X86_INS_KANDND + "kandnq", // X86_INS_KANDNQ + "kandnw", // X86_INS_KANDNW + "kandq", // X86_INS_KANDQ + "kandw", // X86_INS_KANDW + "kmovb", // X86_INS_KMOVB + "kmovd", // X86_INS_KMOVD + "kmovq", // X86_INS_KMOVQ + "kmovw", // X86_INS_KMOVW + "knotb", // X86_INS_KNOTB + "knotd", // X86_INS_KNOTD + "knotq", // X86_INS_KNOTQ + "knotw", // X86_INS_KNOTW + "korb", // X86_INS_KORB + "kord", // X86_INS_KORD + "korq", // X86_INS_KORQ + "kortestb", // X86_INS_KORTESTB + "kortestd", // X86_INS_KORTESTD + "kortestq", // X86_INS_KORTESTQ + "kortestw", // X86_INS_KORTESTW + "korw", // X86_INS_KORW + "kshiftlb", // X86_INS_KSHIFTLB + "kshiftld", // X86_INS_KSHIFTLD + "kshiftlq", // X86_INS_KSHIFTLQ + "kshiftlw", // X86_INS_KSHIFTLW + "kshiftrb", // X86_INS_KSHIFTRB + "kshiftrd", // X86_INS_KSHIFTRD + "kshiftrq", // X86_INS_KSHIFTRQ + "kshiftrw", // X86_INS_KSHIFTRW + "ktestb", // X86_INS_KTESTB + "ktestd", // X86_INS_KTESTD + "ktestq", // X86_INS_KTESTQ + "ktestw", // X86_INS_KTESTW + "kunpckbw", // X86_INS_KUNPCKBW + "kunpckdq", // X86_INS_KUNPCKDQ + "kunpckwd", // X86_INS_KUNPCKWD + "kxnorb", // X86_INS_KXNORB + "kxnord", // X86_INS_KXNORD + "kxnorq", // X86_INS_KXNORQ + "kxnorw", // X86_INS_KXNORW + "kxorb", // X86_INS_KXORB + "kxord", // X86_INS_KXORD + "kxorq", // X86_INS_KXORQ + "kxorw", // X86_INS_KXORW + "lahf", // X86_INS_LAHF + "lar", // X86_INS_LAR + "lddqu", // X86_INS_LDDQU + "ldmxcsr", // X86_INS_LDMXCSR + "lds", // X86_INS_LDS + "fldz", // X86_INS_FLDZ + "fld1", // X86_INS_FLD1 + "fld", // X86_INS_FLD + "lea", // X86_INS_LEA + "leave", // X86_INS_LEAVE + "les", // X86_INS_LES + "lfence", // X86_INS_LFENCE + "lfs", // X86_INS_LFS + "lgdt", // X86_INS_LGDT + "lgs", // X86_INS_LGS + "lidt", // X86_INS_LIDT + "lldt", // X86_INS_LLDT + "llwpcb", // X86_INS_LLWPCB + "lmsw", // X86_INS_LMSW + "lock", // X86_INS_LOCK + "lodsb", // X86_INS_LODSB + "lodsd", // X86_INS_LODSD + "lodsq", // X86_INS_LODSQ + "lodsw", // X86_INS_LODSW + "loop", // X86_INS_LOOP + "loope", // X86_INS_LOOPE + "loopne", // X86_INS_LOOPNE + "retf", // X86_INS_RETF + "retfq", // X86_INS_RETFQ + "lsl", // X86_INS_LSL + "lss", // X86_INS_LSS + "ltr", // X86_INS_LTR + "lwpins", // X86_INS_LWPINS + "lwpval", // X86_INS_LWPVAL + "lzcnt", // X86_INS_LZCNT + "maskmovdqu", // X86_INS_MASKMOVDQU + "maxpd", // X86_INS_MAXPD + "maxps", // X86_INS_MAXPS + "maxsd", // X86_INS_MAXSD + "maxss", // X86_INS_MAXSS + "mfence", // X86_INS_MFENCE + "minpd", // X86_INS_MINPD + "minps", // X86_INS_MINPS + "minsd", // X86_INS_MINSD + "minss", // X86_INS_MINSS + "cvtpd2pi", // X86_INS_CVTPD2PI + "cvtpi2pd", // X86_INS_CVTPI2PD + "cvtpi2ps", // X86_INS_CVTPI2PS + "cvtps2pi", // X86_INS_CVTPS2PI + "cvttpd2pi", // X86_INS_CVTTPD2PI + "cvttps2pi", // X86_INS_CVTTPS2PI + "emms", // X86_INS_EMMS + "maskmovq", // X86_INS_MASKMOVQ + "movd", // X86_INS_MOVD + "movq", // X86_INS_MOVQ + "movdq2q", // X86_INS_MOVDQ2Q + "movntq", // X86_INS_MOVNTQ + "movq2dq", // X86_INS_MOVQ2DQ + "pabsb", // X86_INS_PABSB + "pabsd", // X86_INS_PABSD + "pabsw", // X86_INS_PABSW + "packssdw", // X86_INS_PACKSSDW + "packsswb", // X86_INS_PACKSSWB + "packuswb", // X86_INS_PACKUSWB + "paddb", // X86_INS_PADDB + "paddd", // X86_INS_PADDD + "paddq", // X86_INS_PADDQ + "paddsb", // X86_INS_PADDSB + "paddsw", // X86_INS_PADDSW + "paddusb", // X86_INS_PADDUSB + "paddusw", // X86_INS_PADDUSW + "paddw", // X86_INS_PADDW + "palignr", // X86_INS_PALIGNR + "pandn", // X86_INS_PANDN + "pand", // X86_INS_PAND + "pavgb", // X86_INS_PAVGB + "pavgw", // X86_INS_PAVGW + "pcmpeqb", // X86_INS_PCMPEQB + "pcmpeqd", // X86_INS_PCMPEQD + "pcmpeqw", // X86_INS_PCMPEQW + "pcmpgtb", // X86_INS_PCMPGTB + "pcmpgtd", // X86_INS_PCMPGTD + "pcmpgtw", // X86_INS_PCMPGTW + "pextrw", // X86_INS_PEXTRW + "phaddd", // X86_INS_PHADDD + "phaddsw", // X86_INS_PHADDSW + "phaddw", // X86_INS_PHADDW + "phsubd", // X86_INS_PHSUBD + "phsubsw", // X86_INS_PHSUBSW + "phsubw", // X86_INS_PHSUBW + "pinsrw", // X86_INS_PINSRW + "pmaddubsw", // X86_INS_PMADDUBSW + "pmaddwd", // X86_INS_PMADDWD + "pmaxsw", // X86_INS_PMAXSW + "pmaxub", // X86_INS_PMAXUB + "pminsw", // X86_INS_PMINSW + "pminub", // X86_INS_PMINUB + "pmovmskb", // X86_INS_PMOVMSKB + "pmulhrsw", // X86_INS_PMULHRSW + "pmulhuw", // X86_INS_PMULHUW + "pmulhw", // X86_INS_PMULHW + "pmullw", // X86_INS_PMULLW + "pmuludq", // X86_INS_PMULUDQ + "por", // X86_INS_POR + "psadbw", // X86_INS_PSADBW + "pshufb", // X86_INS_PSHUFB + "pshufw", // X86_INS_PSHUFW + "psignb", // X86_INS_PSIGNB + "psignd", // X86_INS_PSIGND + "psignw", // X86_INS_PSIGNW + "pslld", // X86_INS_PSLLD + "psllq", // X86_INS_PSLLQ + "psllw", // X86_INS_PSLLW + "psrad", // X86_INS_PSRAD + "psraw", // X86_INS_PSRAW + "psrld", // X86_INS_PSRLD + "psrlq", // X86_INS_PSRLQ + "psrlw", // X86_INS_PSRLW + "psubb", // X86_INS_PSUBB + "psubd", // X86_INS_PSUBD + "psubq", // X86_INS_PSUBQ + "psubsb", // X86_INS_PSUBSB + "psubsw", // X86_INS_PSUBSW + "psubusb", // X86_INS_PSUBUSB + "psubusw", // X86_INS_PSUBUSW + "psubw", // X86_INS_PSUBW + "punpckhbw", // X86_INS_PUNPCKHBW + "punpckhdq", // X86_INS_PUNPCKHDQ + "punpckhwd", // X86_INS_PUNPCKHWD + "punpcklbw", // X86_INS_PUNPCKLBW + "punpckldq", // X86_INS_PUNPCKLDQ + "punpcklwd", // X86_INS_PUNPCKLWD + "pxor", // X86_INS_PXOR + "monitorx", // X86_INS_MONITORX + "monitor", // X86_INS_MONITOR + "montmul", // X86_INS_MONTMUL + "mov", // X86_INS_MOV + "movabs", // X86_INS_MOVABS + "movapd", // X86_INS_MOVAPD + "movaps", // X86_INS_MOVAPS + "movbe", // X86_INS_MOVBE + "movddup", // X86_INS_MOVDDUP + "movdir64b", // X86_INS_MOVDIR64B + "movdiri", // X86_INS_MOVDIRI + "movdqa", // X86_INS_MOVDQA + "movdqu", // X86_INS_MOVDQU + "movhlps", // X86_INS_MOVHLPS + "movhpd", // X86_INS_MOVHPD + "movhps", // X86_INS_MOVHPS + "movlhps", // X86_INS_MOVLHPS + "movlpd", // X86_INS_MOVLPD + "movlps", // X86_INS_MOVLPS + "movmskpd", // X86_INS_MOVMSKPD + "movmskps", // X86_INS_MOVMSKPS + "movntdqa", // X86_INS_MOVNTDQA + "movntdq", // X86_INS_MOVNTDQ + "movnti", // X86_INS_MOVNTI + "movntpd", // X86_INS_MOVNTPD + "movntps", // X86_INS_MOVNTPS + "movntsd", // X86_INS_MOVNTSD + "movntss", // X86_INS_MOVNTSS + "movsb", // X86_INS_MOVSB + "movsd", // X86_INS_MOVSD + "movshdup", // X86_INS_MOVSHDUP + "movsldup", // X86_INS_MOVSLDUP + "movsq", // X86_INS_MOVSQ + "movss", // X86_INS_MOVSS + "movsw", // X86_INS_MOVSW + "movsx", // X86_INS_MOVSX + "movsxd", // X86_INS_MOVSXD + "movupd", // X86_INS_MOVUPD + "movups", // X86_INS_MOVUPS + "movzx", // X86_INS_MOVZX + "mpsadbw", // X86_INS_MPSADBW + "mul", // X86_INS_MUL + "mulpd", // X86_INS_MULPD + "mulps", // X86_INS_MULPS + "mulsd", // X86_INS_MULSD + "mulss", // X86_INS_MULSS + "mulx", // X86_INS_MULX + "fmul", // X86_INS_FMUL + "fimul", // X86_INS_FIMUL + "fmulp", // X86_INS_FMULP + "mwaitx", // X86_INS_MWAITX + "mwait", // X86_INS_MWAIT + "neg", // X86_INS_NEG + "nop", // X86_INS_NOP + "not", // X86_INS_NOT + "or", // X86_INS_OR + "orpd", // X86_INS_ORPD + "orps", // X86_INS_ORPS + "out", // X86_INS_OUT + "outsb", // X86_INS_OUTSB + "outsd", // X86_INS_OUTSD + "outsw", // X86_INS_OUTSW + "packusdw", // X86_INS_PACKUSDW + "pause", // X86_INS_PAUSE + "pavgusb", // X86_INS_PAVGUSB + "pblendvb", // X86_INS_PBLENDVB + "pblendw", // X86_INS_PBLENDW + "pclmulqdq", // X86_INS_PCLMULQDQ + "pcmpeqq", // X86_INS_PCMPEQQ + "pcmpestri", // X86_INS_PCMPESTRI + "pcmpestrm", // X86_INS_PCMPESTRM + "pcmpgtq", // X86_INS_PCMPGTQ + "pcmpistri", // X86_INS_PCMPISTRI + "pcmpistrm", // X86_INS_PCMPISTRM + "pconfig", // X86_INS_PCONFIG + "pdep", // X86_INS_PDEP + "pext", // X86_INS_PEXT + "pextrb", // X86_INS_PEXTRB + "pextrd", // X86_INS_PEXTRD + "pextrq", // X86_INS_PEXTRQ + "pf2id", // X86_INS_PF2ID + "pf2iw", // X86_INS_PF2IW + "pfacc", // X86_INS_PFACC + "pfadd", // X86_INS_PFADD + "pfcmpeq", // X86_INS_PFCMPEQ + "pfcmpge", // X86_INS_PFCMPGE + "pfcmpgt", // X86_INS_PFCMPGT + "pfmax", // X86_INS_PFMAX + "pfmin", // X86_INS_PFMIN + "pfmul", // X86_INS_PFMUL + "pfnacc", // X86_INS_PFNACC + "pfpnacc", // X86_INS_PFPNACC + "pfrcpit1", // X86_INS_PFRCPIT1 + "pfrcpit2", // X86_INS_PFRCPIT2 + "pfrcp", // X86_INS_PFRCP + "pfrsqit1", // X86_INS_PFRSQIT1 + "pfrsqrt", // X86_INS_PFRSQRT + "pfsubr", // X86_INS_PFSUBR + "pfsub", // X86_INS_PFSUB + "phminposuw", // X86_INS_PHMINPOSUW + "pi2fd", // X86_INS_PI2FD + "pi2fw", // X86_INS_PI2FW + "pinsrb", // X86_INS_PINSRB + "pinsrd", // X86_INS_PINSRD + "pinsrq", // X86_INS_PINSRQ + "pmaxsb", // X86_INS_PMAXSB + "pmaxsd", // X86_INS_PMAXSD + "pmaxud", // X86_INS_PMAXUD + "pmaxuw", // X86_INS_PMAXUW + "pminsb", // X86_INS_PMINSB + "pminsd", // X86_INS_PMINSD + "pminud", // X86_INS_PMINUD + "pminuw", // X86_INS_PMINUW + "pmovsxbd", // X86_INS_PMOVSXBD + "pmovsxbq", // X86_INS_PMOVSXBQ + "pmovsxbw", // X86_INS_PMOVSXBW + "pmovsxdq", // X86_INS_PMOVSXDQ + "pmovsxwd", // X86_INS_PMOVSXWD + "pmovsxwq", // X86_INS_PMOVSXWQ + "pmovzxbd", // X86_INS_PMOVZXBD + "pmovzxbq", // X86_INS_PMOVZXBQ + "pmovzxbw", // X86_INS_PMOVZXBW + "pmovzxdq", // X86_INS_PMOVZXDQ + "pmovzxwd", // X86_INS_PMOVZXWD + "pmovzxwq", // X86_INS_PMOVZXWQ + "pmuldq", // X86_INS_PMULDQ + "pmulhrw", // X86_INS_PMULHRW + "pmulld", // X86_INS_PMULLD + "pop", // X86_INS_POP + "popaw", // X86_INS_POPAW + "popal", // X86_INS_POPAL + "popcnt", // X86_INS_POPCNT + "popf", // X86_INS_POPF + "popfd", // X86_INS_POPFD + "popfq", // X86_INS_POPFQ + "prefetch", // X86_INS_PREFETCH + "prefetchnta", // X86_INS_PREFETCHNTA + "prefetcht0", // X86_INS_PREFETCHT0 + "prefetcht1", // X86_INS_PREFETCHT1 + "prefetcht2", // X86_INS_PREFETCHT2 + "prefetchw", // X86_INS_PREFETCHW + "prefetchwt1", // X86_INS_PREFETCHWT1 + "pshufd", // X86_INS_PSHUFD + "pshufhw", // X86_INS_PSHUFHW + "pshuflw", // X86_INS_PSHUFLW + "pslldq", // X86_INS_PSLLDQ + "psrldq", // X86_INS_PSRLDQ + "pswapd", // X86_INS_PSWAPD + "ptest", // X86_INS_PTEST + "ptwrite", // X86_INS_PTWRITE + "punpckhqdq", // X86_INS_PUNPCKHQDQ + "punpcklqdq", // X86_INS_PUNPCKLQDQ + "push", // X86_INS_PUSH + "pushaw", // X86_INS_PUSHAW + "pushal", // X86_INS_PUSHAL + "pushf", // X86_INS_PUSHF + "pushfd", // X86_INS_PUSHFD + "pushfq", // X86_INS_PUSHFQ + "rcl", // X86_INS_RCL + "rcpps", // X86_INS_RCPPS + "rcpss", // X86_INS_RCPSS + "rcr", // X86_INS_RCR + "rdfsbase", // X86_INS_RDFSBASE + "rdgsbase", // X86_INS_RDGSBASE + "rdmsr", // X86_INS_RDMSR + "rdpid", // X86_INS_RDPID + "rdpkru", // X86_INS_RDPKRU + "rdpmc", // X86_INS_RDPMC + "rdrand", // X86_INS_RDRAND + "rdseed", // X86_INS_RDSEED + "rdsspd", // X86_INS_RDSSPD + "rdsspq", // X86_INS_RDSSPQ + "rdtsc", // X86_INS_RDTSC + "rdtscp", // X86_INS_RDTSCP + "repne", // X86_INS_REPNE + "rep", // X86_INS_REP + "ret", // X86_INS_RET + "rex64", // X86_INS_REX64 + "rol", // X86_INS_ROL + "ror", // X86_INS_ROR + "rorx", // X86_INS_RORX + "roundpd", // X86_INS_ROUNDPD + "roundps", // X86_INS_ROUNDPS + "roundsd", // X86_INS_ROUNDSD + "roundss", // X86_INS_ROUNDSS + "rsm", // X86_INS_RSM + "rsqrtps", // X86_INS_RSQRTPS + "rsqrtss", // X86_INS_RSQRTSS + "rstorssp", // X86_INS_RSTORSSP + "sahf", // X86_INS_SAHF + "sal", // X86_INS_SAL + "salc", // X86_INS_SALC + "sar", // X86_INS_SAR + "sarx", // X86_INS_SARX + "saveprevssp", // X86_INS_SAVEPREVSSP + "sbb", // X86_INS_SBB + "scasb", // X86_INS_SCASB + "scasd", // X86_INS_SCASD + "scasq", // X86_INS_SCASQ + "scasw", // X86_INS_SCASW + "setae", // X86_INS_SETAE + "seta", // X86_INS_SETA + "setbe", // X86_INS_SETBE + "setb", // X86_INS_SETB + "sete", // X86_INS_SETE + "setge", // X86_INS_SETGE + "setg", // X86_INS_SETG + "setle", // X86_INS_SETLE + "setl", // X86_INS_SETL + "setne", // X86_INS_SETNE + "setno", // X86_INS_SETNO + "setnp", // X86_INS_SETNP + "setns", // X86_INS_SETNS + "seto", // X86_INS_SETO + "setp", // X86_INS_SETP + "setssbsy", // X86_INS_SETSSBSY + "sets", // X86_INS_SETS + "sfence", // X86_INS_SFENCE + "sgdt", // X86_INS_SGDT + "sha1msg1", // X86_INS_SHA1MSG1 + "sha1msg2", // X86_INS_SHA1MSG2 + "sha1nexte", // X86_INS_SHA1NEXTE + "sha1rnds4", // X86_INS_SHA1RNDS4 + "sha256msg1", // X86_INS_SHA256MSG1 + "sha256msg2", // X86_INS_SHA256MSG2 + "sha256rnds2", // X86_INS_SHA256RNDS2 + "shl", // X86_INS_SHL + "shld", // X86_INS_SHLD + "shlx", // X86_INS_SHLX + "shr", // X86_INS_SHR + "shrd", // X86_INS_SHRD + "shrx", // X86_INS_SHRX + "shufpd", // X86_INS_SHUFPD + "shufps", // X86_INS_SHUFPS + "sidt", // X86_INS_SIDT + "fsin", // X86_INS_FSIN + "skinit", // X86_INS_SKINIT + "sldt", // X86_INS_SLDT + "slwpcb", // X86_INS_SLWPCB + "smsw", // X86_INS_SMSW + "sqrtpd", // X86_INS_SQRTPD + "sqrtps", // X86_INS_SQRTPS + "sqrtsd", // X86_INS_SQRTSD + "sqrtss", // X86_INS_SQRTSS + "fsqrt", // X86_INS_FSQRT + "stac", // X86_INS_STAC + "stc", // X86_INS_STC + "std", // X86_INS_STD + "stgi", // X86_INS_STGI + "sti", // X86_INS_STI + "stmxcsr", // X86_INS_STMXCSR + "stosb", // X86_INS_STOSB + "stosd", // X86_INS_STOSD + "stosq", // X86_INS_STOSQ + "stosw", // X86_INS_STOSW + "str", // X86_INS_STR + "fst", // X86_INS_FST + "fstp", // X86_INS_FSTP + "sub", // X86_INS_SUB + "subpd", // X86_INS_SUBPD + "subps", // X86_INS_SUBPS + "fsubr", // X86_INS_FSUBR + "fisubr", // X86_INS_FISUBR + "fsubrp", // X86_INS_FSUBRP + "subsd", // X86_INS_SUBSD + "subss", // X86_INS_SUBSS + "fsub", // X86_INS_FSUB + "fisub", // X86_INS_FISUB + "fsubp", // X86_INS_FSUBP + "swapgs", // X86_INS_SWAPGS + "syscall", // X86_INS_SYSCALL + "sysenter", // X86_INS_SYSENTER + "sysexit", // X86_INS_SYSEXIT + "sysexitq", // X86_INS_SYSEXITQ + "sysret", // X86_INS_SYSRET + "sysretq", // X86_INS_SYSRETQ + "t1mskc", // X86_INS_T1MSKC + "test", // X86_INS_TEST + "tpause", // X86_INS_TPAUSE + "ftst", // X86_INS_FTST + "tzcnt", // X86_INS_TZCNT + "tzmsk", // X86_INS_TZMSK + "ucomisd", // X86_INS_UCOMISD + "ucomiss", // X86_INS_UCOMISS + "fucompi", // X86_INS_FUCOMPI + "fucomi", // X86_INS_FUCOMI + "fucompp", // X86_INS_FUCOMPP + "fucomp", // X86_INS_FUCOMP + "fucom", // X86_INS_FUCOM + "ud0", // X86_INS_UD0 + "ud1", // X86_INS_UD1 + "ud2", // X86_INS_UD2 + "umonitor", // X86_INS_UMONITOR + "umwait", // X86_INS_UMWAIT + "unpckhpd", // X86_INS_UNPCKHPD + "unpckhps", // X86_INS_UNPCKHPS + "unpcklpd", // X86_INS_UNPCKLPD + "unpcklps", // X86_INS_UNPCKLPS + "v4fmaddps", // X86_INS_V4FMADDPS + "v4fmaddss", // X86_INS_V4FMADDSS + "v4fnmaddps", // X86_INS_V4FNMADDPS + "v4fnmaddss", // X86_INS_V4FNMADDSS + "vaddpd", // X86_INS_VADDPD + "vaddps", // X86_INS_VADDPS + "vaddsd", // X86_INS_VADDSD + "vaddss", // X86_INS_VADDSS + "vaddsubpd", // X86_INS_VADDSUBPD + "vaddsubps", // X86_INS_VADDSUBPS + "vaesdeclast", // X86_INS_VAESDECLAST + "vaesdec", // X86_INS_VAESDEC + "vaesenclast", // X86_INS_VAESENCLAST + "vaesenc", // X86_INS_VAESENC + "vaesimc", // X86_INS_VAESIMC + "vaeskeygenassist", // X86_INS_VAESKEYGENASSIST + "valignd", // X86_INS_VALIGND + "valignq", // X86_INS_VALIGNQ + "vandnpd", // X86_INS_VANDNPD + "vandnps", // X86_INS_VANDNPS + "vandpd", // X86_INS_VANDPD + "vandps", // X86_INS_VANDPS + "vblendmpd", // X86_INS_VBLENDMPD + "vblendmps", // X86_INS_VBLENDMPS + "vblendpd", // X86_INS_VBLENDPD + "vblendps", // X86_INS_VBLENDPS + "vblendvpd", // X86_INS_VBLENDVPD + "vblendvps", // X86_INS_VBLENDVPS + "vbroadcastf128", // X86_INS_VBROADCASTF128 + "vbroadcastf32x2", // X86_INS_VBROADCASTF32X2 + "vbroadcastf32x4", // X86_INS_VBROADCASTF32X4 + "vbroadcastf32x8", // X86_INS_VBROADCASTF32X8 + "vbroadcastf64x2", // X86_INS_VBROADCASTF64X2 + "vbroadcastf64x4", // X86_INS_VBROADCASTF64X4 + "vbroadcasti128", // X86_INS_VBROADCASTI128 + "vbroadcasti32x2", // X86_INS_VBROADCASTI32X2 + "vbroadcasti32x4", // X86_INS_VBROADCASTI32X4 + "vbroadcasti32x8", // X86_INS_VBROADCASTI32X8 + "vbroadcasti64x2", // X86_INS_VBROADCASTI64X2 + "vbroadcasti64x4", // X86_INS_VBROADCASTI64X4 + "vbroadcastsd", // X86_INS_VBROADCASTSD + "vbroadcastss", // X86_INS_VBROADCASTSS + "vcmp", // X86_INS_VCMP + "vcmppd", // X86_INS_VCMPPD + "vcmpps", // X86_INS_VCMPPS + "vcmpsd", // X86_INS_VCMPSD + "vcmpss", // X86_INS_VCMPSS + "vcomisd", // X86_INS_VCOMISD + "vcomiss", // X86_INS_VCOMISS + "vcompresspd", // X86_INS_VCOMPRESSPD + "vcompressps", // X86_INS_VCOMPRESSPS + "vcvtdq2pd", // X86_INS_VCVTDQ2PD + "vcvtdq2ps", // X86_INS_VCVTDQ2PS + "vcvtpd2dq", // X86_INS_VCVTPD2DQ + "vcvtpd2ps", // X86_INS_VCVTPD2PS + "vcvtpd2qq", // X86_INS_VCVTPD2QQ + "vcvtpd2udq", // X86_INS_VCVTPD2UDQ + "vcvtpd2uqq", // X86_INS_VCVTPD2UQQ + "vcvtph2ps", // X86_INS_VCVTPH2PS + "vcvtps2dq", // X86_INS_VCVTPS2DQ + "vcvtps2pd", // X86_INS_VCVTPS2PD + "vcvtps2ph", // X86_INS_VCVTPS2PH + "vcvtps2qq", // X86_INS_VCVTPS2QQ + "vcvtps2udq", // X86_INS_VCVTPS2UDQ + "vcvtps2uqq", // X86_INS_VCVTPS2UQQ + "vcvtqq2pd", // X86_INS_VCVTQQ2PD + "vcvtqq2ps", // X86_INS_VCVTQQ2PS + "vcvtsd2si", // X86_INS_VCVTSD2SI + "vcvtsd2ss", // X86_INS_VCVTSD2SS + "vcvtsd2usi", // X86_INS_VCVTSD2USI + "vcvtsi2sd", // X86_INS_VCVTSI2SD + "vcvtsi2ss", // X86_INS_VCVTSI2SS + "vcvtss2sd", // X86_INS_VCVTSS2SD + "vcvtss2si", // X86_INS_VCVTSS2SI + "vcvtss2usi", // X86_INS_VCVTSS2USI + "vcvttpd2dq", // X86_INS_VCVTTPD2DQ + "vcvttpd2qq", // X86_INS_VCVTTPD2QQ + "vcvttpd2udq", // X86_INS_VCVTTPD2UDQ + "vcvttpd2uqq", // X86_INS_VCVTTPD2UQQ + "vcvttps2dq", // X86_INS_VCVTTPS2DQ + "vcvttps2qq", // X86_INS_VCVTTPS2QQ + "vcvttps2udq", // X86_INS_VCVTTPS2UDQ + "vcvttps2uqq", // X86_INS_VCVTTPS2UQQ + "vcvttsd2si", // X86_INS_VCVTTSD2SI + "vcvttsd2usi", // X86_INS_VCVTTSD2USI + "vcvttss2si", // X86_INS_VCVTTSS2SI + "vcvttss2usi", // X86_INS_VCVTTSS2USI + "vcvtudq2pd", // X86_INS_VCVTUDQ2PD + "vcvtudq2ps", // X86_INS_VCVTUDQ2PS + "vcvtuqq2pd", // X86_INS_VCVTUQQ2PD + "vcvtuqq2ps", // X86_INS_VCVTUQQ2PS + "vcvtusi2sd", // X86_INS_VCVTUSI2SD + "vcvtusi2ss", // X86_INS_VCVTUSI2SS + "vdbpsadbw", // X86_INS_VDBPSADBW + "vdivpd", // X86_INS_VDIVPD + "vdivps", // X86_INS_VDIVPS + "vdivsd", // X86_INS_VDIVSD + "vdivss", // X86_INS_VDIVSS + "vdppd", // X86_INS_VDPPD + "vdpps", // X86_INS_VDPPS + "verr", // X86_INS_VERR + "verw", // X86_INS_VERW + "vexp2pd", // X86_INS_VEXP2PD + "vexp2ps", // X86_INS_VEXP2PS + "vexpandpd", // X86_INS_VEXPANDPD + "vexpandps", // X86_INS_VEXPANDPS + "vextractf128", // X86_INS_VEXTRACTF128 + "vextractf32x4", // X86_INS_VEXTRACTF32X4 + "vextractf32x8", // X86_INS_VEXTRACTF32X8 + "vextractf64x2", // X86_INS_VEXTRACTF64X2 + "vextractf64x4", // X86_INS_VEXTRACTF64X4 + "vextracti128", // X86_INS_VEXTRACTI128 + "vextracti32x4", // X86_INS_VEXTRACTI32X4 + "vextracti32x8", // X86_INS_VEXTRACTI32X8 + "vextracti64x2", // X86_INS_VEXTRACTI64X2 + "vextracti64x4", // X86_INS_VEXTRACTI64X4 + "vextractps", // X86_INS_VEXTRACTPS + "vfixupimmpd", // X86_INS_VFIXUPIMMPD + "vfixupimmps", // X86_INS_VFIXUPIMMPS + "vfixupimmsd", // X86_INS_VFIXUPIMMSD + "vfixupimmss", // X86_INS_VFIXUPIMMSS + "vfmadd132pd", // X86_INS_VFMADD132PD + "vfmadd132ps", // X86_INS_VFMADD132PS + "vfmadd132sd", // X86_INS_VFMADD132SD + "vfmadd132ss", // X86_INS_VFMADD132SS + "vfmadd213pd", // X86_INS_VFMADD213PD + "vfmadd213ps", // X86_INS_VFMADD213PS + "vfmadd213sd", // X86_INS_VFMADD213SD + "vfmadd213ss", // X86_INS_VFMADD213SS + "vfmadd231pd", // X86_INS_VFMADD231PD + "vfmadd231ps", // X86_INS_VFMADD231PS + "vfmadd231sd", // X86_INS_VFMADD231SD + "vfmadd231ss", // X86_INS_VFMADD231SS + "vfmaddpd", // X86_INS_VFMADDPD + "vfmaddps", // X86_INS_VFMADDPS + "vfmaddsd", // X86_INS_VFMADDSD + "vfmaddss", // X86_INS_VFMADDSS + "vfmaddsub132pd", // X86_INS_VFMADDSUB132PD + "vfmaddsub132ps", // X86_INS_VFMADDSUB132PS + "vfmaddsub213pd", // X86_INS_VFMADDSUB213PD + "vfmaddsub213ps", // X86_INS_VFMADDSUB213PS + "vfmaddsub231pd", // X86_INS_VFMADDSUB231PD + "vfmaddsub231ps", // X86_INS_VFMADDSUB231PS + "vfmaddsubpd", // X86_INS_VFMADDSUBPD + "vfmaddsubps", // X86_INS_VFMADDSUBPS + "vfmsub132pd", // X86_INS_VFMSUB132PD + "vfmsub132ps", // X86_INS_VFMSUB132PS + "vfmsub132sd", // X86_INS_VFMSUB132SD + "vfmsub132ss", // X86_INS_VFMSUB132SS + "vfmsub213pd", // X86_INS_VFMSUB213PD + "vfmsub213ps", // X86_INS_VFMSUB213PS + "vfmsub213sd", // X86_INS_VFMSUB213SD + "vfmsub213ss", // X86_INS_VFMSUB213SS + "vfmsub231pd", // X86_INS_VFMSUB231PD + "vfmsub231ps", // X86_INS_VFMSUB231PS + "vfmsub231sd", // X86_INS_VFMSUB231SD + "vfmsub231ss", // X86_INS_VFMSUB231SS + "vfmsubadd132pd", // X86_INS_VFMSUBADD132PD + "vfmsubadd132ps", // X86_INS_VFMSUBADD132PS + "vfmsubadd213pd", // X86_INS_VFMSUBADD213PD + "vfmsubadd213ps", // X86_INS_VFMSUBADD213PS + "vfmsubadd231pd", // X86_INS_VFMSUBADD231PD + "vfmsubadd231ps", // X86_INS_VFMSUBADD231PS + "vfmsubaddpd", // X86_INS_VFMSUBADDPD + "vfmsubaddps", // X86_INS_VFMSUBADDPS + "vfmsubpd", // X86_INS_VFMSUBPD + "vfmsubps", // X86_INS_VFMSUBPS + "vfmsubsd", // X86_INS_VFMSUBSD + "vfmsubss", // X86_INS_VFMSUBSS + "vfnmadd132pd", // X86_INS_VFNMADD132PD + "vfnmadd132ps", // X86_INS_VFNMADD132PS + "vfnmadd132sd", // X86_INS_VFNMADD132SD + "vfnmadd132ss", // X86_INS_VFNMADD132SS + "vfnmadd213pd", // X86_INS_VFNMADD213PD + "vfnmadd213ps", // X86_INS_VFNMADD213PS + "vfnmadd213sd", // X86_INS_VFNMADD213SD + "vfnmadd213ss", // X86_INS_VFNMADD213SS + "vfnmadd231pd", // X86_INS_VFNMADD231PD + "vfnmadd231ps", // X86_INS_VFNMADD231PS + "vfnmadd231sd", // X86_INS_VFNMADD231SD + "vfnmadd231ss", // X86_INS_VFNMADD231SS + "vfnmaddpd", // X86_INS_VFNMADDPD + "vfnmaddps", // X86_INS_VFNMADDPS + "vfnmaddsd", // X86_INS_VFNMADDSD + "vfnmaddss", // X86_INS_VFNMADDSS + "vfnmsub132pd", // X86_INS_VFNMSUB132PD + "vfnmsub132ps", // X86_INS_VFNMSUB132PS + "vfnmsub132sd", // X86_INS_VFNMSUB132SD + "vfnmsub132ss", // X86_INS_VFNMSUB132SS + "vfnmsub213pd", // X86_INS_VFNMSUB213PD + "vfnmsub213ps", // X86_INS_VFNMSUB213PS + "vfnmsub213sd", // X86_INS_VFNMSUB213SD + "vfnmsub213ss", // X86_INS_VFNMSUB213SS + "vfnmsub231pd", // X86_INS_VFNMSUB231PD + "vfnmsub231ps", // X86_INS_VFNMSUB231PS + "vfnmsub231sd", // X86_INS_VFNMSUB231SD + "vfnmsub231ss", // X86_INS_VFNMSUB231SS + "vfnmsubpd", // X86_INS_VFNMSUBPD + "vfnmsubps", // X86_INS_VFNMSUBPS + "vfnmsubsd", // X86_INS_VFNMSUBSD + "vfnmsubss", // X86_INS_VFNMSUBSS + "vfpclasspd", // X86_INS_VFPCLASSPD + "vfpclassps", // X86_INS_VFPCLASSPS + "vfpclasssd", // X86_INS_VFPCLASSSD + "vfpclassss", // X86_INS_VFPCLASSSS + "vfrczpd", // X86_INS_VFRCZPD + "vfrczps", // X86_INS_VFRCZPS + "vfrczsd", // X86_INS_VFRCZSD + "vfrczss", // X86_INS_VFRCZSS + "vgatherdpd", // X86_INS_VGATHERDPD + "vgatherdps", // X86_INS_VGATHERDPS + "vgatherpf0dpd", // X86_INS_VGATHERPF0DPD + "vgatherpf0dps", // X86_INS_VGATHERPF0DPS + "vgatherpf0qpd", // X86_INS_VGATHERPF0QPD + "vgatherpf0qps", // X86_INS_VGATHERPF0QPS + "vgatherpf1dpd", // X86_INS_VGATHERPF1DPD + "vgatherpf1dps", // X86_INS_VGATHERPF1DPS + "vgatherpf1qpd", // X86_INS_VGATHERPF1QPD + "vgatherpf1qps", // X86_INS_VGATHERPF1QPS + "vgatherqpd", // X86_INS_VGATHERQPD + "vgatherqps", // X86_INS_VGATHERQPS + "vgetexppd", // X86_INS_VGETEXPPD + "vgetexpps", // X86_INS_VGETEXPPS + "vgetexpsd", // X86_INS_VGETEXPSD + "vgetexpss", // X86_INS_VGETEXPSS + "vgetmantpd", // X86_INS_VGETMANTPD + "vgetmantps", // X86_INS_VGETMANTPS + "vgetmantsd", // X86_INS_VGETMANTSD + "vgetmantss", // X86_INS_VGETMANTSS + "vgf2p8affineinvqb", // X86_INS_VGF2P8AFFINEINVQB + "vgf2p8affineqb", // X86_INS_VGF2P8AFFINEQB + "vgf2p8mulb", // X86_INS_VGF2P8MULB + "vhaddpd", // X86_INS_VHADDPD + "vhaddps", // X86_INS_VHADDPS + "vhsubpd", // X86_INS_VHSUBPD + "vhsubps", // X86_INS_VHSUBPS + "vinsertf128", // X86_INS_VINSERTF128 + "vinsertf32x4", // X86_INS_VINSERTF32X4 + "vinsertf32x8", // X86_INS_VINSERTF32X8 + "vinsertf64x2", // X86_INS_VINSERTF64X2 + "vinsertf64x4", // X86_INS_VINSERTF64X4 + "vinserti128", // X86_INS_VINSERTI128 + "vinserti32x4", // X86_INS_VINSERTI32X4 + "vinserti32x8", // X86_INS_VINSERTI32X8 + "vinserti64x2", // X86_INS_VINSERTI64X2 + "vinserti64x4", // X86_INS_VINSERTI64X4 + "vinsertps", // X86_INS_VINSERTPS + "vlddqu", // X86_INS_VLDDQU + "vldmxcsr", // X86_INS_VLDMXCSR + "vmaskmovdqu", // X86_INS_VMASKMOVDQU + "vmaskmovpd", // X86_INS_VMASKMOVPD + "vmaskmovps", // X86_INS_VMASKMOVPS + "vmaxpd", // X86_INS_VMAXPD + "vmaxps", // X86_INS_VMAXPS + "vmaxsd", // X86_INS_VMAXSD + "vmaxss", // X86_INS_VMAXSS + "vmcall", // X86_INS_VMCALL + "vmclear", // X86_INS_VMCLEAR + "vmfunc", // X86_INS_VMFUNC + "vminpd", // X86_INS_VMINPD + "vminps", // X86_INS_VMINPS + "vminsd", // X86_INS_VMINSD + "vminss", // X86_INS_VMINSS + "vmlaunch", // X86_INS_VMLAUNCH + "vmload", // X86_INS_VMLOAD + "vmmcall", // X86_INS_VMMCALL + "vmovq", // X86_INS_VMOVQ + "vmovapd", // X86_INS_VMOVAPD + "vmovaps", // X86_INS_VMOVAPS + "vmovddup", // X86_INS_VMOVDDUP + "vmovd", // X86_INS_VMOVD + "vmovdqa32", // X86_INS_VMOVDQA32 + "vmovdqa64", // X86_INS_VMOVDQA64 + "vmovdqa", // X86_INS_VMOVDQA + "vmovdqu16", // X86_INS_VMOVDQU16 + "vmovdqu32", // X86_INS_VMOVDQU32 + "vmovdqu64", // X86_INS_VMOVDQU64 + "vmovdqu8", // X86_INS_VMOVDQU8 + "vmovdqu", // X86_INS_VMOVDQU + "vmovhlps", // X86_INS_VMOVHLPS + "vmovhpd", // X86_INS_VMOVHPD + "vmovhps", // X86_INS_VMOVHPS + "vmovlhps", // X86_INS_VMOVLHPS + "vmovlpd", // X86_INS_VMOVLPD + "vmovlps", // X86_INS_VMOVLPS + "vmovmskpd", // X86_INS_VMOVMSKPD + "vmovmskps", // X86_INS_VMOVMSKPS + "vmovntdqa", // X86_INS_VMOVNTDQA + "vmovntdq", // X86_INS_VMOVNTDQ + "vmovntpd", // X86_INS_VMOVNTPD + "vmovntps", // X86_INS_VMOVNTPS + "vmovsd", // X86_INS_VMOVSD + "vmovshdup", // X86_INS_VMOVSHDUP + "vmovsldup", // X86_INS_VMOVSLDUP + "vmovss", // X86_INS_VMOVSS + "vmovupd", // X86_INS_VMOVUPD + "vmovups", // X86_INS_VMOVUPS + "vmpsadbw", // X86_INS_VMPSADBW + "vmptrld", // X86_INS_VMPTRLD + "vmptrst", // X86_INS_VMPTRST + "vmread", // X86_INS_VMREAD + "vmresume", // X86_INS_VMRESUME + "vmrun", // X86_INS_VMRUN + "vmsave", // X86_INS_VMSAVE + "vmulpd", // X86_INS_VMULPD + "vmulps", // X86_INS_VMULPS + "vmulsd", // X86_INS_VMULSD + "vmulss", // X86_INS_VMULSS + "vmwrite", // X86_INS_VMWRITE + "vmxoff", // X86_INS_VMXOFF + "vmxon", // X86_INS_VMXON + "vorpd", // X86_INS_VORPD + "vorps", // X86_INS_VORPS + "vp4dpwssds", // X86_INS_VP4DPWSSDS + "vp4dpwssd", // X86_INS_VP4DPWSSD + "vpabsb", // X86_INS_VPABSB + "vpabsd", // X86_INS_VPABSD + "vpabsq", // X86_INS_VPABSQ + "vpabsw", // X86_INS_VPABSW + "vpackssdw", // X86_INS_VPACKSSDW + "vpacksswb", // X86_INS_VPACKSSWB + "vpackusdw", // X86_INS_VPACKUSDW + "vpackuswb", // X86_INS_VPACKUSWB + "vpaddb", // X86_INS_VPADDB + "vpaddd", // X86_INS_VPADDD + "vpaddq", // X86_INS_VPADDQ + "vpaddsb", // X86_INS_VPADDSB + "vpaddsw", // X86_INS_VPADDSW + "vpaddusb", // X86_INS_VPADDUSB + "vpaddusw", // X86_INS_VPADDUSW + "vpaddw", // X86_INS_VPADDW + "vpalignr", // X86_INS_VPALIGNR + "vpandd", // X86_INS_VPANDD + "vpandnd", // X86_INS_VPANDND + "vpandnq", // X86_INS_VPANDNQ + "vpandn", // X86_INS_VPANDN + "vpandq", // X86_INS_VPANDQ + "vpand", // X86_INS_VPAND + "vpavgb", // X86_INS_VPAVGB + "vpavgw", // X86_INS_VPAVGW + "vpblendd", // X86_INS_VPBLENDD + "vpblendmb", // X86_INS_VPBLENDMB + "vpblendmd", // X86_INS_VPBLENDMD + "vpblendmq", // X86_INS_VPBLENDMQ + "vpblendmw", // X86_INS_VPBLENDMW + "vpblendvb", // X86_INS_VPBLENDVB + "vpblendw", // X86_INS_VPBLENDW + "vpbroadcastb", // X86_INS_VPBROADCASTB + "vpbroadcastd", // X86_INS_VPBROADCASTD + "vpbroadcastmb2q", // X86_INS_VPBROADCASTMB2Q + "vpbroadcastmw2d", // X86_INS_VPBROADCASTMW2D + "vpbroadcastq", // X86_INS_VPBROADCASTQ + "vpbroadcastw", // X86_INS_VPBROADCASTW + "vpclmulqdq", // X86_INS_VPCLMULQDQ + "vpcmov", // X86_INS_VPCMOV + "vpcmp", // X86_INS_VPCMP + "vpcmpb", // X86_INS_VPCMPB + "vpcmpd", // X86_INS_VPCMPD + "vpcmpeqb", // X86_INS_VPCMPEQB + "vpcmpeqd", // X86_INS_VPCMPEQD + "vpcmpeqq", // X86_INS_VPCMPEQQ + "vpcmpeqw", // X86_INS_VPCMPEQW + "vpcmpestri", // X86_INS_VPCMPESTRI + "vpcmpestrm", // X86_INS_VPCMPESTRM + "vpcmpgtb", // X86_INS_VPCMPGTB + "vpcmpgtd", // X86_INS_VPCMPGTD + "vpcmpgtq", // X86_INS_VPCMPGTQ + "vpcmpgtw", // X86_INS_VPCMPGTW + "vpcmpistri", // X86_INS_VPCMPISTRI + "vpcmpistrm", // X86_INS_VPCMPISTRM + "vpcmpq", // X86_INS_VPCMPQ + "vpcmpub", // X86_INS_VPCMPUB + "vpcmpud", // X86_INS_VPCMPUD + "vpcmpuq", // X86_INS_VPCMPUQ + "vpcmpuw", // X86_INS_VPCMPUW + "vpcmpw", // X86_INS_VPCMPW + "vpcom", // X86_INS_VPCOM + "vpcomb", // X86_INS_VPCOMB + "vpcomd", // X86_INS_VPCOMD + "vpcompressb", // X86_INS_VPCOMPRESSB + "vpcompressd", // X86_INS_VPCOMPRESSD + "vpcompressq", // X86_INS_VPCOMPRESSQ + "vpcompressw", // X86_INS_VPCOMPRESSW + "vpcomq", // X86_INS_VPCOMQ + "vpcomub", // X86_INS_VPCOMUB + "vpcomud", // X86_INS_VPCOMUD + "vpcomuq", // X86_INS_VPCOMUQ + "vpcomuw", // X86_INS_VPCOMUW + "vpcomw", // X86_INS_VPCOMW + "vpconflictd", // X86_INS_VPCONFLICTD + "vpconflictq", // X86_INS_VPCONFLICTQ + "vpdpbusds", // X86_INS_VPDPBUSDS + "vpdpbusd", // X86_INS_VPDPBUSD + "vpdpwssds", // X86_INS_VPDPWSSDS + "vpdpwssd", // X86_INS_VPDPWSSD + "vperm2f128", // X86_INS_VPERM2F128 + "vperm2i128", // X86_INS_VPERM2I128 + "vpermb", // X86_INS_VPERMB + "vpermd", // X86_INS_VPERMD + "vpermi2b", // X86_INS_VPERMI2B + "vpermi2d", // X86_INS_VPERMI2D + "vpermi2pd", // X86_INS_VPERMI2PD + "vpermi2ps", // X86_INS_VPERMI2PS + "vpermi2q", // X86_INS_VPERMI2Q + "vpermi2w", // X86_INS_VPERMI2W + "vpermil2pd", // X86_INS_VPERMIL2PD + "vpermilpd", // X86_INS_VPERMILPD + "vpermil2ps", // X86_INS_VPERMIL2PS + "vpermilps", // X86_INS_VPERMILPS + "vpermpd", // X86_INS_VPERMPD + "vpermps", // X86_INS_VPERMPS + "vpermq", // X86_INS_VPERMQ + "vpermt2b", // X86_INS_VPERMT2B + "vpermt2d", // X86_INS_VPERMT2D + "vpermt2pd", // X86_INS_VPERMT2PD + "vpermt2ps", // X86_INS_VPERMT2PS + "vpermt2q", // X86_INS_VPERMT2Q + "vpermt2w", // X86_INS_VPERMT2W + "vpermw", // X86_INS_VPERMW + "vpexpandb", // X86_INS_VPEXPANDB + "vpexpandd", // X86_INS_VPEXPANDD + "vpexpandq", // X86_INS_VPEXPANDQ + "vpexpandw", // X86_INS_VPEXPANDW + "vpextrb", // X86_INS_VPEXTRB + "vpextrd", // X86_INS_VPEXTRD + "vpextrq", // X86_INS_VPEXTRQ + "vpextrw", // X86_INS_VPEXTRW + "vpgatherdd", // X86_INS_VPGATHERDD + "vpgatherdq", // X86_INS_VPGATHERDQ + "vpgatherqd", // X86_INS_VPGATHERQD + "vpgatherqq", // X86_INS_VPGATHERQQ + "vphaddbd", // X86_INS_VPHADDBD + "vphaddbq", // X86_INS_VPHADDBQ + "vphaddbw", // X86_INS_VPHADDBW + "vphadddq", // X86_INS_VPHADDDQ + "vphaddd", // X86_INS_VPHADDD + "vphaddsw", // X86_INS_VPHADDSW + "vphaddubd", // X86_INS_VPHADDUBD + "vphaddubq", // X86_INS_VPHADDUBQ + "vphaddubw", // X86_INS_VPHADDUBW + "vphaddudq", // X86_INS_VPHADDUDQ + "vphadduwd", // X86_INS_VPHADDUWD + "vphadduwq", // X86_INS_VPHADDUWQ + "vphaddwd", // X86_INS_VPHADDWD + "vphaddwq", // X86_INS_VPHADDWQ + "vphaddw", // X86_INS_VPHADDW + "vphminposuw", // X86_INS_VPHMINPOSUW + "vphsubbw", // X86_INS_VPHSUBBW + "vphsubdq", // X86_INS_VPHSUBDQ + "vphsubd", // X86_INS_VPHSUBD + "vphsubsw", // X86_INS_VPHSUBSW + "vphsubwd", // X86_INS_VPHSUBWD + "vphsubw", // X86_INS_VPHSUBW + "vpinsrb", // X86_INS_VPINSRB + "vpinsrd", // X86_INS_VPINSRD + "vpinsrq", // X86_INS_VPINSRQ + "vpinsrw", // X86_INS_VPINSRW + "vplzcntd", // X86_INS_VPLZCNTD + "vplzcntq", // X86_INS_VPLZCNTQ + "vpmacsdd", // X86_INS_VPMACSDD + "vpmacsdqh", // X86_INS_VPMACSDQH + "vpmacsdql", // X86_INS_VPMACSDQL + "vpmacssdd", // X86_INS_VPMACSSDD + "vpmacssdqh", // X86_INS_VPMACSSDQH + "vpmacssdql", // X86_INS_VPMACSSDQL + "vpmacsswd", // X86_INS_VPMACSSWD + "vpmacssww", // X86_INS_VPMACSSWW + "vpmacswd", // X86_INS_VPMACSWD + "vpmacsww", // X86_INS_VPMACSWW + "vpmadcsswd", // X86_INS_VPMADCSSWD + "vpmadcswd", // X86_INS_VPMADCSWD + "vpmadd52huq", // X86_INS_VPMADD52HUQ + "vpmadd52luq", // X86_INS_VPMADD52LUQ + "vpmaddubsw", // X86_INS_VPMADDUBSW + "vpmaddwd", // X86_INS_VPMADDWD + "vpmaskmovd", // X86_INS_VPMASKMOVD + "vpmaskmovq", // X86_INS_VPMASKMOVQ + "vpmaxsb", // X86_INS_VPMAXSB + "vpmaxsd", // X86_INS_VPMAXSD + "vpmaxsq", // X86_INS_VPMAXSQ + "vpmaxsw", // X86_INS_VPMAXSW + "vpmaxub", // X86_INS_VPMAXUB + "vpmaxud", // X86_INS_VPMAXUD + "vpmaxuq", // X86_INS_VPMAXUQ + "vpmaxuw", // X86_INS_VPMAXUW + "vpminsb", // X86_INS_VPMINSB + "vpminsd", // X86_INS_VPMINSD + "vpminsq", // X86_INS_VPMINSQ + "vpminsw", // X86_INS_VPMINSW + "vpminub", // X86_INS_VPMINUB + "vpminud", // X86_INS_VPMINUD + "vpminuq", // X86_INS_VPMINUQ + "vpminuw", // X86_INS_VPMINUW + "vpmovb2m", // X86_INS_VPMOVB2M + "vpmovd2m", // X86_INS_VPMOVD2M + "vpmovdb", // X86_INS_VPMOVDB + "vpmovdw", // X86_INS_VPMOVDW + "vpmovm2b", // X86_INS_VPMOVM2B + "vpmovm2d", // X86_INS_VPMOVM2D + "vpmovm2q", // X86_INS_VPMOVM2Q + "vpmovm2w", // X86_INS_VPMOVM2W + "vpmovmskb", // X86_INS_VPMOVMSKB + "vpmovq2m", // X86_INS_VPMOVQ2M + "vpmovqb", // X86_INS_VPMOVQB + "vpmovqd", // X86_INS_VPMOVQD + "vpmovqw", // X86_INS_VPMOVQW + "vpmovsdb", // X86_INS_VPMOVSDB + "vpmovsdw", // X86_INS_VPMOVSDW + "vpmovsqb", // X86_INS_VPMOVSQB + "vpmovsqd", // X86_INS_VPMOVSQD + "vpmovsqw", // X86_INS_VPMOVSQW + "vpmovswb", // X86_INS_VPMOVSWB + "vpmovsxbd", // X86_INS_VPMOVSXBD + "vpmovsxbq", // X86_INS_VPMOVSXBQ + "vpmovsxbw", // X86_INS_VPMOVSXBW + "vpmovsxdq", // X86_INS_VPMOVSXDQ + "vpmovsxwd", // X86_INS_VPMOVSXWD + "vpmovsxwq", // X86_INS_VPMOVSXWQ + "vpmovusdb", // X86_INS_VPMOVUSDB + "vpmovusdw", // X86_INS_VPMOVUSDW + "vpmovusqb", // X86_INS_VPMOVUSQB + "vpmovusqd", // X86_INS_VPMOVUSQD + "vpmovusqw", // X86_INS_VPMOVUSQW + "vpmovuswb", // X86_INS_VPMOVUSWB + "vpmovw2m", // X86_INS_VPMOVW2M + "vpmovwb", // X86_INS_VPMOVWB + "vpmovzxbd", // X86_INS_VPMOVZXBD + "vpmovzxbq", // X86_INS_VPMOVZXBQ + "vpmovzxbw", // X86_INS_VPMOVZXBW + "vpmovzxdq", // X86_INS_VPMOVZXDQ + "vpmovzxwd", // X86_INS_VPMOVZXWD + "vpmovzxwq", // X86_INS_VPMOVZXWQ + "vpmuldq", // X86_INS_VPMULDQ + "vpmulhrsw", // X86_INS_VPMULHRSW + "vpmulhuw", // X86_INS_VPMULHUW + "vpmulhw", // X86_INS_VPMULHW + "vpmulld", // X86_INS_VPMULLD + "vpmullq", // X86_INS_VPMULLQ + "vpmullw", // X86_INS_VPMULLW + "vpmultishiftqb", // X86_INS_VPMULTISHIFTQB + "vpmuludq", // X86_INS_VPMULUDQ + "vpopcntb", // X86_INS_VPOPCNTB + "vpopcntd", // X86_INS_VPOPCNTD + "vpopcntq", // X86_INS_VPOPCNTQ + "vpopcntw", // X86_INS_VPOPCNTW + "vpord", // X86_INS_VPORD + "vporq", // X86_INS_VPORQ + "vpor", // X86_INS_VPOR + "vpperm", // X86_INS_VPPERM + "vprold", // X86_INS_VPROLD + "vprolq", // X86_INS_VPROLQ + "vprolvd", // X86_INS_VPROLVD + "vprolvq", // X86_INS_VPROLVQ + "vprord", // X86_INS_VPRORD + "vprorq", // X86_INS_VPRORQ + "vprorvd", // X86_INS_VPRORVD + "vprorvq", // X86_INS_VPRORVQ + "vprotb", // X86_INS_VPROTB + "vprotd", // X86_INS_VPROTD + "vprotq", // X86_INS_VPROTQ + "vprotw", // X86_INS_VPROTW + "vpsadbw", // X86_INS_VPSADBW + "vpscatterdd", // X86_INS_VPSCATTERDD + "vpscatterdq", // X86_INS_VPSCATTERDQ + "vpscatterqd", // X86_INS_VPSCATTERQD + "vpscatterqq", // X86_INS_VPSCATTERQQ + "vpshab", // X86_INS_VPSHAB + "vpshad", // X86_INS_VPSHAD + "vpshaq", // X86_INS_VPSHAQ + "vpshaw", // X86_INS_VPSHAW + "vpshlb", // X86_INS_VPSHLB + "vpshldd", // X86_INS_VPSHLDD + "vpshldq", // X86_INS_VPSHLDQ + "vpshldvd", // X86_INS_VPSHLDVD + "vpshldvq", // X86_INS_VPSHLDVQ + "vpshldvw", // X86_INS_VPSHLDVW + "vpshldw", // X86_INS_VPSHLDW + "vpshld", // X86_INS_VPSHLD + "vpshlq", // X86_INS_VPSHLQ + "vpshlw", // X86_INS_VPSHLW + "vpshrdd", // X86_INS_VPSHRDD + "vpshrdq", // X86_INS_VPSHRDQ + "vpshrdvd", // X86_INS_VPSHRDVD + "vpshrdvq", // X86_INS_VPSHRDVQ + "vpshrdvw", // X86_INS_VPSHRDVW + "vpshrdw", // X86_INS_VPSHRDW + "vpshufbitqmb", // X86_INS_VPSHUFBITQMB + "vpshufb", // X86_INS_VPSHUFB + "vpshufd", // X86_INS_VPSHUFD + "vpshufhw", // X86_INS_VPSHUFHW + "vpshuflw", // X86_INS_VPSHUFLW + "vpsignb", // X86_INS_VPSIGNB + "vpsignd", // X86_INS_VPSIGND + "vpsignw", // X86_INS_VPSIGNW + "vpslldq", // X86_INS_VPSLLDQ + "vpslld", // X86_INS_VPSLLD + "vpsllq", // X86_INS_VPSLLQ + "vpsllvd", // X86_INS_VPSLLVD + "vpsllvq", // X86_INS_VPSLLVQ + "vpsllvw", // X86_INS_VPSLLVW + "vpsllw", // X86_INS_VPSLLW + "vpsrad", // X86_INS_VPSRAD + "vpsraq", // X86_INS_VPSRAQ + "vpsravd", // X86_INS_VPSRAVD + "vpsravq", // X86_INS_VPSRAVQ + "vpsravw", // X86_INS_VPSRAVW + "vpsraw", // X86_INS_VPSRAW + "vpsrldq", // X86_INS_VPSRLDQ + "vpsrld", // X86_INS_VPSRLD + "vpsrlq", // X86_INS_VPSRLQ + "vpsrlvd", // X86_INS_VPSRLVD + "vpsrlvq", // X86_INS_VPSRLVQ + "vpsrlvw", // X86_INS_VPSRLVW + "vpsrlw", // X86_INS_VPSRLW + "vpsubb", // X86_INS_VPSUBB + "vpsubd", // X86_INS_VPSUBD + "vpsubq", // X86_INS_VPSUBQ + "vpsubsb", // X86_INS_VPSUBSB + "vpsubsw", // X86_INS_VPSUBSW + "vpsubusb", // X86_INS_VPSUBUSB + "vpsubusw", // X86_INS_VPSUBUSW + "vpsubw", // X86_INS_VPSUBW + "vpternlogd", // X86_INS_VPTERNLOGD + "vpternlogq", // X86_INS_VPTERNLOGQ + "vptestmb", // X86_INS_VPTESTMB + "vptestmd", // X86_INS_VPTESTMD + "vptestmq", // X86_INS_VPTESTMQ + "vptestmw", // X86_INS_VPTESTMW + "vptestnmb", // X86_INS_VPTESTNMB + "vptestnmd", // X86_INS_VPTESTNMD + "vptestnmq", // X86_INS_VPTESTNMQ + "vptestnmw", // X86_INS_VPTESTNMW + "vptest", // X86_INS_VPTEST + "vpunpckhbw", // X86_INS_VPUNPCKHBW + "vpunpckhdq", // X86_INS_VPUNPCKHDQ + "vpunpckhqdq", // X86_INS_VPUNPCKHQDQ + "vpunpckhwd", // X86_INS_VPUNPCKHWD + "vpunpcklbw", // X86_INS_VPUNPCKLBW + "vpunpckldq", // X86_INS_VPUNPCKLDQ + "vpunpcklqdq", // X86_INS_VPUNPCKLQDQ + "vpunpcklwd", // X86_INS_VPUNPCKLWD + "vpxord", // X86_INS_VPXORD + "vpxorq", // X86_INS_VPXORQ + "vpxor", // X86_INS_VPXOR + "vrangepd", // X86_INS_VRANGEPD + "vrangeps", // X86_INS_VRANGEPS + "vrangesd", // X86_INS_VRANGESD + "vrangess", // X86_INS_VRANGESS + "vrcp14pd", // X86_INS_VRCP14PD + "vrcp14ps", // X86_INS_VRCP14PS + "vrcp14sd", // X86_INS_VRCP14SD + "vrcp14ss", // X86_INS_VRCP14SS + "vrcp28pd", // X86_INS_VRCP28PD + "vrcp28ps", // X86_INS_VRCP28PS + "vrcp28sd", // X86_INS_VRCP28SD + "vrcp28ss", // X86_INS_VRCP28SS + "vrcpps", // X86_INS_VRCPPS + "vrcpss", // X86_INS_VRCPSS + "vreducepd", // X86_INS_VREDUCEPD + "vreduceps", // X86_INS_VREDUCEPS + "vreducesd", // X86_INS_VREDUCESD + "vreducess", // X86_INS_VREDUCESS + "vrndscalepd", // X86_INS_VRNDSCALEPD + "vrndscaleps", // X86_INS_VRNDSCALEPS + "vrndscalesd", // X86_INS_VRNDSCALESD + "vrndscaless", // X86_INS_VRNDSCALESS + "vroundpd", // X86_INS_VROUNDPD + "vroundps", // X86_INS_VROUNDPS + "vroundsd", // X86_INS_VROUNDSD + "vroundss", // X86_INS_VROUNDSS + "vrsqrt14pd", // X86_INS_VRSQRT14PD + "vrsqrt14ps", // X86_INS_VRSQRT14PS + "vrsqrt14sd", // X86_INS_VRSQRT14SD + "vrsqrt14ss", // X86_INS_VRSQRT14SS + "vrsqrt28pd", // X86_INS_VRSQRT28PD + "vrsqrt28ps", // X86_INS_VRSQRT28PS + "vrsqrt28sd", // X86_INS_VRSQRT28SD + "vrsqrt28ss", // X86_INS_VRSQRT28SS + "vrsqrtps", // X86_INS_VRSQRTPS + "vrsqrtss", // X86_INS_VRSQRTSS + "vscalefpd", // X86_INS_VSCALEFPD + "vscalefps", // X86_INS_VSCALEFPS + "vscalefsd", // X86_INS_VSCALEFSD + "vscalefss", // X86_INS_VSCALEFSS + "vscatterdpd", // X86_INS_VSCATTERDPD + "vscatterdps", // X86_INS_VSCATTERDPS + "vscatterpf0dpd", // X86_INS_VSCATTERPF0DPD + "vscatterpf0dps", // X86_INS_VSCATTERPF0DPS + "vscatterpf0qpd", // X86_INS_VSCATTERPF0QPD + "vscatterpf0qps", // X86_INS_VSCATTERPF0QPS + "vscatterpf1dpd", // X86_INS_VSCATTERPF1DPD + "vscatterpf1dps", // X86_INS_VSCATTERPF1DPS + "vscatterpf1qpd", // X86_INS_VSCATTERPF1QPD + "vscatterpf1qps", // X86_INS_VSCATTERPF1QPS + "vscatterqpd", // X86_INS_VSCATTERQPD + "vscatterqps", // X86_INS_VSCATTERQPS + "vshuff32x4", // X86_INS_VSHUFF32X4 + "vshuff64x2", // X86_INS_VSHUFF64X2 + "vshufi32x4", // X86_INS_VSHUFI32X4 + "vshufi64x2", // X86_INS_VSHUFI64X2 + "vshufpd", // X86_INS_VSHUFPD + "vshufps", // X86_INS_VSHUFPS + "vsqrtpd", // X86_INS_VSQRTPD + "vsqrtps", // X86_INS_VSQRTPS + "vsqrtsd", // X86_INS_VSQRTSD + "vsqrtss", // X86_INS_VSQRTSS + "vstmxcsr", // X86_INS_VSTMXCSR + "vsubpd", // X86_INS_VSUBPD + "vsubps", // X86_INS_VSUBPS + "vsubsd", // X86_INS_VSUBSD + "vsubss", // X86_INS_VSUBSS + "vtestpd", // X86_INS_VTESTPD + "vtestps", // X86_INS_VTESTPS + "vucomisd", // X86_INS_VUCOMISD + "vucomiss", // X86_INS_VUCOMISS + "vunpckhpd", // X86_INS_VUNPCKHPD + "vunpckhps", // X86_INS_VUNPCKHPS + "vunpcklpd", // X86_INS_VUNPCKLPD + "vunpcklps", // X86_INS_VUNPCKLPS + "vxorpd", // X86_INS_VXORPD + "vxorps", // X86_INS_VXORPS + "vzeroall", // X86_INS_VZEROALL + "vzeroupper", // X86_INS_VZEROUPPER + "wait", // X86_INS_WAIT + "wbinvd", // X86_INS_WBINVD + "wbnoinvd", // X86_INS_WBNOINVD + "wrfsbase", // X86_INS_WRFSBASE + "wrgsbase", // X86_INS_WRGSBASE + "wrmsr", // X86_INS_WRMSR + "wrpkru", // X86_INS_WRPKRU + "wrssd", // X86_INS_WRSSD + "wrssq", // X86_INS_WRSSQ + "wrussd", // X86_INS_WRUSSD + "wrussq", // X86_INS_WRUSSQ + "xabort", // X86_INS_XABORT + "xacquire", // X86_INS_XACQUIRE + "xadd", // X86_INS_XADD + "xbegin", // X86_INS_XBEGIN + "xchg", // X86_INS_XCHG + "fxch", // X86_INS_FXCH + "xcryptcbc", // X86_INS_XCRYPTCBC + "xcryptcfb", // X86_INS_XCRYPTCFB + "xcryptctr", // X86_INS_XCRYPTCTR + "xcryptecb", // X86_INS_XCRYPTECB + "xcryptofb", // X86_INS_XCRYPTOFB + "xend", // X86_INS_XEND + "xgetbv", // X86_INS_XGETBV + "xlatb", // X86_INS_XLATB + "xor", // X86_INS_XOR + "xorpd", // X86_INS_XORPD + "xorps", // X86_INS_XORPS + "xrelease", // X86_INS_XRELEASE + "xrstor", // X86_INS_XRSTOR + "xrstor64", // X86_INS_XRSTOR64 + "xrstors", // X86_INS_XRSTORS + "xrstors64", // X86_INS_XRSTORS64 + "xsave", // X86_INS_XSAVE + "xsave64", // X86_INS_XSAVE64 + "xsavec", // X86_INS_XSAVEC + "xsavec64", // X86_INS_XSAVEC64 + "xsaveopt", // X86_INS_XSAVEOPT + "xsaveopt64", // X86_INS_XSAVEOPT64 + "xsaves", // X86_INS_XSAVES + "xsaves64", // X86_INS_XSAVES64 + "xsetbv", // X86_INS_XSETBV + "xsha1", // X86_INS_XSHA1 + "xsha256", // X86_INS_XSHA256 + "xstore", // X86_INS_XSTORE + "xtest", // X86_INS_XTEST |