Enumeration X86Ins

invalid

case invalid

aaa

case aaa

aad

case aad

aam

case aam

aas

case aas

fabs

case fabs

adc

case adc

adcx

case adcx

add

case add

addpd

case addpd

addps

case addps

addsd

case addsd

addss

case addss

addsubpd

case addsubpd

addsubps

case addsubps

fadd

case fadd

fiadd

case fiadd

adox

case adox

aesdeclast

case aesdeclast

aesdec

case aesdec

aesenclast

case aesenclast

aesenc

case aesenc

aesimc

case aesimc

aeskeygenassist

case aeskeygenassist

and

case and

andn

case andn

andnpd

case andnpd

andnps

case andnps

andpd

case andpd

andps

case andps

arpl

case arpl

bextr

case bextr

blcfill

case blcfill

blci

case blci

blcic

case blcic

blcmsk

case blcmsk

blcs

case blcs

blendpd

case blendpd

blendps

case blendps

blendvpd

case blendvpd

blendvps

case blendvps

blsfill

case blsfill

blsi

case blsi

blsic

case blsic

blsmsk

case blsmsk

blsr

case blsr

bndcl

case bndcl

bndcn

case bndcn

bndcu

case bndcu

bndldx

case bndldx

bndmk

case bndmk

bndmov

case bndmov

bndstx

case bndstx

bound

case bound

bsf

case bsf

bsr

case bsr

bswap

case bswap

bt

case bt

btc

case btc

btr

case btr

bts

case bts

bzhi

case bzhi

call

case call

cbw

case cbw

cdq

case cdq

cdqe

case cdqe

fchs

case fchs

clac

case clac

clc

case clc

cld

case cld

cldemote

case cldemote

clflush

case clflush

clflushopt

case clflushopt

clgi

case clgi

cli

case cli

clrssbsy

case clrssbsy

clts

case clts

clwb

case clwb

clzero

case clzero

cmc

case cmc

cmova

case cmova

cmovae

case cmovae

cmovb

case cmovb

cmovbe

case cmovbe

fcmovbe

case fcmovbe

fcmovb

case fcmovb

cmove

case cmove

fcmove

case fcmove

cmovg

case cmovg

cmovge

case cmovge

cmovl

case cmovl

cmovle

case cmovle

fcmovnbe

case fcmovnbe

fcmovnb

case fcmovnb

cmovne

case cmovne

fcmovne

case fcmovne

cmovno

case cmovno

cmovnp

case cmovnp

fcmovnu

case fcmovnu

fcmovnp

case fcmovnp

cmovns

case cmovns

cmovo

case cmovo

cmovp

case cmovp

fcmovu

case fcmovu

cmovs

case cmovs

cmp

case cmp

cmppd

case cmppd

cmpps

case cmpps

cmpsb

case cmpsb

cmpsd

case cmpsd

cmpsq

case cmpsq

cmpss

case cmpss

cmpsw

case cmpsw

cmpxchg16b

case cmpxchg16b

cmpxchg

case cmpxchg

cmpxchg8b

case cmpxchg8b

comisd

case comisd

comiss

case comiss

fcomp

case fcomp

fcompi

case fcompi

fcomi

case fcomi

fcom

case fcom

fcos

case fcos

cpuid

case cpuid

cqo

case cqo

crc32

case crc32

cvtdq2pd

case cvtdq2pd

cvtdq2ps

case cvtdq2ps

cvtpd2dq

case cvtpd2dq

cvtpd2ps

case cvtpd2ps

cvtps2dq

case cvtps2dq

cvtps2pd

case cvtps2pd

cvtsd2si

case cvtsd2si

cvtsd2ss

case cvtsd2ss

cvtsi2sd

case cvtsi2sd

cvtsi2ss

case cvtsi2ss

cvtss2sd

case cvtss2sd

cvtss2si

case cvtss2si

cvttpd2dq

case cvttpd2dq

cvttps2dq

case cvttps2dq

cvttsd2si

case cvttsd2si

cvttss2si

case cvttss2si

cwd

case cwd

cwde

case cwde

daa

case daa

das

case das

data16

case data16

dec

case dec

div

case div

divpd

case divpd

divps

case divps

fdivr

case fdivr

fidivr

case fidivr

fdivrp

case fdivrp

divsd

case divsd

divss

case divss

fdiv

case fdiv

fidiv

case fidiv

fdivp

case fdivp

dppd

case dppd

dpps

case dpps

encls

case encls

enclu

case enclu

enclv

case enclv

endbr32

case endbr32

endbr64

case endbr64

enter

case enter

extractps

case extractps

extrq

