hexcore-capstone 1.2.0

package/deps/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