// Taken from https://git.zephyr-software.com/opensrc/SMPStaticAnalyzer/-/blob/802006b84d0572a18b037dc5d21596655ef6b95a/src/interfaces/irdb/STARS_IRDB_Instruction.cpp

aaa                 
aad                 
aam                 
aas                 
adc                 
add                 
and                 
arpl                
bound               
bsf                 
bsr                 
bt                  
btc                 
btr                 
bts                 
call                
callfi              
callni              
cbw                 
cwde                
cdqe                
clc                 
cld                 
cli                 
clts                
cmc                 
cmp
cmpsb
cmpsd
cmpsw
cmpsq   
cmps           
cwd                 
cdq                 
cqo                 
daa                 
das                 
dec                 
div                 
enterw              
enter               
enterd              
enterq              
hlt                 
idiv                
imul                
in                  
inc
insb
insw
insd
insq
ins                 
int                 
into                
int3                
iretw               
iret                
iretd               
iretq               
ja                  
jae                 
jb                  
jbe                 
jc                  
jcxz                
jecxz               
jrcxz               
je                  
jg                  
jge                 
jl                  
jle                 
jna                 
jnae                
jnb                 
jnbe                
jnc                 
jne                 
jng                 
jnge                
jnl                 
jnle                
jno                 
jnp                 
jns                 
jnz                 
jo                  
jp                  
jpe                 
jpo                 
js                  
jz                  
jmp             
jmpfi               
jmpni               
jmpshort            
lahf                
lar                 
lea                 
leavew              
leave               
leaved              
leaveq              
lgdt                
lidt                
lgs                 
lss                 
lds                 
les                 
lfs                 
lldt                
lmsw                
lock  
lodsb
lodsw
lodsd
lodsq             
lods                
loopw               
loop                
loopd               
loopq               
loopwe              
loope               
loopde              
loopqe              
loopwne             
loopne              
loopdne             
loopqne             
lsl                 
ltr                 
mov                 
movsp               
movsb
movsq
movsd
movsq
movs                
movsx               
movzx               
mul                 
neg                 
nop                 
not                 
or                  
out                
outsb
outsw
outsd
outsq
outs                
pop                 
popaw               
popa                
popad               
popaq               
popfw               
popf                
popfd               
popfq               
push                
pushaw              
pusha               
pushad              
pushaq              
pushfw              
pushf               
pushfd              
pushfq              
rcl                 
rcr                 
rol                 
ror                 
rep                 
repe                
repne            
ret
retn
retf                
sahf                
sal                 
sar                 
shl                 
shr                 
sbb              
scasb
scasw
scasd
scasq
scas                
seta                
setae               
setb                
setbe               
setc                
sete                
setg                
setge               
setl                
setle               
setna               
setnae              
setnb               
setnbe              
setnc               
setne               
setng               
setnge              
setnl               
setnle              
setno               
setnp               
setns               
setnz               
seto                
setp                
setpe               
setpo               
sets                
setz                
sgdt                
sidt                
shld                
shrd                
sldt                
smsw                
stc                 
std                 
sti             
stosq
stosd
stosw
stosb
stos
str                 
sub                 
test                
verr                
verw                
wait                
xchg 
xlatb
xlatw
xlatd
xlatq
xlat                
xor                 

	
	
	

cmpxchg             
bswap               
xadd                
invd                
wbinvd              
invlpg              

	
	
	

rdmsr               
wrmsr               
cpuid               
cmpxchg8b           
rdtsc               
rsm                 

	
	
	
cmova
cmova
cmovb
cmovbe
cmovg
cmovge
cmovl
cmovle
cmovnb
cmovno
cmovnp
cmovns
cmovnz
cmovo
cmovp
cmovs
cmovz

cmovnbe
cmovnle
cmovnl
cmovae
cmovne
cmove  
fcmovb
fcmove
fcmovbe
fcmovu
fcmovnb
fcmovne
fcmovnbe
fcmovnu

fcomi               
fucomi              
fcomip              
fucomip             
rdpmc               

	
	
	

fld                 
fst                 
fstp                
fxch                
fild                
fist                
fistp               
fbld                
fbstp               
fadd                
faddp               
fiadd               
fsub                
fsubp               
fisub               
fsubr               
fsubrp              
fisubr              
fmul                
fmulp               
fimul               
fdiv                
fdivp               
fidiv               
fdivr               
fdivrp              
fidivr              
fsqrt               
fscale              
fprem               
frndint             
fxtract             
fabs                
fchs                
fcom                
fcomp               
fcompp              
ficom               
ficomp              
ftst                
fxam                
fptan               
fpatan              
f2xm1               
fyl2x               
fyl2xp1             
fldz                
fld1                
fldpi               
fldl2t              
fldl2e              
fldlg2              
fldln2              
finit               
fninit              
fsetpm              
fldcw               
fstcw               
fnstcw              
fstsw               
fnstsw              
fclex               
fnclex              
fstenv              
fnstenv             
fldenv              
fsave               
fnsave              
frstor              
fincstp             
fdecstp             
ffree               
fnop
fdisi               
fndisi              

	
	
	

fprem1              
fsincos             
fsin                
fcos                
fucom               
fucomp              
fucompp             

	
	
	

setalc              
svdc                
rsdc                
svldt               
rsldt               
svts                
rsts                
int1
icebp               
loadall             
	

emms                
movd                
movq                
packsswb            
packssdw            
packuswb            
paddb               
paddw               
paddd               
paddsb              
paddsw              
paddusb             
paddusw             
pand                
pandn               
pcmpeqb             
pcmpeqw             
pcmpeqd             
pcmpgtb             
pcmpgtw             
pcmpgtd             
pmaddwd             
pmulhw              
pmullw              
por                 
psllw               
pslld               
psllq               
psraw               
psrad               
psrlw               
psrld               
psrlq               
psubb               
psubw               
psubd               
psubsb              
psubsw              
psubusb             
psubusw             
punpckhbw           
punpckhwd           
punpckhdq           
punpcklbw           
punpcklwd           
punpckldq           
pxor                

	
	
	

fxsave              
fxrstor             

	

sysenter            
sysexit             

	

pavgusb             
pfadd               
pfsub               
pfsubr              
pfacc               
pfcmpge             
pfcmpgt             
pfcmpeq             
pfmin               
pfmax               
pi2fd               
pf2id               
pfrcp               
pfrsqrt             
pfmul               
pfrcpit1            
pfrsqit1            
pfrcpit2            
pmulhrw             
femms               
prefetch            
prefetchw           


	

addps               
addss               
andnps              
andps               
cmpps               
cmpss               
comiss              
cvtpi2ps            
cvtps2pi            
cvtsi2ss            
cvtss2si            
cvttps2pi           
cvttss2si           
divps               
divss               
ldmxcsr             
maxps               
maxss               
minps               
minss               
movaps              
movhlps             
movhps              
movlhps             
movlps              
movmskps            
movss               
movups              
mulps               
mulss               
orps                
rcpps               
rcpss               
rsqrtps             
rsqrtss             
shufps              
sqrtps              
sqrtss              
stmxcsr             
subps               
subss               
ucomiss             
unpckhps            
unpcklps            
xorps               
pavgb               
pavgw               
pextrw              
pinsrw              
pmaxsw              
pmaxub              
pminsw              
pminub              
pmovmskb            
pmulhuw             
psadbw              
pshufw              
maskmovq            
movntps             
movntq              
prefetcht0          
prefetcht1
prefetcht2
prefetchnta
sfence              

cmpeqps             
cmpltps             
cmpleps             
cmpunordps          
cmpneqps            
cmpnltps            
cmpnleps            
cmpordps            
cmpeqss             
cmpltss             
cmpless             
cmpunordss          
cmpneqss            
cmpnltss            
cmpnless            
cmpordss            

pf2iw               
pfnacc              
pfpnacc             
pi2fw               
pswapd              

fstp1               
fcom2               
fcomp3              
fxch4               
fcomp5              
ffreep              
fxch7               
fstp8               
fstp9               

addpd               
addsd               
andnpd              
andpd               
clflush             
cmppd               
cmpsd               
comisd              
cvtdq2pd            
cvtdq2ps            
cvtpd2dq            
cvtpd2pi            
cvtpd2ps            
cvtpi2pd            
cvtps2dq            
cvtps2pd            
cvtsd2si            
cvtsd2ss            
cvtsi2sd            
cvtss2sd            
cvttpd2dq           
cvttpd2pi           
cvttps2dq           
cvttsd2si           
divpd               
divsd               
lfence              
maskmovdqu          
maxpd               
maxsd               
mfence              
minpd               
minsd               
movapd              
movdq2q             
movdqa              
movdqu              
movhpd              
movlpd              
movmskpd            
movntdq             
movnti              
movntpd             
movq2dq             
movsd               
movupd              
mulpd               
mulsd               
orpd                
paddq               
pause               
pmuludq             
pshufd              
pshufhw             
pshuflw             
pslldq              
psrldq              
psubq               
punpckhqdq          
punpcklqdq          
shufpd              
sqrtpd              
sqrtsd              
subpd               
subsd               
ucomisd             
unpckhpd            
unpcklpd            
xorpd               