case extrq

f2xm1

case f2xm1

lcall

case lcall

ljmp

case ljmp

jmp

case jmp

fbld

case fbld

fbstp

case fbstp

fcompp

case fcompp

fdecstp

case fdecstp

fdisi8087Nop

case fdisi8087Nop

femms

case femms

feni8087Nop

case feni8087Nop

ffree

case ffree

ffreep

case ffreep

ficom

case ficom

ficomp

case ficomp

fincstp

case fincstp

fldcw

case fldcw

fldenv

case fldenv

fldl2e

case fldl2e

fldl2t

case fldl2t

fldlg2

case fldlg2

fldln2

case fldln2

fldpi

case fldpi

fnclex

case fnclex

fninit

case fninit

fnop

case fnop

fnstcw

case fnstcw

fnstsw

case fnstsw

fpatan

case fpatan

fstpnce

case fstpnce

fprem

case fprem

fprem1

case fprem1

fptan

case fptan

frndint

case frndint

frstor

case frstor

fnsave

case fnsave

fscale

case fscale

fsetpm

case fsetpm

fsincos

case fsincos

fnstenv

case fnstenv

fxam

case fxam

fxrstor

case fxrstor

fxrstor64

case fxrstor64

fxsave

case fxsave

fxsave64

case fxsave64

fxtract

case fxtract

fyl2x

case fyl2x

fyl2xp1

case fyl2xp1

getsec

case getsec

gf2p8affineinvqb

case gf2p8affineinvqb

gf2p8affineqb

case gf2p8affineqb

gf2p8mulb

case gf2p8mulb

haddpd

case haddpd

haddps

case haddps

hlt

case hlt

hsubpd

case hsubpd

hsubps

case hsubps

idiv

case idiv

fild

case fild

imul

case imul

`in`

case `in`

inc

case inc

incsspd

case incsspd

incsspq

case incsspq

insb

case insb

insertps

case insertps

insertq

case insertq

insd

case insd

insw

case insw

int

case int

int1

case int1

int3

case int3

into

case into

invd

case invd

invept

case invept

invlpg

case invlpg

invlpga

case invlpga

invpcid

case invpcid

invvpid

case invvpid

iret

case iret

iretd

case iretd

iretq

case iretq

fisttp

case fisttp

fist

case fist

fistp

case fistp

jae

case jae

ja

case ja

jbe

case jbe

jb

case jb

jcxz

case jcxz

jecxz

case jecxz

je

case je

jge

case jge

jg

case jg

jle

case jle

jl

case jl

jne

case jne

jno

case jno

jnp

case jnp

jns

case jns

jo

case jo

jp

case jp

jrcxz

case jrcxz

js

case js

kaddb

case kaddb

kaddd

case kaddd

kaddq

case kaddq

kaddw

case kaddw

kandb

case kandb

kandd

case kandd

kandnb

case kandnb

kandnd

case kandnd

kandnq

case kandnq

kandnw

case kandnw

kandq

case kandq

kandw

case kandw

kmovb

case kmovb

kmovd

case kmovd

kmovq

case kmovq

kmovw

case kmovw

knotb

case knotb

knotd

case knotd

knotq

case knotq

knotw

case knotw

korb

case korb

kord

case kord

korq

case korq

kortestb

case kortestb

kortestd

case kortestd

kortestq

case kortestq

kortestw

case kortestw

korw

case korw

kshiftlb

case kshiftlb

kshiftld

case kshiftld

kshiftlq

case kshiftlq

kshiftlw

case kshiftlw

kshiftrb

case kshiftrb

kshiftrd

case kshiftrd

kshiftrq

case kshiftrq

kshiftrw

case kshiftrw

ktestb

case ktestb

ktestd

case ktestd

ktestq

case ktestq

ktestw

case ktestw

kunpckbw

case kunpckbw

kunpckdq

case kunpckdq

kunpckwd

case kunpckwd

kxnorb

case kxnorb

kxnord

case kxnord

kxnorq

case kxnorq

kxnorw

case kxnorw

kxorb

case kxorb

kxord

case kxord

kxorq

case kxorq

kxorw

case kxorw

lahf

case lahf

lar

case lar

lddqu

case lddqu

ldmxcsr

case ldmxcsr

lds

case lds

fldz

case fldz

fld1

case fld1

fld

case fld

lea

case lea

leave

case leave

les

case les

lfence

case lfence

lfs

case lfs

lgdt

case lgdt

lgs

case lgs

lidt

case lidt

lldt

case lldt

llwpcb

case llwpcb

lmsw

case lmsw

lock

case lock

lodsb

case lodsb