syscall             
sysret              

swapgs              

movddup             
movshdup            
movsldup            

movsxd              
cmpxchg16b          

addsubpd            
addsubps            
haddpd              
haddps              
hsubpd              
hsubps              
monitor             
mwait               
fisttp              
lddqu               

psignb              
psignw              
psignd              
pshufb              
pmulhrsw            
pmaddubsw           
phsubsw             
phaddsw             
phaddw              
phaddd              
phsubw              
phsubd              
palignr             
pabsb               
pabsw               
pabsd               

vmcall              
vmclear             
vmlaunch            
vmresume            
vmptrld             
vmptrst             
vmread              
vmwrite             
vmxoff              
vmxon               

ud2                 

rdtscp              

pfrcpv              
pfrsqrtv            

cmpeqpd             
cmpltpd             
cmplepd             
cmpunordpd          
cmpneqpd            
cmpnltpd            
cmpnlepd            
cmpordpd            
cmpeqsd             
cmpltsd             
cmplesd             
cmpunordsd          
cmpneqsd            
cmpnltsd            
cmpnlesd            
cmpordsd            

blendpd              
blendps              
blendvpd             
blendvps             
dppd                 
dpps                 
extractps            
insertps             
movntdqa             
mpsadbw              
packusdw             
pblendvb             
pblendw              
pcmpeqq              
pextrb               
pextrd               
pextrq               
phminposuw           
pinsrb               
pinsrd               
pinsrq               
pmaxsb               
pmaxsd               
pmaxud               
pmaxuw               
pminsb               
pminsd               
pminud               
pminuw               
pmovsxbw             
pmovsxbd             
pmovsxbq             
pmovsxwd             
pmovsxwq             
pmovsxdq             
pmovzxbw             
pmovzxbd             
pmovzxbq             
pmovzxwd             
pmovzxwq             
pmovzxdq             
pmuldq               
pmulld               
ptest                
roundpd              
roundps              
roundsd              
roundss              

crc32                
pcmpestri            
pcmpestrm            
pcmpistri            
pcmpistrm            
pcmpgtq              
popcnt               

extrq                
insertq              
movntsd              
movntss              
lzcnt                

xgetbv               
xrstor               
xsave                
xsetbv               

getsec               

clgi                 
invlpga              
skinit               
stgi                 
vmexit               
vmload               
vmmcall              
vmrun                
vmsave               

invept               
invvpid              

movbe                

aesenc                
aesenclast            
aesdec                
aesdeclast            
aesimc                
aeskeygenassist       

pclmulqdq	
pclmullqlqdq
pclmulhqlqdq
pclmullqhqdq
pclmulhqhqdq

retnw               
retnd               
retnq               
retfw               
retfd               
retfq               

rdrand              

adcx                 
adox                 
andn                 
bextr                
blsi                 
blsmsk               
blsr                 
bzhi                 
clac                 
mulx                 
pdep                 
pext                 
rorx                 
sarx                 
shlx                 
shrx                 
stac                 
tzcnt                
xsaveopt             
invpcid              
rdseed               
rdfsbase             
rdgsbase             
wrfsbase             
wrgsbase             

	
vaddpd               
vaddps               
vaddsd               
vaddss               
vaddsubpd            
vaddsubps            
vaesdec              
vaesdeclast          
vaesenc              
vaesenclast          
vaesimc              
vaeskeygenassist     
vandnpd              
vandnps              
vandpd               
vandps               
vblendpd             
vblendps             
vblendvpd            
vblendvps            
vbroadcastf128       
vbroadcasti128       
vbroadcastsd         
vbroadcastss         
vcmppd               
vcmpps               
vcmpsd
vcmpeqsd
vcmpltsd
vcmplesd
vcmpunordsd
vcmpneqsd
vcmpnltsd
vcmpnlesd
vcmpordsd
vcmpeq_uqsd
vcmpngesd
vcmpngtsd
vcmpfalsesd
vcmpneq_oqsd
vcmpgesd
vcmpeqsd
vcmpltsd
vcmplesd
vcmpunordsd
vcmpneqsd
vcmpnltsd
vcmpnlesd
vcmpordsd
vcmpeq_uqsd
vcmpngesd
vcmpngtsd
vcmpfalsesd
vcmpneq_oqsd
vcmpgesd



vcmpss               
vcomisd              
vcomiss              
vcvtdq2pd            
vcvtdq2ps            
vcvtpd2dq            
vcvtpd2ps            
vcvtph2ps            
vcvtps2dq            
vcvtps2pd            
vcvtps2ph            
vcvtsd2si            
vcvtsd2ss            
vcvtsi2sd            
vcvtsi2ss            
vcvtss2sd            
vcvtss2si            
vcvttpd2dq           
vcvttps2dq           
vcvttsd2si           
vcvttss2si           
vdivpd               
vdivps               
vdivsd               
vdivss               
vdppd                
vdpps                
vextractf128         
vextracti128         
vextractps           
vfmadd132pd          
vfmadd132ps          
vfmadd132sd          
vfmadd132ss          
vfmadd213pd          
vfmadd213ps          
vfmadd213sd          
vfmadd213ss          
vfmadd231pd          
vfmadd231ps          
vfmadd231sd          
vfmadd231ss          
vfmaddsub132pd       
vfmaddsub132ps       
vfmaddsub213pd       
vfmaddsub213ps       
vfmaddsub231pd       
vfmaddsub231ps       
vfmsub132pd          
vfmsub132ps          
vfmsub132sd          
vfmsub132ss          
vfmsub213pd          
vfmsub213ps          
vfmsub213sd          
vfmsub213ss          
vfmsub231pd          
vfmsub231ps          
vfmsub231sd          
vfmsub231ss          
vfmsubadd132pd       
vfmsubadd132ps       
vfmsubadd213pd       
vfmsubadd213ps       
vfmsubadd231pd       
vfmsubadd231ps       
vfnmadd132pd         
vfnmadd132ps         
vfnmadd132sd         
vfnmadd132ss         
vfnmadd213pd         
vfnmadd213ps         
vfnmadd213sd         
vfnmadd213ss         
vfnmadd231pd         
vfnmadd231ps         
vfnmadd231sd         
vfnmadd231ss         
vfnmsub132pd         
vfnmsub132ps         
vfnmsub132sd         
vfnmsub132ss         
vfnmsub213pd         
vfnmsub213ps         
vfnmsub213sd         
vfnmsub213ss         
vfnmsub231pd         
vfnmsub231ps         
vfnmsub231sd         
vfnmsub231ss         
vgatherdps           
vgatherdpd           
vgatherqps           
vgatherqpd           
vhaddpd              
vhaddps              
vhsubpd              
vhsubps              
vinsertf128          
vinserti128          
vinsertps            
vlddqu               
vldmxcsr             
vmaskmovdqu          
vmaskmovpd           
vmaskmovps           
vmaxpd               
vmaxps               
vmaxsd               
vmaxss               
vminpd               
vminps               
vminsd               
vminss               
vmovapd              
vmovaps              
vmovd                
vmovddup             
vmovdqa              
vmovdqu              
vmovhlps             
vmovhpd              
vmovhps              
vmovlhps             
vmovlpd              
vmovlps              
vmovmskpd            
vmovmskps            
vmovntdq             
vmovntdqa            
vmovntpd             
vmovntps             
vmovntsd
vmovntss
vmovq                
vmovsd               
vmovshdup            
vmovsldup            
vmovss               
vmovupd              
vmovups              
vmpsadbw             
vmulpd               
vmulps               
vmulsd               
vmulss               
vorpd                
vorps                
vpabsb               
vpabsd               
vpabsw               
vpackssdw            
vpacksswb            
vpackusdw            
vpackuswb            
vpaddb               
vpaddd               
vpaddq               
vpaddsb              
vpaddsw              
vpaddusb             
vpaddusw             
vpaddw               
vpalignr             
vpand                
vpandn               
vpavgb               
vpavgw               
vpblendd             
vpblendvb            
vpblendw             
vpbroadcastb         
vpbroadcastd         
vpbroadcastq         
vpbroadcastw         
vpclmulqdq           
vpcmpeqb             
vpcmpeqd             
vpcmpeqq             
vpcmpeqw             
vpcmpestri           
vpcmpestrm           
vpcmpgtb             
vpcmpgtd             
vpcmpgtq             
vpcmpgtw             
vpcmpistri           
vpcmpistrm           
vperm2f128           
vperm2i128           
vpermd               
vpermilpd            
vpermilps            
vpermpd              
vpermps              
vpermq               
vpextrb              
vpextrd              
vpextrq              
vpextrw              
vpgatherdd           
vpgatherdq           
vpgatherqd           
vpgatherqq           
vphaddd              
vphaddsw             
vphaddw              
vphminposuw          
vphsubd              
vphsubsw             
vphsubw              
vpinsrb              
vpinsrd              
vpinsrq              
vpinsrw              
vpmaddubsw           
vpmaddwd             
vpmaskmovd           
vpmaskmovq           
vpmaxsb              
vpmaxsd              
vpmaxsw              
vpmaxub              
vpmaxud              
vpmaxuw              
vpminsb              
vpminsd              
vpminsw              
vpminub              
vpminud              
vpminuw              
vpmovmskb            
vpmovsxbd            
vpmovsxbq            
vpmovsxbw            
vpmovsxdq            
vpmovsxwd            
vpmovsxwq            
vpmovzxbd            
vpmovzxbq            
vpmovzxbw            
vpmovzxdq            
vpmovzxwd            
vpmovzxwq            
vpmuldq              
vpmulhrsw            
vpmulhuw             
vpmulhw              
vpmulld              
vpmullw              
vpmuludq             
vpor                 
vpsadbw              
vpshufb              
vpshufd              
vpshufhw             
vpshuflw             
vpsignb              
vpsignd              
vpsignw              
vpslld               
vpslldq              
vpsllq               
vpsllvd              
vpsllvq              
vpsllw               
vpsrad               
vpsravd              
vpsraw               
vpsrld               
vpsrldq              
vpsrlq               
vpsrlvd              
vpsrlvq              
vpsrlw               
vpsubb               
vpsubd               
vpsubq               
vpsubsb              
vpsubsw              
vpsubusb             
vpsubusw             
vpsubw               
vptest               
vpunpckhbw           
vpunpckhdq           
vpunpckhqdq          
vpunpckhwd           
vpunpcklbw           
vpunpckldq           
vpunpcklqdq          
vpunpcklwd           
vpxor                
vrcpps               
vrcpss               
vroundpd             
vroundps             
vroundsd             
vroundss             
vrsqrtps             
vrsqrtss             
vshufpd              
vshufps              
vsqrtpd              
vsqrtps              
vsqrtsd              
vsqrtss              
vstmxcsr             
vsubpd               
vsubps               
vsubsd               
vsubss               
vtestpd              
vtestps              
vucomisd             
vucomiss             
vunpckhpd            
vunpckhps            
vunpcklpd            
vunpcklps            
vxorpd               
vxorps               
vzeroall             
vzeroupper           

	

xabort               
xbegin               
xend                 
xtest                

	

vmgetinfo            
vmsetinfo            
vmdxdsbl             
vmdxenbl             
vmcpuid              
vmhlt                
vmsplaf              
vmpushfd             
vmpopfd              
vmcli                
vmsti                
vmiretd              
vmsgdt               
vmsidt               
vmsldt               
vmstr                
vmsdte               
vpcext               

vfmaddsubps          // Multiply with Alternating Add/Subtract of Packed Single-Precision Floating-Point
vfmaddsubpd          // Multiply with Alternating Add/Subtract of Packed Double-Precision Floating-Point
vfmsubaddps          // Multiply with Alternating Subtract/Add of Packed Single-Precision Floating-Point
vfmsubaddpd          // Multiply with Alternating Subtract/Add of Packed Double-Precision Floating-Point
vfmaddps             // Multiply and Add Packed Single-Precision Floating-Point
vfmaddpd             // Multiply and Add Packed Double-Precision Floating-Point
vfmaddss             // Multiply and Add Scalar Single-Precision Floating-Point
vfmaddsd             // Multiply and Add Scalar Double-Precision Floating-Point
vfmsubps             // Multiply and Subtract Packed Single-Precision Floating-Point
vfmsubpd             // Multiply and Subtract Packed Double-Precision Floating-Point
vfmsubss             // Multiply and Subtract Scalar Single-Precision Floating-Point
vfmsubsd             // Multiply and Subtract Scalar Double-Precision Floating-Point
vfnmaddps            // Negative Multiply and Add Packed Single-Precision Floating-Point
vfnmaddpd            // Negative Multiply and Add Packed Double-Precision Floating-Point
vfnmaddss            // Negative Multiply and Add Scalar Single-Precision Floating-Point
vfnmaddsd            // Negative Multiply and Add Double Single-Precision Floating-Point
vfnmsubps            // Negative Multiply and Subtract Packed Single-Precision Floating-Point
vfnmsubpd            // Negative Multiply and Subtract Packed Double-Precision Floating-Point
vfnmsubss            // Negative Multiply and Subtract Scalar Single-Precision Floating-Point
vfnmsubsd            // Negative Multiply and Subtract Double Single-Precision Floating-Point

bndmk                // Make Bounds
bndcl                // Check Lower Bound
bndcu                // Check Upper Bound
bndcn                // Check Upper Bound
bndmov               // Move Bounds
bndldx               // Load Extended Bounds Using Address Translation
bndstx               // Store Extended Bounds Using Address Translation

	// New xstate instructions

xrstors              // Restore Processor Extended States Supervisor
xsavec               // Save Processor Extended States with Compaction
xsaves               // Save Processor Extended States Supervisor

	// PREFETCHWT1 support

prefetchwt1          // Prefetch Vector Data Into Caches with Intent to Write and T1 Hint

	// Memory instructions

clflushopt           // Flush a Cache Line Optimized
clwb                 // Cache Line Write Back
pcommit              // Persistent Commit (deprecated by Intel)

	// Protection Key Rights for User Pages

rdpkru               // Read Protection Key Rights for User Pages
wrpkru               // Write Data to User Page Key Register

	// AVX comparison pseudo-ops

vcmpeqpd             // Compare Packed Double-Precision Floating-Point Values - Equal (ordered non-signaling)
vcmpltpd             // Compare Packed Double-Precision Floating-Point Values - Less-than (ordered signaling)
vcmplepd             // Compare Packed Double-Precision Floating-Point Values - Less-than-or-equal (ordered signaling)
vcmpunordpd          // Compare Packed Double-Precision Floating-Point Values - Unordered (non-signaling)
vcmpneqpd            // Compare Packed Double-Precision Floating-Point Values - Not-equal (unordered non-signaling)
vcmpnltpd            // Compare Packed Double-Precision Floating-Point Values - Not-less-than (unordered signaling)
vcmpnlepd            // Compare Packed Double-Precision Floating-Point Values - Not-less-than-or-equal (unordered signaling)
vcmpordpd            // Compare Packed Double-Precision Floating-Point Values - Ordered (non-signaling)
vcmpeq_uqpd          // Compare Packed Double-Precision Floating-Point Values - Equal (unordered non-signaling)
vcmpngepd            // Compare Packed Double-Precision Floating-Point Values - Not-greater-than-or-equal (unordered signaling)
vcmpngtpd            // Compare Packed Double-Precision Floating-Point Values - Not-greater-than (unordered signaling)
vcmpfalsepd          // Compare Packed Double-Precision Floating-Point Values - False (ordered non-signaling)
vcmpneq_oqpd         // Compare Packed Double-Precision Floating-Point Values - Not-equal (ordered non-signaling)
vcmpgepd             // Compare Packed Double-Precision Floating-Point Values - Greater-than-or-equal (ordered signaling)
vcmpgtpd             // Compare Packed Double-Precision Floating-Point Values - Greater-than (ordered signaling)
vcmptruepd           // Compare Packed Double-Precision Floating-Point Values - True (unordered non-signaling)
vcmpeq_ospd          // Compare Packed Double-Precision Floating-Point Values - Equal (ordered signaling)
vcmplt_oqpd          // Compare Packed Double-Precision Floating-Point Values - Less-than (ordered non-signaling)
vcmple_oqpd          // Compare Packed Double-Precision Floating-Point Values - Less-than-or-equal (ordered non-signaling)
vcmpunord_spd        // Compare Packed Double-Precision Floating-Point Values - Unordered (signaling)
vcmpneq_uspd         // Compare Packed Double-Precision Floating-Point Values - Not-equal (unordered signaling)
vcmpnlt_uqpd         // Compare Packed Double-Precision Floating-Point Values - Not-less-than (unordered non-signaling)
vcmpnle_uqpd         // Compare Packed Double-Precision Floating-Point Values - Not-less-than-or-equal (unordered non-signaling)
vcmpord_spd          // Compare Packed Double-Precision Floating-Point Values - Ordered (signaling)
vcmpeq_uspd          // Compare Packed Double-Precision Floating-Point Values - Equal (unordered signaling)
vcmpnge_uqpd         // Compare Packed Double-Precision Floating-Point Values - Not-greater-than-or-equal (unordered non-signaling)
vcmpngt_uqpd         // Compare Packed Double-Precision Floating-Point Values - Not-greater-than (unordered non-signaling)
vcmpfalse_ospd       // Compare Packed Double-Precision Floating-Point Values - False (ordered signaling)
vcmpneq_ospd         // Compare Packed Double-Precision Floating-Point Values - Not-equal (ordered signaling)
vcmpge_oqpd          // Compare Packed Double-Precision Floating-Point Values - Greater-than-or-equal (ordered non-signaling)
vcmpgt_oqpd          // Compare Packed Double-Precision Floating-Point Values - Greater-than (ordered non-signaling)
vcmptrue_uspd        // Compare Packed Double-Precision Floating-Point Values - True (unordered signaling)