lodsd

case lodsd

lodsq

case lodsq

lodsw

case lodsw

loop

case loop

loope

case loope

loopne

case loopne

retf

case retf

retfq

case retfq

lsl

case lsl

lss

case lss

ltr

case ltr

lwpins

case lwpins

lwpval

case lwpval

lzcnt

case lzcnt

maskmovdqu

case maskmovdqu

maxpd

case maxpd

maxps

case maxps

maxsd

case maxsd

maxss

case maxss

mfence

case mfence

minpd

case minpd

minps

case minps

minsd

case minsd

minss

case minss

cvtpd2pi

case cvtpd2pi

cvtpi2pd

case cvtpi2pd

cvtpi2ps

case cvtpi2ps

cvtps2pi

case cvtps2pi

cvttpd2pi

case cvttpd2pi

cvttps2pi

case cvttps2pi

emms

case emms

maskmovq

case maskmovq

movd

case movd

movq

case movq

movdq2q

case movdq2q

movntq

case movntq

movq2dq

case movq2dq

pabsb

case pabsb

pabsd

case pabsd

pabsw

case pabsw

packssdw

case packssdw

packsswb

case packsswb

packuswb

case packuswb

paddb

case paddb

paddd

case paddd

paddq

case paddq

paddsb

case paddsb

paddsw

case paddsw

paddusb

case paddusb

paddusw

case paddusw

paddw

case paddw

palignr

case palignr

pandn

case pandn

pand

case pand

pavgb

case pavgb

pavgw

case pavgw

pcmpeqb

case pcmpeqb

pcmpeqd

case pcmpeqd

pcmpeqw

case pcmpeqw

pcmpgtb

case pcmpgtb

pcmpgtd

case pcmpgtd

pcmpgtw

case pcmpgtw

pextrw

case pextrw

phaddd

case phaddd

phaddsw

case phaddsw

phaddw

case phaddw

phsubd

case phsubd

phsubsw

case phsubsw

phsubw

case phsubw

pinsrw

case pinsrw

pmaddubsw

case pmaddubsw

pmaddwd

case pmaddwd

pmaxsw

case pmaxsw

pmaxub

case pmaxub

pminsw

case pminsw

pminub

case pminub

pmovmskb

case pmovmskb

pmulhrsw

case pmulhrsw

pmulhuw

case pmulhuw

pmulhw

case pmulhw

pmullw

case pmullw

pmuludq

case pmuludq

por

case por

psadbw

case psadbw

pshufb

case pshufb

pshufw

case pshufw

psignb

case psignb

psignd

case psignd

psignw

case psignw

pslld

case pslld

psllq

case psllq

psllw

case psllw

psrad

case psrad

psraw

case psraw

psrld

case psrld

psrlq

case psrlq

psrlw

case psrlw

psubb

case psubb

psubd

case psubd

psubq

case psubq

psubsb

case psubsb

psubsw

case psubsw

psubusb

case psubusb

psubusw

case psubusw

psubw

case psubw

punpckhbw

case punpckhbw

punpckhdq

case punpckhdq

punpckhwd

case punpckhwd

punpcklbw

case punpcklbw

punpckldq

case punpckldq

punpcklwd

case punpcklwd

pxor

case pxor

monitorx

case monitorx

monitor

case monitor

montmul

case montmul

mov

case mov

movabs

case movabs

movapd

case movapd

movaps

case movaps

movbe

case movbe

movddup

case movddup

movdir64b

case movdir64b

movdiri

case movdiri

movdqa

case movdqa

movdqu

case movdqu

movhlps

case movhlps

movhpd

case movhpd

movhps

case movhps

movlhps

case movlhps

movlpd

case movlpd

movlps

case movlps

movmskpd

case movmskpd

movmskps

case movmskps

movntdqa

case movntdqa

movntdq

case movntdq

movnti

case movnti

movntpd

case movntpd

movntps

case movntps

movntsd

case movntsd

movntss

case movntss

movsb

case movsb

movsd

case movsd

movshdup

case movshdup

movsldup

case movsldup

movsq

case movsq

movss

case movss

movsw

case movsw

movsx

case movsx

movsxd

case movsxd

movupd

case movupd

movups

case movups

movzx

case movzx

mpsadbw

case mpsadbw

mul

case mul

mulpd

case mulpd

mulps

case mulps

mulsd

case mulsd

mulss

case mulss

mulx

case mulx

fmul

case fmul

fimul

case fimul

fmulp

case fmulp

mwaitx

case mwaitx

mwait

case mwait

neg

case neg

nop

case nop

not

case not

or

case or

orpd

case orpd

orps

case orps

out

case out

outsb

case outsb

outsd

case outsd

outsw

case outsw

packusdw

case packusdw

pause

case pause

pavgusb

case pavgusb

pblendvb

case pblendvb

pblendw

case pblendw

pclmulqdq

case pclmulqdq

pcmpeqq

case pcmpeqq

pcmpestri

case pcmpestri

pcmpestrm

case pcmpestrm

pcmpgtq

case pcmpgtq

pcmpistri

case pcmpistri

pcmpistrm

case pcmpistrm

pconfig

case pconfig

pdep

case pdep

pext

case pext

pextrb

case pextrb

pextrd

case pextrd

pextrq

case pextrq

pf2id

case pf2id

pf2iw

case pf2iw

pfacc

case pfacc

pfadd

case pfadd

pfcmpeq

case pfcmpeq

pfcmpge

case pfcmpge

pfcmpgt

case pfcmpgt

pfmax

case pfmax

pfmin

case pfmin

pfmul

case pfmul

pfnacc

case pfnacc

pfpnacc

case pfpnacc

pfrcpit1

case pfrcpit1

pfrcpit2

case pfrcpit2

pfrcp

case pfrcp

pfrsqit1

case pfrsqit1

pfrsqrt

case pfrsqrt

pfsubr

case pfsubr

pfsub

case pfsub

phminposuw

case phminposuw

pi2fd

case pi2fd

pi2fw

case pi2fw

pinsrb

case pinsrb

pinsrd

case pinsrd

pinsrq

case pinsrq

pmaxsb

case pmaxsb

pmaxsd

case pmaxsd

pmaxud

case pmaxud

pmaxuw

case pmaxuw

pminsb

case pminsb

pminsd

case pminsd

pminud

case pminud

pminuw

case pminuw

pmovsxbd

case pmovsxbd

pmovsxbq

case pmovsxbq

pmovsxbw

case pmovsxbw

pmovsxdq

case pmovsxdq

pmovsxwd

case pmovsxwd

pmovsxwq

case pmovsxwq

pmovzxbd

case pmovzxbd

pmovzxbq

case pmovzxbq

pmovzxbw

case pmovzxbw

pmovzxdq

case pmovzxdq

pmovzxwd

case pmovzxwd

pmovzxwq

case pmovzxwq

pmuldq

case pmuldq

pmulhrw

case pmulhrw

pmulld

case pmulld

pop

case pop

popaw

case popaw

popal

case popal

popcnt

case popcnt

popf

case popf

popfd

case popfd

popfq

case popfq

prefetch

case prefetch

prefetchnta

case prefetchnta

prefetcht0

case prefetcht0

prefetcht1

case prefetcht1

prefetcht2

case prefetcht2

prefetchw

case prefetchw

prefetchwt1

case prefetchwt1

pshufd

case pshufd

pshufhw

case pshufhw

pshuflw

case pshuflw

pslldq

case pslldq

psrldq

case psrldq

pswapd

case pswapd

ptest

case ptest

ptwrite

case ptwrite

punpckhqdq

case punpckhqdq

punpcklqdq

case punpcklqdq

push

case push

pushaw

case pushaw

pushal

case pushal

pushf

case pushf

pushfd

case pushfd

pushfq

case pushfq

rcl

case rcl

rcpps

case rcpps

rcpss

case rcpss

rcr

case rcr

rdfsbase

case rdfsbase

rdgsbase

case rdgsbase

rdmsr

case rdmsr

rdpid

case rdpid

rdpkru

case rdpkru

rdpmc

case rdpmc

rdrand

case rdrand

rdseed

case rdseed

rdsspd

case rdsspd

rdsspq

case rdsspq

rdtsc

case rdtsc

rdtscp

case rdtscp

repne

case repne

rep

case rep

ret

case ret

rex64

case rex64

rol

case rol

ror

case ror

rorx

case rorx

roundpd

case roundpd

roundps

case roundps

roundsd

case roundsd

roundss

case roundss

rsm

case rsm

rsqrtps

case rsqrtps

rsqrtss

case rsqrtss

rstorssp

case rstorssp

sahf

case sahf

sal

case sal

salc

case salc

sar

case sar

sarx

case sarx

saveprevssp

case saveprevssp

sbb

case sbb

scasb

case scasb

scasd

case scasd

scasq

case scasq

scasw

case scasw

setae

case setae

seta

case seta

setbe

case setbe

setb

case setb

sete

case sete

setge

case setge

setg

case setg

setle

case setle

setl

case setl

setne

case setne

setno

case setno

setnp

case setnp

setns

case setns