vcmpeqps             // Packed Single-FP Compare - Equal (ordered non-signaling)
vcmpltps             // Packed Single-FP Compare - Less-than (ordered signaling)
vcmpleps             // Packed Single-FP Compare - Less-than-or-equal (ordered signaling)
vcmpunordps          // Packed Single-FP Compare - Unordered (non-signaling)
vcmpneqps            // Packed Single-FP Compare - Not-equal (unordered non-signaling)
vcmpnltps            // Packed Single-FP Compare - Not-less-than (unordered signaling)
vcmpnleps            // Packed Single-FP Compare - Not-less-than-or-equal (unordered signaling)
vcmpordps            // Packed Single-FP Compare - Ordered (non-signaling)
vcmpeq_uqps          // Packed Single-FP Compare - Equal (unordered non-signaling)
vcmpngeps            // Packed Single-FP Compare - Not-greater-than-or-equal (unordered signaling)
vcmpngtps            // Packed Single-FP Compare - Not-greater-than (unordered signaling)
vcmpfalseps          // Packed Single-FP Compare - False (ordered non-signaling)
vcmpneq_oqps         // Packed Single-FP Compare - Not-equal (ordered, non-signaling)
vcmpgeps             // Packed Single-FP Compare - Greater-than-or-equal (ordered, signaling)
vcmpgtps             // Packed Single-FP Compare - Greater-than (ordered, signaling)
vcmptrueps           // Packed Single-FP Compare - True (unordered, non-signaling)
vcmpeq_osps          // Packed Single-FP Compare - Equal (ordered, signaling)
vcmplt_oqps          // Packed Single-FP Compare - Less-than (ordered, non-signaling)
vcmple_oqps          // Packed Single-FP Compare - Less-than-or-equal (ordered, non-signaling)
vcmpunord_sps        // Packed Single-FP Compare - Unordered (signaling)
vcmpneq_usps         // Packed Single-FP Compare - Not-equal (unordered signaling)
vcmpnlt_uqps         // Packed Single-FP Compare - Not-less-than (unordered, non-signaling)
vcmpnle_uqps         // Packed Single-FP Compare - Not-less-than-or-equal (unordered, non-signaling)
vcmpord_sps          // Packed Single-FP Compare - Ordered (signaling)
vcmpeq_usps          // Packed Single-FP Compare - Equal (unordered, signaling)
vcmpnge_uqps         // Packed Single-FP Compare - Not-greater-than-or-equal (unordered, non-signaling)
vcmpngt_uqps         // Packed Single-FP Compare - Not-greater-than (unordered, non-signaling)
vcmpfalse_osps       // Packed Single-FP Compare - False (ordered, signaling)
vcmpneq_osps         // Packed Single-FP Compare - Not-equal (ordered, signaling)
vcmpge_oqps          // Packed Single-FP Compare - Greater-than-or-equal (ordered, non-signaling)
vcmpgt_oqps          // Packed Single-FP Compare - Greater-than (ordered, non-signaling)
vcmptrue_usps        // Packed Single-FP Compare - True (unordered, signaling)

vcmpeqsd             // Compare Scalar Double-Precision Floating-Point Values - Equal (ordered, non-signaling)
vcmpltsd             // Compare Scalar Double-Precision Floating-Point Values - Less-than (ordered, signaling)
vcmplesd             // Compare Scalar Double-Precision Floating-Point Values - Less-than-or-equal (ordered, signaling)
vcmpunordsd          // Compare Scalar Double-Precision Floating-Point Values - Unordered (non-signaling)
vcmpneqsd            // Compare Scalar Double-Precision Floating-Point Values - Not-equal (unordered, non-signaling)
vcmpnltsd            // Compare Scalar Double-Precision Floating-Point Values - Not-less-than (unordered, signaling)
vcmpnlesd            // Compare Scalar Double-Precision Floating-Point Values - Not-less-than-or-equal (unordered, signaling)
vcmpordsd            // Compare Scalar Double-Precision Floating-Point Values - Ordered (non-signaling)
vcmpeq_uqsd          // Compare Scalar Double-Precision Floating-Point Values - Equal (unordered, non-signaling)
vcmpngesd            // Compare Scalar Double-Precision Floating-Point Values - Not-greater-than-or-equal (unordered, signaling)
vcmpngtsd            // Compare Scalar Double-Precision Floating-Point Values - Not-greater-than (unordered, signaling)
vcmpfalsesd          // Compare Scalar Double-Precision Floating-Point Values - False (ordered, non-signaling)
vcmpneq_oqsd         // Compare Scalar Double-Precision Floating-Point Values - Not-equal (ordered, non-signaling)
vcmpgesd             // Compare Scalar Double-Precision Floating-Point Values - Greater-than-or-equal (ordered, signaling)
vcmpgtsd             // Compare Scalar Double-Precision Floating-Point Values - Greater-than (ordered, signaling)
vcmptruesd           // Compare Scalar Double-Precision Floating-Point Values - True (unordered, non-signaling)
vcmpeq_ossd          // Compare Scalar Double-Precision Floating-Point Values - Equal (ordered, signaling)
vcmplt_oqsd          // Compare Scalar Double-Precision Floating-Point Values - Less-than (ordered, non-signaling)
vcmple_oqsd          // Compare Scalar Double-Precision Floating-Point Values - Less-than-or-equal (ordered, non-signaling)
vcmpunord_ssd        // Compare Scalar Double-Precision Floating-Point Values - Unordered (signaling)
vcmpneq_ussd         // Compare Scalar Double-Precision Floating-Point Values - Not-equal (unordered, signaling)
vcmpnlt_uqsd         // Compare Scalar Double-Precision Floating-Point Values - Not-less-than (unordered, non-signaling)
vcmpnle_uqsd         // Compare Scalar Double-Precision Floating-Point Values - Not-less-than-or-equal (unordered, non-signaling)
vcmpord_ssd          // Compare Scalar Double-Precision Floating-Point Values - Ordered (signaling)
vcmpeq_ussd          // Compare Scalar Double-Precision Floating-Point Values - Equal (unordered, signaling)
vcmpnge_uqsd         // Compare Scalar Double-Precision Floating-Point Values - Not-greater-than-or-equal (unordered, non-signaling)
vcmpngt_uqsd         // Compare Scalar Double-Precision Floating-Point Values - Not-greater-than (unordered, non-signaling)
vcmpfalse_ossd       // Compare Scalar Double-Precision Floating-Point Values - False (ordered, signaling)
vcmpneq_ossd         // Compare Scalar Double-Precision Floating-Point Values - Not-equal (ordered, signaling)
vcmpge_oqsd          // Compare Scalar Double-Precision Floating-Point Values - Greater-than-or-equal (ordered, non-signaling)
vcmpgt_oqsd          // Compare Scalar Double-Precision Floating-Point Values - Greater-than (ordered, non-signaling)
vcmptrue_ussd        // Compare Scalar Double-Precision Floating-Point Values - True (unordered, signaling)