seto

case seto

setp

case setp

setssbsy

case setssbsy

sets

case sets

sfence

case sfence

sgdt

case sgdt

sha1msg1

case sha1msg1

sha1msg2

case sha1msg2

sha1nexte

case sha1nexte

sha1rnds4

case sha1rnds4

sha256msg1

case sha256msg1

sha256msg2

case sha256msg2

sha256rnds2

case sha256rnds2

shl

case shl

shld

case shld

shlx

case shlx

shr

case shr

shrd

case shrd

shrx

case shrx

shufpd

case shufpd

shufps

case shufps

sidt

case sidt

fsin

case fsin

skinit

case skinit

sldt

case sldt

slwpcb

case slwpcb

smsw

case smsw

sqrtpd

case sqrtpd

sqrtps

case sqrtps

sqrtsd

case sqrtsd

sqrtss

case sqrtss

fsqrt

case fsqrt

stac

case stac

stc

case stc

std

case std

stgi

case stgi

sti

case sti

stmxcsr

case stmxcsr

stosb

case stosb

stosd

case stosd

stosq

case stosq

stosw

case stosw

str

case str

fst

case fst

fstp

case fstp

sub

case sub

subpd

case subpd

subps

case subps

fsubr

case fsubr

fisubr

case fisubr

fsubrp

case fsubrp

subsd

case subsd

subss

case subss

fsub

case fsub

fisub

case fisub

fsubp

case fsubp

swapgs

case swapgs

syscall

case syscall

sysenter

case sysenter

sysexit

case sysexit

sysexitq

case sysexitq

sysret

case sysret

sysretq

case sysretq

t1mskc

case t1mskc

test

case test

tpause

case tpause

ftst

case ftst

tzcnt

case tzcnt

tzmsk

case tzmsk

ucomisd

case ucomisd

ucomiss

case ucomiss

fucompi

case fucompi

fucomi

case fucomi

fucompp

case fucompp

fucomp

case fucomp

fucom

case fucom

ud0

case ud0

ud1

case ud1

ud2

case ud2

umonitor

case umonitor

umwait

case umwait

unpckhpd

case unpckhpd

unpckhps

case unpckhps

unpcklpd

case unpcklpd

unpcklps

case unpcklps

v4fmaddps

case v4fmaddps

v4fmaddss

case v4fmaddss

v4fnmaddps

case v4fnmaddps

v4fnmaddss

case v4fnmaddss

vaddpd

case vaddpd

vaddps

case vaddps

vaddsd

case vaddsd

vaddss

case vaddss

vaddsubpd

case vaddsubpd

vaddsubps

case vaddsubps

vaesdeclast

case vaesdeclast

vaesdec

case vaesdec

vaesenclast

case vaesenclast

vaesenc

case vaesenc

vaesimc

case vaesimc

vaeskeygenassist

case vaeskeygenassist

valignd

case valignd

valignq

case valignq

vandnpd

case vandnpd

vandnps

case vandnps

vandpd

case vandpd

vandps

case vandps

vblendmpd

case vblendmpd

vblendmps

case vblendmps

vblendpd

case vblendpd

vblendps

case vblendps

vblendvpd

case vblendvpd

vblendvps

case vblendvps

vbroadcastf128

case vbroadcastf128

vbroadcastf32x2

case vbroadcastf32x2

vbroadcastf32x4

case vbroadcastf32x4

vbroadcastf32x8

case vbroadcastf32x8

vbroadcastf64x2

case vbroadcastf64x2

vbroadcastf64x4

case vbroadcastf64x4

vbroadcasti128

case vbroadcasti128

vbroadcasti32x2

case vbroadcasti32x2

vbroadcasti32x4

case vbroadcasti32x4

vbroadcasti32x8

case vbroadcasti32x8

vbroadcasti64x2

case vbroadcasti64x2

vbroadcasti64x4

case vbroadcasti64x4

vbroadcastsd

case vbroadcastsd

vbroadcastss

case vbroadcastss

vcmp

case vcmp

vcmppd

case vcmppd

vcmpps

case vcmpps

vcmpsd

case vcmpsd

vcmpss

case vcmpss

vcomisd

case vcomisd

vcomiss

case vcomiss

vcompresspd

case vcompresspd

vcompressps

case vcompressps

vcvtdq2pd

case vcvtdq2pd

vcvtdq2ps

case vcvtdq2ps

vcvtpd2dq

case vcvtpd2dq

vcvtpd2ps

case vcvtpd2ps

vcvtpd2qq

case vcvtpd2qq

vcvtpd2udq

case vcvtpd2udq

vcvtpd2uqq

case vcvtpd2uqq

vcvtph2ps

case vcvtph2ps

vcvtps2dq

case vcvtps2dq

vcvtps2pd

case vcvtps2pd

vcvtps2ph

case vcvtps2ph

vcvtps2qq

case vcvtps2qq

vcvtps2udq

case vcvtps2udq

vcvtps2uqq

case vcvtps2uqq

vcvtqq2pd

case vcvtqq2pd

vcvtqq2ps

case vcvtqq2ps

vcvtsd2si

case vcvtsd2si

vcvtsd2ss

case vcvtsd2ss

vcvtsd2usi

case vcvtsd2usi

vcvtsi2sd

case vcvtsi2sd

vcvtsi2ss

case vcvtsi2ss

vcvtss2sd

case vcvtss2sd

vcvtss2si

case vcvtss2si

vcvtss2usi

case vcvtss2usi

vcvttpd2dq

case vcvttpd2dq

vcvttpd2qq

case vcvttpd2qq

vcvttpd2udq

case vcvttpd2udq

vcvttpd2uqq

case vcvttpd2uqq

vcvttps2dq

case vcvttps2dq

vcvttps2qq

case vcvttps2qq

vcvttps2udq

case vcvttps2udq

vcvttps2uqq

case vcvttps2uqq

vcvttsd2si

case vcvttsd2si

vcvttsd2usi

case vcvttsd2usi

vcvttss2si

case vcvttss2si

vcvttss2usi

case vcvttss2usi

vcvtudq2pd

case vcvtudq2pd

vcvtudq2ps

case vcvtudq2ps

vcvtuqq2pd

case vcvtuqq2pd

vcvtuqq2ps

case vcvtuqq2ps

vcvtusi2sd

case vcvtusi2sd

vcvtusi2ss

case vcvtusi2ss

vdbpsadbw

case vdbpsadbw

vdivpd

case vdivpd

vdivps

case vdivps

vdivsd

case vdivsd

vdivss

case vdivss

vdppd

case vdppd

vdpps

case vdpps

verr

case verr

verw

case verw

vexp2pd

case vexp2pd

vexp2ps

case vexp2ps

vexpandpd

case vexpandpd

vexpandps

case vexpandps

vextractf128

case vextractf128

vextractf32x4

case vextractf32x4

vextractf32x8

case vextractf32x8

vextractf64x2

case vextractf64x2

vextractf64x4

case vextractf64x4

vextracti128

case vextracti128

vextracti32x4

case vextracti32x4

vextracti32x8

case vextracti32x8

vextracti64x2

case vextracti64x2

vextracti64x4

case vextracti64x4

vextractps

case vextractps

vfixupimmpd

case vfixupimmpd

vfixupimmps

case vfixupimmps

vfixupimmsd

case vfixupimmsd

vfixupimmss

case vfixupimmss

vfmadd132pd

case vfmadd132pd

vfmadd132ps

case vfmadd132ps

vfmadd132sd

case vfmadd132sd

vfmadd132ss

case vfmadd132ss

vfmadd213pd

case vfmadd213pd

vfmadd213ps

case vfmadd213ps

vfmadd213sd

case vfmadd213sd

vfmadd213ss

case vfmadd213ss

vfmadd231pd

case vfmadd231pd

vfmadd231ps

case vfmadd231ps

vfmadd231sd

case vfmadd231sd

vfmadd231ss

case vfmadd231ss

vfmaddpd

case vfmaddpd

vfmaddps

case vfmaddps

vfmaddsd

case vfmaddsd

vfmaddss

case vfmaddss

vfmaddsub132pd

case vfmaddsub132pd

vfmaddsub132ps

case vfmaddsub132ps

vfmaddsub213pd

case vfmaddsub213pd

vfmaddsub213ps

case vfmaddsub213ps

vfmaddsub231pd

case vfmaddsub231pd

vfmaddsub231ps

case vfmaddsub231ps

vfmaddsubpd

case vfmaddsubpd

vfmaddsubps

case vfmaddsubps

vfmsub132pd

case vfmsub132pd

vfmsub132ps

case vfmsub132ps

vfmsub132sd

case vfmsub132sd

vfmsub132ss

case vfmsub132ss

vfmsub213pd

case vfmsub213pd

vfmsub213ps

case vfmsub213ps

vfmsub213sd

case vfmsub213sd

vfmsub213ss

case vfmsub213ss

vfmsub231pd

case vfmsub231pd

vfmsub231ps

case vfmsub231ps

vfmsub231sd

case vfmsub231sd

vfmsub231ss

case vfmsub231ss

vfmsubadd132pd