vcmpeqss             // Scalar Single-FP Compare - Equal (ordered, non-signaling)
vcmpltss             // Scalar Single-FP Compare - Less-than (ordered, signaling)
vcmpless             // Scalar Single-FP Compare - Less-than-or-equal (ordered, signaling)
vcmpunordss          // Scalar Single-FP Compare - Unordered (non-signaling)
vcmpneqss            // Scalar Single-FP Compare - Not-equal (unordered, non-signaling)
vcmpnltss            // Scalar Single-FP Compare - Not-less-than (unordered, signaling)
vcmpnless            // Scalar Single-FP Compare - Not-less-than-or-equal (unordered, signaling)
vcmpordss            // Scalar Single-FP Compare - Ordered (non-signaling)
vcmpeq_uqss          // Scalar Single-FP Compare - Equal (unordered, non-signaling)
vcmpngess            // Scalar Single-FP Compare - Not-greater-than-or-equal (unordered, signaling)
vcmpngtss            // Scalar Single-FP Compare - Not-greater-than (unordered, signaling)
vcmpfalsess          // Scalar Single-FP Compare - False (ordered, non-signaling)
vcmpneq_oqss         // Scalar Single-FP Compare - Not-equal (ordered, non-signaling)
vcmpgess             // Scalar Single-FP Compare - Greater-than-or-equal (ordered, signaling)
vcmpgtss             // Scalar Single-FP Compare - Greater-than (ordered, signaling)
vcmptruess           // Scalar Single-FP Compare - True (unordered, non-signaling)
vcmpeq_osss          // Scalar Single-FP Compare - Equal (ordered, signaling)
vcmplt_oqss          // Scalar Single-FP Compare - Less-than (ordered, non-signaling)
vcmple_oqss          // Scalar Single-FP Compare - Less-than-or-equal (ordered, non-signaling)
vcmpunord_sss        // Scalar Single-FP Compare - Unordered (signaling)
vcmpneq_usss         // Scalar Single-FP Compare - Not-equal (unordered, signaling)
vcmpnlt_uqss         // Scalar Single-FP Compare - Not-less-than (unordered, non-signaling)
vcmpnle_uqss         // Scalar Single-FP Compare - Not-less-than-or-equal (unordered, non-signaling)
vcmpord_sss          // Scalar Single-FP Compare - Ordered (signaling)
vcmpeq_usss          // Scalar Single-FP Compare - Equal (unordered, signaling)
vcmpnge_uqss         // Scalar Single-FP Compare - Not-greater-than-or-equal (unordered, non-signaling)
vcmpngt_uqss         // Scalar Single-FP Compare - Not-greater-than (unordered, non-signaling)
vcmpfalse_osss       // Scalar Single-FP Compare - False (ordered, signaling)
vcmpneq_osss         // Scalar Single-FP Compare - Not-equal (ordered, signaling)
vcmpge_oqss          // Scalar Single-FP Compare - Greater-than-or-equal (ordered, non-signaling)
vcmpgt_oqss          // Scalar Single-FP Compare - Greater-than (ordered, non-signaling)
vcmptrue_usss        // Scalar Single-FP Compare - True (unordered, signaling)

	// AVX-512 instructions