case vfmsubadd132pd

vfmsubadd132ps

case vfmsubadd132ps

vfmsubadd213pd

case vfmsubadd213pd

vfmsubadd213ps

case vfmsubadd213ps

vfmsubadd231pd

case vfmsubadd231pd

vfmsubadd231ps

case vfmsubadd231ps

vfmsubaddpd

case vfmsubaddpd

vfmsubaddps

case vfmsubaddps

vfmsubpd

case vfmsubpd

vfmsubps

case vfmsubps

vfmsubsd

case vfmsubsd

vfmsubss

case vfmsubss

vfnmadd132pd

case vfnmadd132pd

vfnmadd132ps

case vfnmadd132ps

vfnmadd132sd

case vfnmadd132sd

vfnmadd132ss

case vfnmadd132ss

vfnmadd213pd

case vfnmadd213pd

vfnmadd213ps

case vfnmadd213ps

vfnmadd213sd

case vfnmadd213sd

vfnmadd213ss

case vfnmadd213ss

vfnmadd231pd

case vfnmadd231pd

vfnmadd231ps

case vfnmadd231ps

vfnmadd231sd

case vfnmadd231sd

vfnmadd231ss

case vfnmadd231ss

vfnmaddpd

case vfnmaddpd

vfnmaddps

case vfnmaddps

vfnmaddsd

case vfnmaddsd

vfnmaddss

case vfnmaddss

vfnmsub132pd

case vfnmsub132pd

vfnmsub132ps

case vfnmsub132ps

vfnmsub132sd

case vfnmsub132sd

vfnmsub132ss

case vfnmsub132ss

vfnmsub213pd

case vfnmsub213pd

vfnmsub213ps

case vfnmsub213ps

vfnmsub213sd

case vfnmsub213sd

vfnmsub213ss

case vfnmsub213ss

vfnmsub231pd

case vfnmsub231pd

vfnmsub231ps

case vfnmsub231ps

vfnmsub231sd

case vfnmsub231sd

vfnmsub231ss

case vfnmsub231ss

vfnmsubpd

case vfnmsubpd

vfnmsubps

case vfnmsubps

vfnmsubsd

case vfnmsubsd

vfnmsubss

case vfnmsubss

vfpclasspd

case vfpclasspd

vfpclassps

case vfpclassps

vfpclasssd

case vfpclasssd

vfpclassss

case vfpclassss

vfrczpd

case vfrczpd

vfrczps

case vfrczps

vfrczsd

case vfrczsd

vfrczss

case vfrczss

vgatherdpd

case vgatherdpd

vgatherdps

case vgatherdps

vgatherpf0dpd

case vgatherpf0dpd

vgatherpf0dps

case vgatherpf0dps

vgatherpf0qpd

case vgatherpf0qpd

vgatherpf0qps

case vgatherpf0qps

vgatherpf1dpd

case vgatherpf1dpd

vgatherpf1dps

case vgatherpf1dps

vgatherpf1qpd

case vgatherpf1qpd

vgatherpf1qps

case vgatherpf1qps

vgatherqpd

case vgatherqpd

vgatherqps

case vgatherqps

vgetexppd

case vgetexppd

vgetexpps

case vgetexpps

vgetexpsd

case vgetexpsd

vgetexpss

case vgetexpss

vgetmantpd

case vgetmantpd

vgetmantps

case vgetmantps

vgetmantsd

case vgetmantsd

vgetmantss

case vgetmantss

vgf2p8affineinvqb

case vgf2p8affineinvqb

vgf2p8affineqb

case vgf2p8affineqb

vgf2p8mulb

case vgf2p8mulb

vhaddpd

case vhaddpd

vhaddps

case vhaddps

vhsubpd

case vhsubpd

vhsubps

case vhsubps

vinsertf128

case vinsertf128

vinsertf32x4

case vinsertf32x4

vinsertf32x8

case vinsertf32x8

vinsertf64x2

case vinsertf64x2

vinsertf64x4

case vinsertf64x4

vinserti128

case vinserti128

vinserti32x4

case vinserti32x4

vinserti32x8

case vinserti32x8

vinserti64x2

case vinserti64x2

vinserti64x4

case vinserti64x4

vinsertps

case vinsertps

vlddqu

case vlddqu

vldmxcsr

case vldmxcsr

vmaskmovdqu

case vmaskmovdqu

vmaskmovpd

case vmaskmovpd

vmaskmovps

case vmaskmovps

vmaxpd

case vmaxpd

vmaxps

case vmaxps

vmaxsd

case vmaxsd

vmaxss

case vmaxss

vmcall