valignd              // Align Doubleword Vectors
valignq              // Align Quadword Vectors
vblendmpd            // Blend Float64 Vectors Using an OpMask Control
vblendmps            // Blend Float32 Vectors Using an OpMask Control
vpblendmb            // Blend Byte Vectors Using an Opmask Control
vpblendmw            // Blend Word Vectors Using an Opmask Control
vpblendmd            // Blend Int32 Vectors Using an OpMask Control
vpblendmq            // Blend Int64 Vectors Using an OpMask Control
vbroadcastf32x2      // Load with Broadcast Floating-Point Data
vbroadcastf32x4      // Load with Broadcast Floating-Point Data
vbroadcastf64x2      // Load with Broadcast Floating-Point Data
vbroadcastf32x8      // Load with Broadcast Floating-Point Data
vbroadcastf64x4      // Load with Broadcast Floating-Point Data
vbroadcasti32x2      // Load Integer and Broadcast
vbroadcasti32x4      // Load Integer and Broadcast
vbroadcasti64x2      // Load Integer and Broadcast
vbroadcasti32x8      // Load Integer and Broadcast
vbroadcasti64x4      // Load Integer and Broadcast
vcompresspd          // Store Sparse Packed Double-Precision Floating-Point Values into Dense Memory
vcompressps          // Store Sparse Packed Single-Precision Floating-Point Values into Dense Memory
vcvtpd2qq            // Convert Packed Double-Precision Floating-Point Values to Packed Quadword Integers
vcvtpd2udq           // Convert Packed Double-Precision Floating-Point Values to Packed Unsigned Doubleword Integers
vcvtpd2uqq           // Convert Packed Double-Precision Floating-Point Values to Packed Unsigned Quadword Integers
vcvtps2udq           // Convert Packed Single-Precision Floating-Point Values to Packed Unsigned Doubleword Integer Values
vcvtps2qq            // Convert Packed Single Precision Floating-Point Values to Packed Singed Quadword Integer Values
vcvtps2uqq           // Convert Packed Single Precision Floating-Point Values to Packed Unsigned Quadword Integer Values
vcvtqq2pd            // Convert Packed Quadword Integers to Packed Double-Precision Floating-Point Values
vcvtqq2ps            // Convert Packed Quadword Integers to Packed Single-Precision Floating-Point Values
vcvtsd2usi           // Convert Scalar Double-Precision Floating-Point Value to Unsigned Doubleword Integer
vcvtss2usi           // Convert Scalar Single-Precision Floating-Point Value to Unsigned Doubleword Integer
vcvttpd2qq           // Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Quadword Integers
vcvttpd2udq          // Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Unsigned Doubleword Integers
vcvttpd2uqq          // Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Unsigned Quadword Integers
vcvttps2udq          // Convert with Truncation Packed Single-Precision Floating-Point Values to Packed Unsigned Doubleword Integer Values
vcvttps2qq           // Convert with Truncation Packed Single Precision Floating-Point Values to Packed Singed Quadword Integer Values
vcvttps2uqq          // Convert with Truncation Packed Single Precision Floating-Point Values to Packed Unsigned Quadword Integer Values
vcvttsd2usi          // Convert with Truncation Scalar Double-Precision Floating-Point Value to Unsigned Integer
vcvttss2usi          // Convert with Truncation Scalar Single-Precision Floating-Point Value to Unsigned Integer
vcvtudq2pd           // Convert Packed Unsigned Doubleword Integers to Packed Double-Precision Floating-Point Values
vcvtudq2ps           // Convert Packed Unsigned Doubleword Integers to Packed Single-Precision Floating-Point Values
vcvtuqq2pd           // Convert Packed Unsigned Quadword Integers to Packed Double-Precision Floating-Point Values
vcvtuqq2ps           // Convert Packed Unsigned Quadword Integers to Packed Single-Precision Floating-Point Values
vcvtusi2sd           // Convert Unsigned Integer to Scalar Double-Precision Floating-Point Value
vcvtusi2ss           // Convert Unsigned Integer to Scalar Single-Precision Floating-Point Value
vdbpsadbw            // Double Block Packed Sum-Absolute-Differences (SAD) on Unsigned Bytes
vexpandpd            // Load Sparse Packed Double-Precision Floating-Point Values from Dense Memory
vexpandps            // Load Sparse Packed Single-Precision Floating-Point Values from Dense Memory
vextractf32x4        // Extract Packed Floating-Point Values
vextractf64x2        // Extract Packed Floating-Point Values
vextractf32x8        // Extract Packed Floating-Point Values
vextractf64x4        // Extract Packed Floating-Point Values
vextracti32x4        // Extract packed Integer Values
vextracti64x2        // Extract packed Integer Values
vextracti32x8        // Extract packed Integer Values
vextracti64x4        // Extract packed Integer Values
vfixupimmpd          // Fix Up Special Packed Float64 Values
vfixupimmps          // Fix Up Special Packed Float32 Values
vfixupimmsd          // Fix Up Special Scalar Float64 Value
vfixupimmss          // Fix Up Special Scalar Float32 Value
vfpclasspd           // Tests Types Of a Packed Float64 Values
vfpclassps           // Tests Types Of a Packed Float32 Values
vfpclasssd           // Tests Types Of a Scalar Float64 Values
vfpclassss           // Tests Types Of a Scalar Float32 Values
vgetexppd            // Convert Exponents of Packed DP FP Values to DP FP Values
vgetexpps            // Convert Exponents of Packed SP FP Values to SP FP Values
vgetexpsd            // Convert Exponents of Scalar DP FP Values to DP FP Value
vgetexpss            // Convert Exponents of Scalar SP FP Values to SP FP Value
vgetmantpd           // Extract Float64 Vector of Normalized Mantissas from Float64 Vector
vgetmantps           // Extract Float32 Vector of Normalized Mantissas from Float32 Vector
vgetmantsd           // Extract Float64 of Normalized Mantissas from Float64 Scalar
vgetmantss           // Extract Float32 Vector of Normalized Mantissa from Float32 Vector
vinsertf32x4         // Insert Packed Floating-Point Values
vinsertf64x2         // Insert Packed Floating-Point Values
vinsertf32x8         // Insert Packed Floating-Point Values
vinsertf64x4         // Insert Packed Floating-Point Values
vinserti32x4         // Insert Packed Integer Values
vinserti64x2         // Insert Packed Integer Values
vinserti32x8         // Insert Packed Integer Values
vinserti64x4         // Insert Packed Integer Values
vmovdqa32            // Move Aligned Packed Integer Values
vmovdqa64            // Move Aligned Packed Integer Values
vmovdqu8             // Move Unaligned Packed Integer Values
vmovdqu16            // Move Unaligned Packed Integer Values
vmovdqu32            // Move Unaligned Packed Integer Values
vmovdqu64            // Move Unaligned Packed Integer Values
vpabsq               // Packed Absolute Value
vpandd               // Logical AND
vpandq               // Logical AND
vpandnd              // Logical AND NOT
vpandnq              // Logical AND NOT
vpbroadcastmb2q      // Broadcast Mask to Vector Register
vpbroadcastmw2d      // Broadcast Mask to Vector Register
vpcmpb               // Compare Packed Byte Values Into Mask
vpcmpub              // Compare Packed Byte Values Into Mask
vpcmpd               // Compare Packed Integer Values into Mask
vpcmpud              // Compare Packed Integer Values into Mask
vpcmpq               // Compare Packed Integer Values into Mask
vpcmpuq              // Compare Packed Integer Values into Mask
vpcmpw               // Compare Packed Word Values Into Mask
vpcmpuw              // Compare Packed Word Values Into Mask
vpcompressd          // Store Sparse Packed Doubleword Integer Values into Dense Memory/Register
vpcompressq          // Store Sparse Packed Quadword Integer Values into Dense Memory/Register
vpconflictd          // Detect Conflicts Within a Vector of Packed Dword Values into Dense Memory/Register
vpconflictq          // Detect Conflicts Within a Vector of Packed Qword Values into Dense Memory/Register
vpermb               // Permute Packed Bytes Elements
vpermw               // Permute Packed Words Elements
vpermi2b             // Full Permute of Bytes From Two Tables Overwriting the Index
vpermi2w             // Full Permute From Two Tables Overwriting the Index
vpermi2d             // Full Permute From Two Tables Overwriting the Index
vpermi2q             // Full Permute From Two Tables Overwriting the Index
vpermi2ps            // Full Permute From Two Tables Overwriting the Index
vpermi2pd            // Full Permute From Two Tables Overwriting the Index
vpermt2b             // Full Permute of Bytes From Two Tables Overwriting a Table
vpermt2w             // Full Permute from Two Tables Overwriting one Table
vpermt2d             // Full Permute from Two Tables Overwriting one Table
vpermt2q             // Full Permute from Two Tables Overwriting one Table
vpermt2ps            // Full Permute from Two Tables Overwriting one Table
vpermt2pd            // Full Permute from Two Tables Overwriting one Table
vpexpandd            // Load Sparse Packed Doubleword Integer Values from Dense Memory/Register
vpexpandq            // Load Sparse Packed Quadword Integer Values from Dense Memory/Register
vplzcntd             // Count the Number of Leading Zero Bits for Packed Dword Values
vplzcntq             // Count the Number of Leading Zero Bits for Packed Qword Values
vpmadd52luq          // Packed Multiply of Unsigned 52-bit Integers and Add the Low 52-bit Products to Qword Accumulators
vpmadd52huq          // Packed Multiply of Unsigned 52-bit Unsigned Integers and Add High 52-bit Products to 64-bit Accumulators
vpmaxsq              // Maximum of Packed Signed Integers
vpmaxuq              // Maximum of Packed Unsigned Integers
vpminsq              // Minimum of Packed Signed Integers
vpminuq              // Minimum of Packed Unsigned Integers
vpmovm2b             // Convert a Mask Register to a Vector Register
vpmovm2w             // Convert a Mask Register to a Vector Register
vpmovm2d             // Convert a Mask Register to a Vector Register
vpmovm2q             // Convert a Mask Register to a Vector Register
vpmovb2m             // Convert a Vector Register to a Mask
vpmovw2m             // Convert a Vector Register to a Mask
vpmovd2m             // Convert a Vector Register to a Mask
vpmovq2m             // Convert a Vector Register to a Mask
vpmovqb              // Down Convert QWord to Byte
vpmovsqb             // Down Convert QWord to Byte
vpmovusqb            // Down Convert QWord to Byte
vpmovqw              // Down Convert QWord to Word
vpmovsqw             // Down Convert QWord to Word
vpmovusqw            // Down Convert QWord to Word
vpmovqd              // Down Convert QWord to DWord
vpmovsqd             // Down Convert QWord to DWord
vpmovusqd            // Down Convert QWord to DWord
vpmovdb              // Down Convert DWord to Byte
vpmovsdb             // Down Convert DWord to Byte
vpmovusdb            // Down Convert DWord to Byte
vpmovdw              // Down Convert DWord to Word
vpmovsdw             // Down Convert DWord to Word
vpmovusdw            // Down Convert DWord to Word
vpmovwb              // Down Convert Word to Byte
vpmovswb             // Down Convert Word to Byte
vpmovuswb            // Down Convert Word to Byte
vpmullq              // Multiply Packed Integers and Store Low Result
vpmultishiftqb       // Select Packed Unaligned Bytes from Quadword Sources
vpord                // Bitwise Logical Or
vporq                // Bitwise Logical Or
vprold               // Bit Rotate Left
vprolvd              // Bit Rotate Left
vprolq               // Bit Rotate Left
vprolvq              // Bit Rotate Left
vprord               // Bit Rotate Right
vprorvd              // Bit Rotate Right
vprorq               // Bit Rotate Right
vprorvq              // Bit Rotate Right
vpscatterdd          // Scatter Packed Dword with Signed Dword
vpscatterdq          // Scatter Packed Qword with Signed Qword Indices
vpscatterqd          // Scatter Packed Dword with Signed Dword
vpscatterqq          // Scatter Packed Qword with Signed Qword Indices
vpsraq               // Bit Shift Arithmetic Right
vpsllvw              // Variable Bit Shift Left Logical
vpsrlvw              // Variable Bit Shift Right Logical
vptestnmb            // Logical NAND and Set
vptestnmw            // Logical NAND and Set
vptestnmd            // Logical NAND and Set
vptestnmq            // Logical NAND and Set
vshuff32x4           // Shuffle Packed Values at 128-bit Granularity
vshuff64x2           // Shuffle Packed Values at 128-bit Granularity
vshufi32x4           // Shuffle Packed Values at 128-bit Granularity
vshufi64x2           // Shuffle Packed Values at 128-bit Granularity
vpternlogd           // Bitwise Ternary Logic
vpternlogq           // Bitwise Ternary Logic
vptestmb             // Logical AND and Set Mask
vptestmw             // Logical AND and Set Mask
vptestmd             // Logical AND and Set Mask
vptestmq             // Logical AND and Set Mask
vpsravw              // Variable Bit Shift Right Arithmetic
vpsravq              // Variable Bit Shift Right Arithmetic
vpxord               // Exclusive Or
vpxorq               // Exclusive Or
vrangepd             // Range Restriction Calculation For Packed Pairs of Float64 Values
vrangeps             // Range Restriction Calculation For Packed Pairs of Float32 Values
vrangesd             // Range Restriction Calculation From a pair of Scalar Float64 Values
vrangess             // Range Restriction Calculation From a Pair of Scalar Float32 Values
vrcp14pd             // Compute Approximate Reciprocals of Packed Float64 Values
vrcp14sd             // Compute Approximate Reciprocal of Scalar Float64 Value
vrcp14ps             // Compute Approximate Reciprocals of Packed Float32 Values
vrcp14ss             // Compute Approximate Reciprocal of Scalar Float32 Value
vreducepd            // Perform Reduction Transformation on Packed Float64 Values
vreducesd            // Perform a Reduction Transformation on a Scalar Float64 Value
vreduceps            // Perform Reduction Transformation on Packed Float32 Values
vreducess            // Perform a Reduction Transformation on a Scalar Float32 Value
vrndscalepd          // Round Packed Float64 Values To Include A Given Number Of Fraction Bits
vrndscalesd          // Round Scalar Float64 Value To Include A Given Number Of Fraction Bits
vrndscaleps          // Round Packed Float32 Values To Include A Given Number Of Fraction Bits
vrndscaless          // Round Scalar Float32 Value To Include A Given Number Of Fraction Bits
vrsqrt14pd           // Compute Approximate Reciprocals of Square Roots of Packed Float64 Values
vrsqrt14sd           // Compute Approximate Reciprocal of Square Root of Scalar Float64 Value
vrsqrt14ps           // Compute Approximate Reciprocals of Square Roots of Packed Float32 Values
vrsqrt14ss           // Compute Approximate Reciprocal of Square Root of Scalar Float32 Value
vscalefpd            // Scale Packed Float64 Values With Float64 Values
vscalefsd            // Scale Scalar Float64 Values With Float64 Values
vscalefps            // Scale Packed Float32 Values With Float32 Values
vscalefss            // Scale Scalar Float32 Value With Float32 Value
vscatterdps          // Scatter Packed Single, Packed Double with Signed Dword and Qword Indices
vscatterdpd          // Scatter Packed Single, Packed Double with Signed Dword and Qword Indices
vscatterqps          // Scatter Packed Single, Packed Double with Signed Dword and Qword Indices
vscatterqpd          // Scatter Packed Single, Packed Double with Signed Dword and Qword Indices

vexp2pd              // Approximation to the Exponential 2^x of Packed Double-Precision Floating-Point Values with Less Than 2^-23 Relative Error
vexp2ps              // Approximation to the Exponential 2^x of Packed Single-Precision Floating-Point Values with Less Than 2^-23 Relative Error
vrcp28pd             // Approximation to the Reciprocal of Packed Double-Precision Floating-Point Values with Less Than 2^-28 Relative Error
vrcp28sd             // Approximation to the Reciprocal of Scalar Double-Precision Floating-Point Value with Less Than 2^-28 Relative Error
vrcp28ps             // Approximation to the Reciprocal of Packed Single-Precision Floating-Point Values with Less Than 2^-28 Relative Error
vrcp28ss             // Approximation to the Reciprocal of Scalar Single-Precision Floating-Point Value with Less Than 2^-28 Relative Error
vrsqrt28pd           // Approximation to the Reciprocal Square Root of Packed Double-Precision Floating-Point Values with Less Than 2^-28 Relative Error
vrsqrt28sd           // Approximation to the Reciprocal Square Root of Scalar Double-Precision Floating-Point Value with Less Than 2^-28 Relative Error
vrsqrt28ps           // Approximation to the Reciprocal Square Root of Packed Single-Precision Floating-Point Values with Less Than 2^-28 Relative Error
vrsqrt28ss           // Approximation to the Reciprocal Square Root of Scalar Single-Precision Floating-Point Value with Less Than 2^-28 Relative Error

vgatherpf0dps        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint
vgatherpf0qps        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint
vgatherpf0dpd        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint
vgatherpf0qpd        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint
vgatherpf1dps        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint
vgatherpf1qps        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint
vgatherpf1dpd        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint
vgatherpf1qpd        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint
vscatterpf0dps       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint with Intent to Write
vscatterpf0qps       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint with Intent to Write
vscatterpf0dpd       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint with Intent to Write
vscatterpf0qpd       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint with Intent to Write
vscatterpf1dps       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint with Intent to Write
vscatterpf1qps       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint with Intent to Write
vscatterpf1dpd       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint with Intent to Write
vscatterpf1qpd       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint with Intent to Write

	// AVX-512 comparison pseudo-ops

vpcmpltd             // Compare Packed Integer Values into Mask
vpcmpled             // Compare Packed Integer Values into Mask
vpcmpneqd            // Compare Packed Integer Values into Mask
vpcmpnltd            // Compare Packed Integer Values into Mask
vpcmpnled            // Compare Packed Integer Values into Mask

vpcmpequd            // Compare Packed Integer Values into Mask
vpcmpltud            // Compare Packed Integer Values into Mask
vpcmpleud            // Compare Packed Integer Values into Mask
vpcmpnequd           // Compare Packed Integer Values into Mask
vpcmpnltud           // Compare Packed Integer Values into Mask
vpcmpnleud           // Compare Packed Integer Values into Mask

vpcmpltq             // Compare Packed Integer Values into Mask
vpcmpleq             // Compare Packed Integer Values into Mask
vpcmpneqq            // Compare Packed Integer Values into Mask
vpcmpnltq            // Compare Packed Integer Values into Mask
vpcmpnleq            // Compare Packed Integer Values into Mask

vpcmpequq            // Compare Packed Integer Values into Mask
vpcmpltuq            // Compare Packed Integer Values into Mask
vpcmpleuq            // Compare Packed Integer Values into Mask
vpcmpnequq           // Compare Packed Integer Values into Mask
vpcmpnltuq           // Compare Packed Integer Values into Mask
vpcmpnleuq           // Compare Packed Integer Values into Mask

	// Opmask instructions

kaddw                // ADD Two Masks
kaddb                // ADD Two Masks
kaddq                // ADD Two Masks
kaddd                // ADD Two Masks
kandw                // Bitwise Logical AND Masks
kandb                // Bitwise Logical AND Masks
kandq                // Bitwise Logical AND Masks
kandd                // Bitwise Logical AND Masks
kandnw               // Bitwise Logical AND NOT Masks
kandnb               // Bitwise Logical AND NOT Masks
kandnq               // Bitwise Logical AND NOT Masks
kandnd               // Bitwise Logical AND NOT Masks
kmovw                // Move from and to Mask Registers
kmovb                // Move from and to Mask Registers
kmovq                // Move from and to Mask Registers
kmovd                // Move from and to Mask Registers
kunpckbw             // Unpack for Mask Registers
kunpckwd             // Unpack for Mask Registers
kunpckdq             // Unpack for Mask Registers
knotw                // NOT Mask Register
knotb                // NOT Mask Register
knotq                // NOT Mask Register
knotd                // NOT Mask Register
korw                 // Bitwise Logical OR Masks
korb                 // Bitwise Logical OR Masks
korq                 // Bitwise Logical OR Masks
kord                 // Bitwise Logical OR Masks
kortestw             // OR Masks And Set Flags
kortestb             // OR Masks And Set Flags
kortestq             // OR Masks And Set Flags
kortestd             // OR Masks And Set Flags
kshiftlw             // Shift Left Mask Registers
kshiftlb             // Shift Left Mask Registers
kshiftlq             // Shift Left Mask Registers
kshiftld             // Shift Left Mask Registers
kshiftrw             // Shift Right Mask Registers
kshiftrb             // Shift Right Mask Registers
kshiftrq             // Shift Right Mask Registers
kshiftrd             // Shift Right Mask Registers
kxnorw               // Bitwise Logical XNOR Masks
kxnorb               // Bitwise Logical XNOR Masks
kxnorq               // Bitwise Logical XNOR Masks
kxnord               // Bitwise Logical XNOR Masks
ktestw               // Packed Bit Test Masks and Set Flags
ktestb               // Packed Bit Test Masks and Set Flags
ktestq               // Packed Bit Test Masks and Set Flags
ktestd               // Packed Bit Test Masks and Set Flags
kxorw                // Bitwise Logical XOR Masks
kxorb                // Bitwise Logical XOR Masks
kxorq                // Bitwise Logical XOR Masks
kxord                // Bitwise Logical XOR Masks

	// SHA Extensions

sha1rnds4            // Perform Four Rounds of SHA1 Operation
sha1nexte            // Calculate SHA1 State Variable E after Four Rounds
sha1msg1             // Perform an Intermediate Calculation for the Next Four SHA1 Message Dwords
sha1msg2             // Perform a Final Calculation for the Next Four SHA1 Message Dwords
sha256rnds2          // Perform Two Rounds of SHA256 Operation
sha256msg1           // Perform an Intermediate Calculation for the Next Four SHA256 Message Dwords
sha256msg2           // Perform a Final Calculation for the Next Four SHA256 Message Dwords

	// Intel Software Guard Extensions

encls                // Execute an Enclave System Function of Specified Leaf Number
enclu                // Execute an Enclave User Function of Specified Leaf Number

	// AMD XOP