case vmcall

vmclear

case vmclear

vmfunc

case vmfunc

vminpd

case vminpd

vminps

case vminps

vminsd

case vminsd

vminss

case vminss

vmlaunch

case vmlaunch

vmload

case vmload

vmmcall

case vmmcall

vmovq

case vmovq

vmovapd

case vmovapd

vmovaps

case vmovaps

vmovddup

case vmovddup

vmovd

case vmovd

vmovdqa32

case vmovdqa32

vmovdqa64

case vmovdqa64

vmovdqa

case vmovdqa

vmovdqu16

case vmovdqu16

vmovdqu32

case vmovdqu32

vmovdqu64

case vmovdqu64

vmovdqu8

case vmovdqu8

vmovdqu

case vmovdqu

vmovhlps

case vmovhlps

vmovhpd

case vmovhpd

vmovhps

case vmovhps

vmovlhps

case vmovlhps

vmovlpd

case vmovlpd

vmovlps

case vmovlps

vmovmskpd

case vmovmskpd

vmovmskps

case vmovmskps

vmovntdqa

case vmovntdqa

vmovntdq

case vmovntdq

vmovntpd

case vmovntpd

vmovntps

case vmovntps

vmovsd

case vmovsd

vmovshdup

case vmovshdup

vmovsldup

case vmovsldup

vmovss

case vmovss

vmovupd

case vmovupd

vmovups

case vmovups

vmpsadbw

case vmpsadbw

vmptrld

case vmptrld

vmptrst

case vmptrst

vmread

case vmread

vmresume

case vmresume

vmrun

case vmrun

vmsave

case vmsave

vmulpd

case vmulpd

vmulps

case vmulps

vmulsd

case vmulsd

vmulss

case vmulss

vmwrite

case vmwrite

vmxoff

case vmxoff

vmxon

case vmxon

vorpd

case vorpd

vorps

case vorps

vp4dpwssds

case vp4dpwssds

vp4dpwssd

case vp4dpwssd

vpabsb

case vpabsb

vpabsd

case vpabsd

vpabsq

case vpabsq

vpabsw

case vpabsw

vpackssdw

case vpackssdw

vpacksswb

case vpacksswb

vpackusdw

case vpackusdw

vpackuswb

case vpackuswb

vpaddb

case vpaddb

vpaddd

case vpaddd

vpaddq

case vpaddq

vpaddsb

case vpaddsb

vpaddsw

case vpaddsw

vpaddusb

case vpaddusb

vpaddusw

case vpaddusw

vpaddw

case vpaddw

vpalignr

case vpalignr

vpandd

case vpandd

vpandnd

case vpandnd

vpandnq

case vpandnq

vpandn

case vpandn

vpandq

case vpandq

vpand

case vpand

vpavgb

case vpavgb

vpavgw

case vpavgw

vpblendd

case vpblendd

vpblendmb

case vpblendmb

vpblendmd

case vpblendmd

vpblendmq

case vpblendmq

vpblendmw

case vpblendmw

vpblendvb

case vpblendvb

vpblendw

case vpblendw

vpbroadcastb

case vpbroadcastb

vpbroadcastd

case vpbroadcastd

vpbroadcastmb2q

case vpbroadcastmb2q

vpbroadcastmw2d

case vpbroadcastmw2d

vpbroadcastq

case vpbroadcastq

vpbroadcastw

case vpbroadcastw

vpclmulqdq

case vpclmulqdq

vpcmov

case vpcmov

vpcmp

case vpcmp

vpcmpb

case vpcmpb

vpcmpd

case vpcmpd

vpcmpeqb

case vpcmpeqb

vpcmpeqd

case vpcmpeqd

vpcmpeqq

case vpcmpeqq

vpcmpeqw

case vpcmpeqw

vpcmpestri

case vpcmpestri

vpcmpestrm

case vpcmpestrm

vpcmpgtb

case vpcmpgtb

vpcmpgtd

case vpcmpgtd

vpcmpgtq

case vpcmpgtq

vpcmpgtw

case vpcmpgtw

vpcmpistri

case vpcmpistri

vpcmpistrm

case vpcmpistrm

vpcmpq

case vpcmpq

vpcmpub

case vpcmpub

vpcmpud

case vpcmpud

vpcmpuq

case vpcmpuq

vpcmpuw

case vpcmpuw

vpcmpw

case vpcmpw

vpcom

case vpcom

vpcomb

case vpcomb

vpcomd

case vpcomd

vpcompressb

case vpcompressb

vpcompressd

case vpcompressd

vpcompressq

case vpcompressq

vpcompressw

case vpcompressw