vfrczpd              // Extract Fraction Packed Double-Precision Floating-Point
vfrczps              // Extract Fraction Packed Single-Precision Floating-Point
vfrczsd              // Extract Fraction Scalar Double-Precision Floating-Point
vfrczss              // Extract Fraction Scalar Single-Precision Floating Point
vpcmov               // Vector Conditional Moves
vpcomb               // Compare Vector Signed Bytes
vpcomd               // Compare Vector Signed Doublewords
vpcomq               // Compare Vector Signed Quadwords
vpcomub              // Compare Vector Unsigned Bytes
vpcomud              // Compare Vector Unsigned Doublewords
vpcomuq              // Compare Vector Unsigned Quadwords
vpcomuw              // Compare Vector Unsigned Words
vpcomw               // Compare Vector Signed Words
vpermil2pd           // Permute Two-Source Double-Precision Floating-Point Values
vpermil2ps           // Permute Two-Source Single-Precision Floating-Point Values
vphaddbd             // Packed Horizontal Add Signed Byte to Signed Doubleword
vphaddbq             // Packed Horizontal Add Signed Byte to Signed Quadword
vphaddbw             // Packed Horizontal Add Signed Byte to Signed Word
vphadddq             // Packed Horizontal Add Signed Doubleword to Signed Quadword
vphaddubd            // Packed Horizontal Add Unsigned Byte to Doubleword
vphaddubq            // Packed Horizontal Add Unsigned Byte to Quadword
vphaddubw            // Packed Horizontal Add Unsigned Byte to Word
vphaddudq            // Packed Horizontal Add Unsigned Doubleword to Quadword
vphadduwd            // Packed Horizontal Add Unsigned Word to Doubleword
vphadduwq            // Packed Horizontal Add Unsigned Word to Quadword
vphaddwd             // Packed Horizontal Add Signed Word to Signed Doubleword
vphaddwq             // Packed Horizontal Add Signed Word to Signed Quadword
vphsubbw             // Packed Horizontal Subtract Signed Byte to Signed Word
vphsubdq             // Packed Horizontal Subtract Signed Doubleword to Signed Quadword
vphsubwd             // Packed Horizontal Subtract Signed Word to Signed Doubleword
vpmacsdd             // Packed Multiply Accumulate Signed Doubleword to Signed Doubleword
vpmacsdqh            // Packed Multiply Accumulate Signed High Doubleword to Signed Quadword
vpmacsdql            // Packed Multiply Accumulate Signed Low Doubleword to Signed Quadword
vpmacssdd            // Packed Multiply Accumulate Signed Doubleword to Signed Doubleword with Saturation
vpmacssdqh           // Packed Multiply Accumulate Signed High Doubleword to Signed Quadword with Saturation
vpmacssdql           // Packed Multiply Accumulate Signed Low Doubleword to Signed Quadword with Saturation
vpmacsswd            // Packed Multiply Accumulate Signed Word to Signed Doubleword with Saturation
vpmacssww            // Packed Multiply Accumulate Signed Word to Signed Word with Saturation
vpmacswd             // Packed Multiply Accumulate Signed Word to Signed Doubleword
vpmacsww             // Packed Multiply Accumulate Signed Word to Signed Word
vpmadcsswd           // Packed Multiply, Add and Accumulate Signed Word to Signed Doubleword with Saturation
vpmadcswd            // Packed Multiply Add and Accumulate Signed Word to Signed Doubleword
vpperm               // Packed Permute Bytes
vprotb               // Packed Rotate Bytes
vprotd               // Packed Rotate Doublewords
vprotq               // Packed Rotate Quadwords
vprotw               // Packed Rotate Words
vpshab               // Packed Shift Arithmetic Bytes
vpshad               // Packed Shift Arithmetic Doublewords
vpshaq               // Packed Shift Arithmetic Quadwords
vpshaw               // Packed Shift Arithmetic Words
vpshlb               // Packed Shift Logical Bytes
vpshld               // Packed Shift Logical Doublewords
vpshlq               // Packed Shift Logical Quadwords
vpshlw               // Packed Shift Logical Words

	// AMP XOP comparison pseudo-ops

vpcomltb             // Compare Vector Signed Bytes
vpcomleb             // Compare Vector Signed Bytes
vpcomgtb             // Compare Vector Signed Bytes
vpcomgeb             // Compare Vector Signed Bytes
vpcomeqb             // Compare Vector Signed Bytes
vpcomneqb            // Compare Vector Signed Bytes
vpcomfalseb          // Compare Vector Signed Bytes
vpcomtrueb           // Compare Vector Signed Bytes

vpcomltw             // Compare Vector Signed Words
vpcomlew             // Compare Vector Signed Words
vpcomgtw             // Compare Vector Signed Words
vpcomgew             // Compare Vector Signed Words
vpcomeqw             // Compare Vector Signed Words
vpcomneqw            // Compare Vector Signed Words
vpcomfalsew          // Compare Vector Signed Words
vpcomtruew           // Compare Vector Signed Words

vpcomltd             // Compare Vector Signed Doublewords
vpcomled             // Compare Vector Signed Doublewords
vpcomgtd             // Compare Vector Signed Doublewords
vpcomged             // Compare Vector Signed Doublewords
vpcomeqd             // Compare Vector Signed Doublewords
vpcomneqd            // Compare Vector Signed Doublewords
vpcomfalsed          // Compare Vector Signed Doublewords
vpcomtrued           // Compare Vector Signed Doublewords

vpcomltq             // Compare Vector Signed Quadwords
vpcomleq             // Compare Vector Signed Quadwords
vpcomgtq             // Compare Vector Signed Quadwords
vpcomgeq             // Compare Vector Signed Quadwords
vpcomeqq             // Compare Vector Signed Quadwords
vpcomneqq            // Compare Vector Signed Quadwords
vpcomfalseq          // Compare Vector Signed Quadwords
vpcomtrueq           // Compare Vector Signed Quadwords

vpcomltub            // Compare Vector Unsigned Bytes
vpcomleub            // Compare Vector Unsigned Bytes
vpcomgtub            // Compare Vector Unsigned Bytes
vpcomgeub            // Compare Vector Unsigned Bytes
vpcomequb            // Compare Vector Unsigned Bytes
vpcomnequb           // Compare Vector Unsigned Bytes
vpcomfalseub         // Compare Vector Unsigned Bytes
vpcomtrueub          // Compare Vector Unsigned Bytes

vpcomltuw            // Compare Vector Unsigned Words
vpcomleuw            // Compare Vector Unsigned Words
vpcomgtuw            // Compare Vector Unsigned Words
vpcomgeuw            // Compare Vector Unsigned Words
vpcomequw            // Compare Vector Unsigned Words
vpcomnequw           // Compare Vector Unsigned Words
vpcomfalseuw         // Compare Vector Unsigned Words
vpcomtrueuw          // Compare Vector Unsigned Words

vpcomltud            // Compare Vector Unsigned Doublewords
vpcomleud            // Compare Vector Unsigned Doublewords
vpcomgtud            // Compare Vector Unsigned Doublewords
vpcomgeud            // Compare Vector Unsigned Doublewords
vpcomequd            // Compare Vector Unsigned Doublewords
vpcomnequd           // Compare Vector Unsigned Doublewords
vpcomfalseud         // Compare Vector Unsigned Doublewords
vpcomtrueud          // Compare Vector Unsigned Doublewords

vpcomltuq            // Compare Vector Unsigned Quadwords
vpcomleuq            // Compare Vector Unsigned Quadwords
vpcomgtuq            // Compare Vector Unsigned Quadwords
vpcomgeuq            // Compare Vector Unsigned Quadwords
vpcomequq            // Compare Vector Unsigned Quadwords
vpcomnequq           // Compare Vector Unsigned Quadwords
vpcomfalseuq         // Compare Vector Unsigned Quadwords
vpcomtrueuq          // Compare Vector Unsigned Quadwords

	// AMD Excavator

monitorx             // Setup Monitor Address
mwaitx               // Monitor Wait with Timeout

	// AMD Zen

clzero               // Zero out 64 byte cache

	// Intel Processor Trace

ptwrite              // Write Data to a Processor Trace Packet

	// new Intel AVX-512 instructions (December 2016)

v4fmaddps            // Packed Single-Precision Floating-Point Fused Multiply-Add (4-iterations)
v4fnmaddps           // Packed Single-Precision Floating-Point Fused Multiply-Add (4-iterations)
v4fmaddss            // Scalar Single-Precision Floating-Point Fused Multiply-Add (4-iterations)
v4fnmaddss           // Scalar Single-Precision Floating-Point Fused Multiply-Add (4-iterations)
vp4dpwssd            // Dot Product of Signed Words with Dword Accumulation (4-iterations)
vp4dpwssds           // Dot Product of Signed Words with Dword Accumulation and Saturation (4-iterations)
vpopcntd             // Return the Count of Number of Bits Set to 1 in DWORD
vpopcntq             // Return the Count of Number of Bits Set to 1 in QWORD

	// Read Processor ID

rdpid                // Read Processor ID

	// Invoke VM function

vmfunc               // Invoke VM function

	// Control-flow Enforcement

incsspd              // Increment Shadow Stack Pointer (by 4)
incsspq              // Increment Shadow Stack Pointer (by 8)
rdsspd               // Read (low 32 bits of) Shadow Stack Pointer
rdsspq               // Read Shadow Stack Pointer
saveprevssp          // Save Previous Shadow Stack Pointer
rstorssp             // Restore saved Shadow Stack Pointer
wrssd                // Write (4 bytes) to shadow stack
wrssq                // Write (8 bytes) to shadow stack
wrussd               // Write (4 bytes) to User Shadow Stack
wrussq               // Write (8 bytes) to User Shadow Stack
setssbsy             // Mark Shadow Stack Busy
clrssbsy             // Clear Shadow Stack Busy Flag
endbr64              // Terminate an Indirect Branch in 64-bit Mode
endbr32              // Terminate an Indirect Branch in 32-bit and Compatibility Mode
