aaa=ascii adjust after addition
aad=ascii adjust ax before division
aam=ascii adjust ax after multiply
aas=ascii adjust al after subtraction
adc=add with carry
adcx=unsigned integer addition of two operands with carry flag
add=adds src and dst, stores result on dst
addpd=add packed double-fp values
addps=add packed single-fp values
addsd=add scalar double-fp values
addss=add scalar single-fp values
addsubpd=packed double-fp add/subtract
addsubps=packed single-fp add/subtract
adox=unsigned integer addition of two operands with overflow flag
aesdec=perform one round of an AES decryption flow
aesdeclast=perform the last round of an AES decryption flow
aesenc=perform one round of an AES encryption flow
aesenclast=perform the last round of an AES encryption flow
aesimc=assist in aes Inverse Mix Columns
aeskeygenassist=assist in AES round key generation
and=binary and operation between src and dst, stores result on dst
andn=logical and not
andnpd=bitwise logical and not of packed double-fp values
andnps=bitwise logical and not of packed single-fp values
andpd=bitwise logical and of packed double-fp values
andps=bitwise logical and of packed single-fp values
arpl=adjust rpl field of segment selector
bextr=bit field extract
blendpd=blend packed double-fp values
blendps=blend packed single-fp values
blendvpd=variable blend packed double-fp values
blendvps=variable blend packed single-fp values
blsi=extract lowest set isolated bit
blsmsk=get mask up to lowest set bit
blsr=reset lowest set bit
bndcl=check lower bound
bndcn=check upper bound
bndcu=check upper bound
bndldx=load extended bounds using address translation
bndmk=make bounds
bndmov=move bounds
bndstx=store extended bounds using address translation
bound=check array index against bounds
bsf=bit scan forward
bsr=bit scan reverse
bswap=byte swap
bt=bit test
btc=bit test and complement
btr=bit test and reset
bts=bit test and set
bzhi=zero high bits starting with specified bit position
call=calls a subroutine, push eip into the stack (esp)
cbw=convert byte to word
cdq=sign extends eax into edx (convert doubleword to quadword)
cdqe=sign extend eax into rax
clac=clear ac flag in eflags register
clc=clear carry flag
cld=clear direction flag
clflush=flush cache line
clflushopt=flush cache line optimized
cli=clear interrupt flag
clts=clear task-switched flag in cr0
cmc=complement carry flag
cmova=conditional move - above/not below nor equal (cf=0 and zf=0)
cmovae=conditional move - above or equal/not below/not carry (cf=0)
cmovb=conditional move - below/not above nor equal/carry (cf=1)
cmovbe=conditional move - below or equal/not above (cf=1 or zf=1)
cmovc=conditional move - carry/below/not above or equal (cf=1)
cmove=conditional move - equal/zero (zf=1)
cmovg=conditional move - greater/not less nor equal (zf=0 and sf=of)
cmovge=conditional move - greater or equal/not less (sf=of)
cmovl=conditional move - less/not greater nor equal (sf!=of)
cmovle=conditional move - less or equal/not greater (zf=1 or sf!=of)
cmovna=conditional move - not above/below or equal (cf=1 or zf=1)
cmovnae=conditional move - not above nor equal/below/carry (cf=1)
cmovnb=conditional move - not below/above or equal/not carry (cf=0)
cmp=compare two operands
cmppd=compare packed double-fp values
cmpps=compare packed single-fp values
cmps=compare string operands
cmpsb=cmp DS:[esi], (byte)ES:[edi] (esi++, edi++)
cmpsd=cmp DS:[esi], (dword)ES:[edi] (esi+=4, edi+=4)/compare scalar double-fp values
cmpsq=cmp DS:[rsi], (qword)ES:[rdi] (rsi+=8, rdi+=8)
cmpss=compare scalar single-fp values
cmpsw=cmp DS:[esi], (word)ES:[edi] (esi+=2, edi+=2)
cmpxchg=compare and exchange
cmpxchg16b=compare and exchange bytes
cmpxchg8b=compare and exchange bytes
comisd=compare scalar ordered double-fp values and set eflags
comiss=compare scalar ordered single-fp values and set eflags
cpuid=cpu identification
cqo=sign extends rax into rdx (convert quadword to double-quadword)
crc32=accumulate crc32 value
cvtdq2pd=convert packed dw integers to double-fp values
cvtdq2ps=convert packed dw integers to single-fp values
cvtpd2dq=convert packed double-fp values to dw integers
cvtpd2pi=convert packed double-fp values to dw integers
cvtpd2ps=convert packed double-fp values to single-fp values
cvtpi2pd=convert packed dw integers to double-fp values
cvtpi2ps=convert packed dw integers to single-fp values
cvtps2dq=convert packed single-fp values to dw integers
cvtps2pd=convert packed single-fp values to double-fp values
cvtps2pi=convert packed single-fp values to dw integers
cvtsd2si=convert scalar double-fp value to dw integer
cvtsd2ss=convert scalar double-fp value to scalar single-fp value
cvtsi2sd=convert dw integer to scalar double-fp value
cvtsi2ss=convert dw integer to scalar single-fp value
cvtss2sd=convert scalar single-fp value to scalar double-fp value
cvtss2si=convert scalar single-fp value to dw integer
cvttpd2dq=convert with trunc. packed double-fp values to dw integers
cvttpd2pi=convert with trunc. packed double-fp values to dw integers
cvttps2dq=convert with trunc. packed single-fp values to dw integers
cvttps2pi=convert with trunc. packed single-fp values to dw integers
cvttsd2si=conv. with trunc. scalar double-fp value to signed dw int
cvttss2si=convert with trunc. scalar single-fp value to dw integer
cwd=convert word to doubleword
cwde=convert word to doubleword
daa=decimal adjust al after addition
das=decimal adjust al after subtraction
dec=decrement by 1
div=unsigned divide
divpd=divide packed double-fp values
divps=divide packed single-fp values
divsd=divide scalar double-fp values
divss=divide scalar single-fp values
dppd=dot product of packed double-fp values
dpps=dot product of packed single-fp values
emms=empty mmx technology state
enter=alias for push ebp; mov ebp, esp
extractps=extract packed single-fp value
f2xm1=compute pow(2,x) - 1
fabs=absolute value
fadd=floating point add
faddp=floating point add and pop
fbld=load binary coded decimal
fbstp=store binary coded decimal integer and pop
fchs=change sign
fclex=clear exceptions
fcmovb=fp conditional move - below (cf=1)
fcmovbe=fp conditional move - below or equal (cf=1 or zf=1)
fcmove=fp conditional move - equal (zf=1)
fcmovnb=fp conditional move - not below (cf=0)
fcmovnbe=fp conditional move - not below or equal (cf=0 and zf=0)
fcmovne=fp conditional move - not equal (zf=0)
fcmovu=fp conditional move - unordered (pf=1)
fcom=floating point compare
fcomi=compare floating point values and set eflags
fcomip=compare floating point values and set eflags and pop
fcomp=floating point compare and pop
fcompp=floating point compare and pop twice
fcos=floating point cosine
fdecstp=decrement floating point stack pointer
fdiv=floating point divide
fdivp=floting point divide and pop
fdivr=floating point divide reversed
fdivrp=floating point reverse divide and pop
ffree=free floating-point register
fiadd=integer add
ficom=integer compare
ficomp=integer compare and pop
fidiv=integer divide
fidivr=integer divide reserved
fild=load integer
fimul=integer multiply
fincstp=increment floating-point stack pointer
finit=initialize fpu (floating-point unit)
fist=store integer
fistp=store integer and pop
fisttp=store integer with truncation and pop
fisub=integer substract
fisubr=integer susbtract reversed
fld=load floating point value
fld1=load constant onto stack +1.0f
fldcw=load x87 fpu control word
fldenv=load x87 fpu environment
fldl2e=load constant onto stack: logarithm base 2 (e)
fldl2t=load constant onto stack: logarithm base 2 (10)
fldlg2=load constant onto stack: logarithm base 10 (2)
fldln2=load constant onto stack: natural logarithm (2)
fldpi=load constant onto stack: pi (3.141592...)
fldz=load constant onto stack 0.0f
fmul=floating point multiply
fmulp=floating point multiply and pop
fnclex=clear exceptions
fninit=initialize fpu (floating-point unit)
fnop=no operation
fnsave=store x87 fpu state
fnstcw=store x87 fpu control word
fnstenv=store x87 fpu environment
fnstsw=store x87 fpu status word
fpatan=partial arctangent and pop
fprem=partial remainder (for compatibility with i8087 and i287)
fprem1=ieee partial remainder
fptan=partial tangent
frndint=round to integer
frstor=restore x87 fpu state
fsave=store x87 fpu state
fscale=scale
fsin=sine
fsincos=sine and cosine
fsqrt=square root
fst=store floating point value
fstcw=store x87 fpu control word
fstenv=store x87 fpu environment
fstp=store floating point value and pop
fstsw=store x87 fpu status word
fsub=floating point subtract
fsubp=subtract and pop
fsubr=reverse subtract
fsubrp=reverse subtract and pop
ftst=test
fucom=unordered compare floating point values
fucomi=unordered compare floating point values and set eflags
fucomip=unordered compare floating point values and set eflags and pop
fucomp=unordered compare floating point values and pop
fucompp=unordered compare floating point values and pop twice
fwait=check pending unmasked floating-point exceptions
fxam=examine
fxch=exchange register contents
fxrstor=restore x87 fpu, mmx, xmm, and mxcsr state
fxsave=save x87 fpu, mmx, xmm, and mxcsr state
fxtract=extract exponent and significand
fyl2x=compute y times log2(x) and pop
fyl2xp1=compute y times log2(x+1) and pop
haddpd=packed double-fp horizontal add
haddps=packed single-fp horizontal add
hlt=stop process until external interrupt received
hsubpd=packed double-fp horizontal subtract
hsubps=packed single-fp horizontal subtract
idiv=signed divide
imul=signed multiply
in=input from port
inc=increment by 1
ins=input from port to string
insb=input from port to string
insd=input from port to string
insertps=insert scalar single-precision floating-point value
insw=input from port to string
int=call to interrupt procedure
int 3=call to interrupt procedure
into=call to interrupt if overflow
invd=invalidate internal caches
invlpg=invalidate tlb entry
invpcid=invalidate process-context identifier
iret=return from interrupt
iretd=interrupt return
ja=jump short if above (cf=0 and zf=0)
jae=jump short if above or equal (cf=0)
jb=jump short if below/not above nor equal/carry (cf=1)
jbe=jump short if below or equal/not above (cf=1 or zf=1)
jc=jump short if carry (cf=1)
jcxz=jump short if ecx register is 0
je=jump short if equal (zf=1)
jecxz=jump short if ecx is 0
jg=jump short if greater (zf=0 and sf=of)
jge=jump short if greater or equal (sf=of)
jl=jump short if less/not greater (sf!=of)
jle=jump short if less or equal/not greater (zf=1 or sf!=of)
jmp=jump
jna=jump short if not above/equal (cf=1 or zf=1)
jnae=jump short if not above nor equal/below (cf=1)
jnb=jump short if not below/above or equal/not carry (cf=0)
jnbe=jump short if not below or equal/above (cf=0 and zf=0)
jnc=jump short if not carry (cf=0)
jne=jump short if not equal/not zero (zf=0)
jng=jump short if not greater/less or equal (zf=1 or sf!=of)
jnge=jump short if not greater/less (sf!=of)
jnl=jump short if not less/greater or equal (sf=of)
jnle=jump short if not less nor equal/greater (zf=0 and sf=of)
jno=jump short if not overflow (of=0)
jnp=jump short if not parity/parity odd (pf=0)
jns=jump short if not sign (sf=0)
jnz=jump short if not zero/not equal (zf=0)
jo=jump short if overflow (of=1)
jp=jump short if parity/parity even (pf=1)
jpe=jump short if parity even/parity (pf=1)
jpo=jump short if parity odd/not parity (pf=0)
jrcxz=jump short if rcx register is 0
js=jump short if sign (sf=1)
jz=jump short if zero/equal (zf=1)
kaddb=add two masks
kaddd=add two masks
kaddq=add two masks
kaddw=add two masks
kandb=bitwise logical and masks
kandd=bitwise logical and masks
kandnb=bitwise logical and not masks
kandnd=bitwise logical and not masks
kandnq=bitwise logical and not masks
kandnw=bitwise logical and not masks
kandq=bitwise logical and masks
kandw=bitwise logical and masks
kmovb=move from and to mask registers
kmovd=move from and to mask registers
kmovq=move from and to mask registers
kmovw=move from and to mask registers
knotb=not mask register
knotd=not mask register
knotq=not mask register
knotw=not mask register
korb=bitwise logical or masks
kord=bitwise logical or masks
korq=bitwise logical or masks
kortestb=or masks and set flags
kortestd=or masks and set flags
kortestq=or masks and set flags
kortestw=or masks and set flags
korw=bitwise logical or masks
kshiftlb=shift left mask registers
kshiftld=shift left mask registers
kshiftlq=shift left mask registers
kshiftlw=shift left mask registers
kshiftrb=shift right mask registers
kshiftrd=shift right mask registers
kshiftrq=shift right mask registers
kshiftrw=shift right mask registers
ktestb=packed bit test masks and set flags
ktestd=packed bit test masks and set flags
ktestq=packed bit test masks and set flags
ktestw=packed bit test masks and set flags
kunpckbw=unpack for mask registers
kunpckdq=unpack for mask registers
kunpckwd=unpack for mask registers
kxnorb=bitwise logical xnor masks
kxnord=bitwise logical xnor masks
kxnorq=bitwise logical xnor masks
kxnorw=bitwise logical xnor masks
kxorb=bitwise logical xor masks
kxord=bitwise logical xor masks
kxorq=bitwise logical xor masks
kxorw=bitwise logical xor masks
lahf=load status flags into ah register
lar=load acces right byte
lddqu=load unaligned integer 128 bits
ldmxcsr=load mxcsr register
lds=load far pointer
lea=load effective address
leave=one byte alias for mov esp, ebp ; pop ebp
les=load far pointer
lfence=load fence
lfs=load far pointer
lgdt=load global descriptor table register
lgs=load far pointer
lidt=load interrupt descriptor table register
lldt=load local descriptor table register
lmsw=load machine status word
lock=instruction prefix to setup the LOCK pin
lods=load string
lodsb=Load string byte
lodsd=Load string doubleword
lodsq=Load string quadword
lodsw=Load string word
loop=decrement count; jump short if ecx!=0
loope=decrement count; jump short if ecx!=0 and zf=1
loopne=decrement count; jump short if ecx!=0 and zf=0
loopnz=decrement count; jump short if ecx!=0 and zf=0
loopz=decrement count; jump short if ecx!=0 and zf=1
lsl=load segment limit
lss=load far pointer
ltr=load task register
lzcnt=count the number of leading zero bits
maskmovdqu=store selected bytes of double quadword
maskmovq=store selected bytes of quadword
maxpd=return maximum packed double-fp values
maxps=return maximum packed single-fp values
maxsd=return maximum scalar double-fp value
maxss=return maximum scalar single-fp value
mfence=memory fence
minpd=return minimum packed double-fp values
minps=return minimum packed single-fp values
minsd=return minimum scalar double-fp value
minss=return minimum scalar single-fp value
monitor=set up monitor address
mov=moves data from src to dst
movapd=move aligned packed double-fp values
movaps=move aligned packed single-fp values
movbe=move data after swapping bytes
movd=move doubleword
movddup=move one double-fp and duplicate
movdq2q=move quadword from xmm to mmx technology register
movdqa=move aligned double quadword
movdqu=move unaligned double quadword
movhlps=move packed single-fp values high to low
movhpd=move high packed double-fp value
movhps=move high packed single-fp values
movlhps=move packed single-fp values low to high
movlpd=move low packed double-fp value
movlps=move low packed single-fp values
movmskpd=extract packed double-fp sign mask
movmskps=extract packed single-fp sign mask
movntdq=store double quadword using non-temporal hint
movntdqa=load double quadword non-temporal aligned hint
movnti=store doubleword using non-temporal hint
movntpd=store packed double-fp values using non-temporal hint
movntps=store packed single-fp values using non-temporal hint
movntq=store of quadword using non-temporal hint
movq=move quadword
movq2dq=move quadword from mmx technology to xmm register
movs=move data from string to string
movsb=ES:[edi] = (byte)DS:[esi] (esi++, edi++)
movsd=ES:[edi] = (dword)DS:[esi] (esi+=4, edi+=4)/move scalar double-fp value
movshdup=move packed single-fp high and duplicate
movsldup=move packed single-fp low and duplicate
movsq=ES:[rdi] = (qword)DS:[rsi] (rsi+=8, rdi+=8)
movss=move scalar single-fp values
movsw=ES:[edi] = (word)DS:[esi] (esi+=2, edi+=2)
movsx=move with sign-extension
movsxd=move with sign-extension
movupd=move unaligned packed double-fp values
movups=move unaligned packed single-fp values
movzx=move dst register size padding with zeroes
mpsadbw=compute multiple packed sums of absolute difference
mul=unsigned multiply
mulpd=multiply packed double-fp values
mulps=multiply packed single-fp values
mulsd=multiply scalar double-fp values
mulss=multiply scalar single-fp value
mulx=unsigned multiply without affecting flags
mwait=monitor wait
neg=two's complement negation
nop=no operation
not=one's complement negation
or=logical inclusive or
orpd=bitwise logical or of double-fp values
orps=bitwise logical or of single-fp values
out=output to port
outs=output string to port
outsb=Output string byte to port
outsd=Output string doubleword to port
outsw=Output string word to port
pabsb=packed absolute value
pabsd=packed absolute value
pabsq=packed absolute value
pabsw=packed absolute value
packssdw=pack with signed saturation
packsswb=pack with signed saturation
packusdw=pack with unsigned saturation
packuswb=pack with unsigned saturation
paddb=add packed integers
paddd=add packed integers
paddq=add packed quadword integers
paddsb=add packed signed integers with signed saturation
paddsw=add packed signed integers with signed saturation
paddusb=add packed unsigned integers with unsigned saturation
paddusw=add packed unsigned integers with unsigned saturation
paddw=add packed integers
palignr=packed align right
pand=logical and
pandn=logical and not
pause=spin loop hint
pavgb=average packed integers
pavgw=average packed integers
pblendvb=variable blend packed bytes
pblendw=blend packed words
pclmulqdq=performs a carry-less multiplication of two 64-bit polynomials over the finite field GF(2).
pcmpeqb=compare packed data for equal
pcmpeqd=compare packed data for equal
pcmpeqq=compare packed qword data for equal
pcmpeqw=compare packed data for equal
pcmpestri=packed compare explicit length strings, return index
pcmpestrm=packed compare explicit length strings, return mask
pcmpgtb=compare packed signed integers for greater than
pcmpgtd=compare packed signed integers for greater than
pcmpgtq=compare packed data for greater than
pcmpgtw=compare packed signed integers for greater than
pcmpistri=packed compare implicit length strings, return index
pcmpistrm=packed compare implicit length strings, return mask
pdep=parallel bits deposit
pext=parallel bits extract
pextrb=extract a byte from an XMM register and insert the value into a general-purpose register or memory
pextrd=extract a dword from an XMM register and insert the value into a general-purpose register or memory
pextrq=extract a qword from an XMM register and insert the value into a general-purpose register or memory
pextrw=extract a word from an XMM register and insert the value into a general-purpose register or memory
phaddd=packed horizontal add
phaddsw=packed horizontal add and saturate
phaddw=packed horizontal add
phminposuw=packed horizontal word minimum
phsubd=packed horizontal subtract
phsubsw=packed horizontal subtract and saturate
phsubw=packed horizontal subtract
pinsrb=insert a byte value from a register or memory into an XMM register
pinsrd=insert a dword value from a register or memory into an XMM register
pinsrq=insert a qword value from a register or memory into an XMM register
pinsrw=insert a word value from a register or memory into an XMM register
pmaddubsw=multiply and add packed signed and unsigned bytes
pmaddwd=multiply and add packed integers
pmaxsb=maximum of packed signed byte integers
pmaxsd=maximum of packed signed dword integers
pmaxsq=maximum of packed signed integers
pmaxsw=maximum of packed signed word integers
pmaxub=maximum of packed unsigned byte integers
pmaxud=maximum of packed unsigned dword integers
pmaxuq=maximum of packed unsigned integers
pmaxuw=maximum of packed unsigned word integers
pminsb=minimum of packed signed byte integers
pminsd=minimum of packed signed dword integers
pminsq=minimum of packed signed integers
pminsw=minimum of packed signed word integers
pminub=minimum of packed unsigned byte integers
pminud=minimum of packed unsigned dword integers
pminuq=minimum of packed unsigned integers
pminuw=minimum of packed unsigned word integers
pmovmskb=move byte mask
pmovsxbd=sign extend the lower 8-bit integer of each packed dword element into packed signed dword integers
pmovsxbq=sign extend the lower 8-bit integer of each packed qword element into packed signed qword integers
pmovsxbw=sign extend the lower 8-bit integer of each packed word element into packed signed word integers
pmovsxdq=sign extend the lower 32-bit integer of each packed qword element into packed signed qword integers
pmovsxwd=sign extend the lower 16-bit integer of each packed dword element into packed signed dword integers
pmovsxwq=sign extend the lower 16-bit integer of each packed qword element into packed signed qword integers
pmovzxbd=zero extend the lower 8-bit integer of each packed dword element into packed signed dword integers
pmovzxbq=zero extend the lower 8-bit integer of each packed qword element into packed signed qword integers
pmovzxbw=zero extend the lower 8-bit integer of each packed word element into packed signed word integers
pmovzxdq=zero extend the lower 32-bit integer of each packed qword element into packed signed qword integers
pmovzxwd=zero extend the lower 16-bit integer of each packed dword element into packed signed dword integers
pmovzxwq=zero extend the lower 16-bit integer of each packed qword element into packed signed qword integers
pmuldq=multiply packed doubleword integers
pmulhrsw=packed multiply high with round and scale
pmulhuw=multiply packed unsigned integers and store high result
pmulhw=multiply packed signed integers and store high result
pmulld=multiply packed signed dword integers and store low result
pmullq=multiply packed integers and store low result
pmullw=multiply packed signed integers and store low result
pmuludq=multiply packed unsigned dw integers
pop=pops last element of stack and stores the result in argument
popa=pop all general-purpose registers
popad=pop all general-purpose registers
popcnt=bit population count
popf=pop stack into flags register
popfd=pop stack into eflags register
popfq=pop stack into rflags register
por=bitwise logical or
prefetchnta=prefetch data into caches
prefetcht0=prefetch data into caches
prefetcht1=prefetch data into caches
prefetcht2=prefetch data into caches
prefetchw=prefetch data into caches
prefetchwt1=prefetch vector data into caches with intent to write and t1 hint
prold=bit rotate left
prolq=bit rotate left
prolvd=bit rotate left
prolvq=bit rotate left
prord=bit rotate right
prorq=bit rotate right
prorvd=bit rotate right
prorvq=bit rotate right
psadbw=compute sum of absolute differences
pshufb=packed shuffle bytes
pshufd=shuffle packed doublewords
pshufhw=shuffle packed high words
pshuflw=shuffle packed low words
pshufw=shuffle packed words
psignb=packed sign
psignd=packed sign
psignw=packed sign
pslld=shift packed data left logical
pslldq=shift double quadword left logical
psllq=shift packed data left logical
psllw=shift packed data left logical
psrad=shift packed data right arithmetic
psraq=shift packed data right arithmetic
psraw=shift packed data right arithmetic
psrld=shift packed data right logical
psrldq=shift double quadword right logical
psrlq=shift packed data right logical
psrlw=shift packed data right logical
psubb=subtract packed integers
psubd=subtract packed integers
psubq=subtract packed quadword integers
psubsb=subtract packed signed integers with signed saturation
psubsw=subtract packed signed integers with signed saturation
psubusb=subtract packed unsigned integers with unsigned saturation
psubusw=subtract packed unsigned integers with unsigned saturation
psubw=subtract packed integers
ptest=logical compare
ptwrite=ptwrite - write data to a processor trace packet
punpckhbw=unpack high data
punpckhdq=unpack high data
punpckhqdq=unpack high data
punpckhwd=unpack high data
punpcklbw=unpack low data
punpckldq=unpack low data
punpcklqdq=unpack low data
punpcklwd=unpack low data
push=push word, doubleword or quadword onto the stack
pusha=push all general-purpose registers
pushad=push all general-purpose registers
pushf=push flags register onto the stack
pushfd=push eflags register onto the stack
pxor=logical exclusive or
rcl=rotate bits left (with CF)
rcpps=compute reciprocals of packed single-fp values
rcpss=compute reciprocal of scalar single-fp values
rcr=rotate bits right (with CF)
rdfsbase=read fs/gs segment base
rdgsbase=read fs/gs segment base
rdmsr=read from model specific register
rdpid=read processor id
rdpkru=read protection key rights for user pages
rdpmc=read performance-monitoring counters
rdrand=read random number
rdseed=read random seed
rdtsc=read time-stamp counter
rdtscp=read time-stamp counter and processor id
rep ins=repeat string operation prefix
rep lods=repeat string operation prefix
rep movs=repeat string operation prefix
rep outs=repeat string operation prefix
rep stos=repeat string operation prefix
repe cmps=repeat string operation prefix
repe scas=repeat string operation prefix
repne cmps=repeat string operation prefix
repne scas=repeat string operation prefix
ret=return from subroutine. pop 4 bytes from esp and jump there.
rol=rotate bits left
ror=rotate bits right
rorx=rotate right logical without affecting flags
roundpd=round packed double-fp values
roundps=round packed single-fp values
roundsd=round scalar double-fp values
roundss=round scalar single-fp values
rsm=resume from system management mode
rsqrtps=compute recipr. of square roots of packed single-fp values
rsqrtss=compute recipr. of square root of scalar single-fp value
sahf=store ah into flags
sal=arithmetic left shift
sar=arithmetic right shift
sarx=shift without affecting flags
sbb=integer subtraction with borrow
scas=scan string
scasb=cmp al, ES:[edi++]
scasd=cmp eax, ES:[edi+=4]
scasw=cmp ax, ES:[edi+=2]
seta=set byte on condition - above/not below nor equal (cf=0 and zf=0)
setae=set byte on condition - above or equal/not below/not carry (cf=0)
setb=set byte on condition - below/not above nor equal/carry (cf=1)
setbe=set byte on condition - below or equal/not above (cf=1 or zf=1)
setc=set byte on condition - carry/below/not above nor equal (cf=1)
sete=set byte on condition - equal/zero (zf=1)
setg=set byte on condition - greater/not less nor equal (zf=0 and sf=of)
setge=set byte on condition - greater or equal/not less (sf=of)
setl=set byte on condition - less/not greater nor equal (sf!=of)
setle=set byte on condition - less or equal/not greater (zf=1 or sf!=of)
setna=set byte on condition - not above/below or equal (cf=1 or zf=1)
setnae=set byte on condition - not above nor equal/below/carry (cf=1)
setnb=set byte on condition - not below/above or equal/not carry (cf=0)
setnbe=set byte on condition - not below nor equal/above (cf=0 and zf=0)
setnc=set byte on condition - not carry/above or equal/not below (cf=0)
setne=set byte on condition - not equal/not zero (zf=0)
setng=set byte on condition - not greater/less or equal (zf=1 or sf!=of)
setnge=set byte on condition - not greater nor equal/less (sf!=of)
setnl=set byte on condition - not less/greater or equal (sf=of)
setno=set byte on condition - not overflow (of=0)
setnp=set byte on condition - not parity/parity odd (pf=0)
setns=set byte on condition - not sign (sf=0)
setnz=set byte on condition - not zero/not equal (zf=0)
seto=set byte on condition - overflow (of=1)
setp=set byte on condition - parity/parity even (pf=1)
setpe=set byte on condition - parity even/parity (pf=1)
setpo=set byte on condition - parity odd/not parity (pf=0)
sets=set byte on condition - sign (sf=1)
setz=set byte on condition - zero/equal (zf=1)
sfence=store fence
sgdt=store global descriptor table register
sha1msg1=perform an intermediate calculation for the next four sha1 message dwords
sha1msg2=perform a final calculation for the next four sha1 message dwords
sha1nexte=calculate sha1 state variable e after four rounds
sha1rnds4=perform four rounds of sha1 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
sha256rnds2=perform two rounds of sha256 operation
shl=logic left shift (0 padding)
shld=double precision shift left
shlx=shift without affecting flags
shr=logic right shift (0 padding)
shrd=double precision shift right
shrx=shift without affecting flags
shufpd=shuffle packed double-fp values
shufps=shuffle packed single-fp values
sidt=store interrupt descriptor table register
sldt=store local descriptor table register.
smsw=store machine status word
sqrtpd=compute square roots of packed double-fp values
sqrtps=compute square roots of packed single-fp values
sqrtsd=compute square root of scalar double-fp value
sqrtss=compute square root of scalar single-fp value
stac=set ac flag in eflags register
stc=set carry flag
std=set direction flag
sti=set interrupt flag
stmxcsr=store mxcsr register state
stos=store string
stosb=store string byte
stosd=store string dword
stosq=store string quadword
stosw=store string word
str=store task register
sub=substract src and dst, stores result on dst
subpd=subtract packed double-fp values
subps=subtract packed single-fp values
subsd=subtract scalar double-fp values
subss=subtract scalar single-fp values
swapgs=swap gs base register
syscall=fast system call
sysenter=fast system call
sysexit=fast return from fast system call
sysret=return from fast system call
test=set eflags after comparing two registers (AF, CF, OF, PF, SF, ZF)
tzcnt=count the number of trailing zero bits
ucomisd=unordered compare scalar double-fp values and set eflags
ucomiss=unordered compare scalar single-fp values and set eflags
ud2=undefined instruction
unpckhpd=unpack and interleave high packed double-fp values
unpckhps=unpack and interleave high packed single-fp values
unpcklpd=unpack and interleave low packed double-fp values
unpcklps=unpack and interleave low packed single-fp values
vaddpd=add packed double-precision floating-point values
vaddps=add packed single-precision floating-point values
vaddsd=add scalar double-precision floating-point values
vaddss=add scalar single-precision floating-point values
vaddsubpd=packed double-fp add/subtract
vaddsubps=packed single-fp add/subtract
vaesdec=perform one round of an aes decryption flow
vaesdeclast=perform last round of an aes decryption flow
vaesenc=perform one round of an aes encryption flow
vaesenclast=perform last round of an aes encryption flow
vaesimc=perform the aes invmixcolumn transformation
vaeskeygenassist=aes round key generation assist
valignd=align doubleword/quadword vectors
valignq=align doubleword/quadword vectors
vandnpd=bitwise logical and not of packed double precision floating-point values
vandnps=bitwise logical and not of packed single precision floating-point values
vandpd=bitwise logical and of packed double precision floating-point values
vandps=bitwise logical and of packed single precision floating-point values
vblendmpd=blend float64/float32 vectors using an opmask control
vblendmps=blend float64/float32 vectors using an opmask control
vblendpd=blend packed double precision floating-point values
vblendps=blend packed single precision floating-point values
vblendvpd=variable blend packed double precision floating-point values
vblendvps=variable blend packed single precision floating-point values
vbroadcastf128=load with broadcast floating-point data
vbroadcastf32x2=load with broadcast floating-point data
vbroadcastf32x4=load with broadcast floating-point data
vbroadcastf32x8=load with broadcast floating-point data
vbroadcastf64x2=load with broadcast floating-point data
vbroadcastf64x4=load with broadcast floating-point data
vbroadcasti32x8=load integer and broadcast
vbroadcasti32x2=load integer and broadcast
vbroadcasti64x4=load integer and broadcast
vbroadcastsd=load with broadcast floating-point data
vbroadcastss=load with broadcast floating-point data
vcmppd=compare packed double-precision floating-point values
vcmpps=compare packed single-precision floating-point values
vcmpsd=compare scalar double-precision floating-point value
vcmpss=compare scalar single-precision floating-point value
vcomisd=compare scalar ordered double-precision floating-point values and set eflags
vcomiss=compare scalar ordered single-precision floating-point values and set eflags
vcompresspd=store sparse packed double-precision floating-point values into dense memory
vcompressps=store sparse packed single-precision floating-point values into dense memory
vcvtdq2pd=convert packed doubleword integers to packed double-precision floating-point values
vcvtdq2ps=convert packed doubleword integers to packed single-precision floating-point values
vcvtpd2dq=convert packed double-precision floating-point values to packed doubleword integers
vcvtpd2ps=convert packed double-precision floating-point values to packed single-precision floating-point values
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
vcvtph2ps=convert 16-bit fp values to single-precision fp values
vcvtps2dq=convert packed single-precision floating-point values to packed signed doubleword integer values
vcvtps2pd=convert packed single-precision floating-point values to packed double-precision floating-point values
vcvtps2ph=convert single-precision fp value to 16-bit fp value
vcvtps2qq=convert packed single precision floating-point values to packed singed quadword integer values
vcvtps2udq=convert packed single-precision floating-point values to packed unsigned doubleword 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
vcvtsd2si=convert scalar double-precision floating-point value to doubleword integer
vcvtsd2ss=convert scalar double-precision floating-point value to scalar single-precision floating-point value
vcvtsd2usi=convert scalar double-precision floating-point value to unsigned doubleword integer
vcvtsi2sd=convert doubleword integer to scalar double-precision floating-point value
vcvtsi2ss=convert doubleword integer to scalar single-precision floating-point value
vcvtss2sd=convert scalar single-precision floating-point value to scalar double-precision floating-point value
vcvtss2si=convert scalar single-precision floating-point value to doubleword integer
vcvtss2usi=convert scalar single-precision floating-point value to unsigned doubleword integer
vcvttpd2dq=convert with truncation packed double-precision floating-point values to packed doubleword integers
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
vcvttps2dq=convert with truncation packed single-precision floating-point values to packed signed doubleword integer values
vcvttps2qq=convert with truncation packed single precision floating-point values to packed singed quadword integer values
vcvttps2udq=convert with truncation packed single-precision floating-point values to packed unsigned doubleword integer values
vcvttps2uqq=convert with truncation packed single precision floating-point values to packed unsigned quadword integer values
vcvttsd2si=convert with truncation scalar double-precision floating-point value to signed integer
vcvttsd2usi=convert with truncation scalar double-precision floating-point value to unsigned integer
vcvttss2si=convert with truncation scalar single-precision floating-point value to 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
vdivpd=divide packed double-precision floating-point values
vdivps=divide packed single-precision floating-point values
vdivsd=divide scalar double-precision floating-point value
vdivss=divide scalar single-precision floating-point values
vdppd=dot product of packed double precision floating-point values
vdpps=dot product of packed single precision floating-point values
verr=verify a segment for reading
verw=verify a segment for writing
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
vexpandpd=load sparse packed double-precision floating-point values from dense memory
vexpandps=load sparse packed single-precision floating-point values from dense memory
vextractf128=extra ct packed floating-point values
vextractf32x4=extra ct packed floating-point values
vextractf32x8=extra ct packed floating-point values
vextractf64x2=extra ct packed floating-point values
vextractf64x4=extra ct packed floating-point values
vextracti128=extract packed integer values
vextracti32x4=extract packed integer values
vextracti32x8=extract packed integer values
vextracti64x2=extract packed integer values
vextracti64x4=extract packed integer values
vextractps=extract packed floating-point 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
vfmadd132pd=fused multiply-add of packed double-precision floating-point values
vfmadd132ps=fused multiply-add of packed single-precision floating-point values
vfmadd132sd=fused multiply-add of scalar double-precision floating-point values
vfmadd132ss=fused multiply-add of scalar single-precision floating-point values
vfmadd213pd=fused multiply-add of packed double-precision floating-point values
vfmadd213ps=fused multiply-add of packed single-precision floating-point values
vfmadd213sd=fused multiply-add of scalar double-precision floating-point values
vfmadd213ss=fused multiply-add of scalar single-precision floating-point values
vfmadd231pd=fused multiply-add of packed double-precision floating-point values
vfmadd231ps=fused multiply-add of packed single-precision floating-point values
vfmadd231sd=fused multiply-add of scalar double-precision floating-point values
vfmadd231ss=fused multiply-add of scalar single-precision floating-point values
vfmaddsub132pd=fused multiply-alternating add/subtract of packed double-precision floating-point values
vfmaddsub132ps=fused multiply-alternating add/subtract of packed single-precision floating-point values
vfmaddsub213pd=fused multiply-alternating add/subtract of packed double-precision floating-point values
vfmaddsub213ps=fused multiply-alternating add/subtract of packed single-precision floating-point values
vfmaddsub231pd=fused multiply-alternating add/subtract of packed double-precision floating-point values
vfmaddsub231ps=fused multiply-alternating add/subtract of packed single-precision floating-point values
vfmsub132pd=fused multiply-subtract of packed double-precision floating-point values
vfmsub132ps=fused multiply-subtract of packed single-precision floating-point values
vfmsub132sd=fused multiply-subtract of scalar double-precision floating-point values
vfmsub132ss=fused multiply-subtract of scalar single-precision floating-point values
vfmsub213pd=fused multiply-subtract of packed double-precision floating-point values
vfmsub213ps=fused multiply-subtract of packed single-precision floating-point values
vfmsub213sd=fused multiply-subtract of scalar double-precision floating-point values
vfmsub213ss=fused multiply-subtract of scalar single-precision floating-point values
vfmsub231pd=fused multiply-subtract of packed double-precision floating-point values
vfmsub231ps=fused multiply-subtract of packed single-precision floating-point values
vfmsub231sd=fused multiply-subtract of scalar double-precision floating-point values
vfmsub231ss=fused multiply-subtract of scalar single-precision floating-point values
vfmsubadd132pd=fused multiply-alternating subtract/add of packed double-precision floating-point values
vfmsubadd132ps=fused multiply-alternating subtract/add of packed single-precision floating-point values
vfmsubadd213pd=fused multiply-alternating subtract/add of packed double-precision floating-point values
vfmsubadd213ps=fused multiply-alternating subtract/add of packed single-precision floating-point values
vfmsubadd231pd=fused multiply-alternating subtract/add of packed double-precision floating-point values
vfmsubadd231ps=fused multiply-alternating subtract/add of packed single-precision floating-point values
vfnmadd132pd=fused negative multiply-add of packed double-precision floating-point values
vfnmadd132ps=fused negative multiply-add of packed single-precision floating-point values
vfnmadd132sd=fused negative multiply-add of scalar double-precision floating-point values
vfnmadd132ss=fused negative multiply-add of scalar single-precision floating-point values
vfnmadd213pd=fused negative multiply-add of packed double-precision floating-point values
vfnmadd213ps=fused negative multiply-add of packed single-precision floating-point values
vfnmadd213sd=fused negative multiply-add of scalar double-precision floating-point values
vfnmadd213ss=fused negative multiply-add of scalar single-precision floating-point values
vfnmadd231pd=fused negative multiply-add of packed double-precision floating-point values
vfnmadd231ps=fused negative multiply-add of packed single-precision floating-point values
vfnmadd231sd=fused negative multiply-add of scalar double-precision floating-point values
vfnmadd231ss=fused negative multiply-add of scalar single-precision floating-point values
vfnmsub132pd=fused negative multiply-subtract of packed double-precision floating-point values
vfnmsub132ps=fused negative multiply-subtract of packed single-precision floating-point values
vfnmsub132sd=fused negative multiply-subtract of scalar double-precision floating-point values
vfnmsub132ss=fused negative multiply-subtract of scalar single-precision floating-point values
vfnmsub213pd=fused negative multiply-subtract of packed double-precision floating-point values
vfnmsub213ps=fused negative multiply-subtract of packed single-precision floating-point values
vfnmsub213sd=fused negative multiply-subtract of scalar double-precision floating-point values
vfnmsub213ss=fused negative multiply-subtract of scalar single-precision floating-point values
vfnmsub231pd=fused negative multiply-subtract of packed double-precision floating-point values
vfnmsub231ps=fused negative multiply-subtract of packed single-precision floating-point values
vfnmsub231sd=fused negative multiply-subtract of scalar double-precision floating-point values
vfnmsub231ss=fused negative multiply-subtract of scalar single-precision floating-point values
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
vgatherdpd=gather packed single, packed double with signed dword
vgatherdps=gather packed sp fp values using signed dword/qword indices
vgatherpf0dpd=sparse prefetch packed sp/dp data values with signed dword, signed qword indices using t0 hint
vgatherpf0dps=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
vgatherpf0qps=sparse prefetch packed sp/dp data values with signed dword, signed qword indices using t0 hint
vgatherpf1dpd=sparse prefetch packed sp/dp data values with signed dword, signed qword indices using t1 hint
vgatherpf1dps=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
vgatherpf1qps=sparse prefetch packed sp/dp data values with signed dword, signed qword indices using t1 hint
vgatherqpd=gather packed single, packed double with signed qword indices
vgatherqps=gather packed single, packed double with signed qword indices
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
vhaddpd=packed double-fp horizontal add
vhaddps=packed single-fp horizontal add
vhsubpd=packed double-fp horizontal subtract
vhsubps=packed single-fp horizontal subtract
vinsertf128=insert packed floating-point values
vinsertf32x4=insert packed floating-point values
vinsertf32x8=insert packed floating-point values
vinsertf64x2=insert packed floating-point values
vinsertf64x4=insert packed floating-point values
vinserti128=insert packed integer values
vinserti32x4=insert packed integer values
vinserti32x8=insert packed integer values
vinserti64x2=insert packed integer values
vinserti64x4=insert packed integer values
vinsertps=insert scalar single-precision floating-point value
vlddqu=load unaligned integer 128 bits
vldmxcsr=load mxcsr register
vmaskmovdqu=store selected bytes of double quadword
vmaskmovpd=conditional simd packed loads and stores
vmaskmovps=conditional simd packed loads and stores
vmaxpd=maximum of packed double-precision floating-point values
vmaxps=maximum of packed single-precision floating-point values
vmaxsd=return maximum scalar double-precision floating-point value
vmaxss=return maximum scalar single-precision floating-point value
vminpd=minimum of packed double-precision floating-point values
vminps=minimum of packed single-precision floating-point values
vminsd=return minimum scalar double-precision floating-point value
vminss=return minimum scalar single-precision floating-point value
vmovapd=move aligned packed double-precision floating-point values
vmovaps=move aligned packed single-precision floating-point values
vmovd=move doubleword/move quadword
vmovddup=replicate double fp values
vmovdqa=move aligned packed integer values
vmovdqa32=move aligned packed integer values
vmovdqa64=move aligned packed integer values
vmovdqu=move unaligned packed integer values
vmovdqu16=move unaligned packed integer values
vmovdqu32=move unaligned packed integer values
vmovdqu64=move unaligned packed integer values
vmovdqu8=move unaligned packed integer values
vmovhlps=move packed single-precision floating-point values high to low
vmovhpd=move high packed double-precision floating-point value
vmovhps=move high packed single-precision floating-point values
vmovlhps=move packed single-precision floating-point values low to high
vmovlpd=move low packed double-precision floating-point value
vmovlps=move low packed single-precision floating-point values
vmovmskpd=extract packed double-precision floating-point sign mask
vmovmskps=extract packed single-precision floating-point sign mask
vmovntdq=store packed integers using non-temporal hint
vmovntdqa=load double quadword non-temporal aligned hint
vmovntpd=store packed double-precision floating-point values using non-temporal hint
vmovntps=store packed single-precision floating-point values using non-temporal hint
vmovq=move quadword
vmovsd=move or merge scalar double-precision floating-point value
vmovshdup=replicate single fp values
vmovsldup=replicate single fp values
vmovss=move or merge scalar single-precision floating-point value
vmovupd=move unaligned packed double-precision floating-point values
vmovups=move unaligned packed single-precision floating-point values
vmpsadbw=compute multiple packed sums of absolute difference
vmulpd=multiply packed double-precision floating-point values
vmulps=multiply packed single-precision floating-point values
vmulsd=multiply scalar double-precision floating-point value
vmulss=multiply scalar single-precision floating-point values
vorpd=bitwise logical or of packed double precision floating-point values
vorps=bitwise logical or of packed single precision floating-point values
vpabsb=packed absolute value
vpabsd=packed absolute value
vpabsq=packed absolute value
vpabsw=packed absolute value
vpackssdw=pack with signed saturation
vpacksswb=pack with signed saturation
vpackusdw=pack with unsigned saturation
vpackuswb=pack with unsigned saturation
vpaddb=add packed integers
vpaddd=add packed integers
vpaddq=add packed integers
vpaddsb=add packed signed integers with signed saturation
vpaddsw=add packed signed integers with signed saturation
vpaddusb=add packed unsigned integers with unsigned saturation
vpaddusw=add packed unsigned integers with unsigned saturation
vpaddw=add packed integers
vpalignr=packed align right
vpand=logical and
vpandd=logical and
vpandn=logical and not
vpandnd=logical and not
vpandnq=logical and not
vpandq=logical and
vpavgb=average packed integers
vpavgw=average packed integers
vpblendd=blend packed dwords
vpblendmb=blend byte/word vectors using an opmask control
vpblendmd=blend int32/int64 vectors using an opmask control
vpblendmq=blend int32/int64 vectors using an opmask control
vpblendmw=blend byte/word vectors using an opmask control
vpblendvb=variable blend packed bytes
vpblendw=blend packed words
vpbroadcastb=load with broadcast integer data from general purpose register
vpbroadcastd=load with broadcast integer data from general purpose register
vpbroadcastmb2q=broadcast mask to vector register
vpbroadcastmw2d=broadcast mask to vector register
vpbroadcastq=load with broadcast integer data from general purpose register
vpbroadcastw=load with broadcast integer data from general purpose register
vpclmulqdq=pclmulqdq - carry-less multiplication quadword
vpcmpb=compare packed byte values into mask
vpcmpd=compare packed integer values into mask
vpcmpeqb=compare packed data for equal
vpcmpeqd=compare packed data for equal
vpcmpeqq=compare packed qword data for equal
vpcmpeqw=compare packed data for equal
vpcmpestri=packed compare explicit length strings, return index
vpcmpestrm=packed compare explicit length strings, return mask
vpcmpgtb=compare packed signed integers for greater than
vpcmpgtd=compare packed signed integers for greater than
vpcmpgtq=compare packed data for greater than
vpcmpgtw=compare packed signed integers for greater than
vpcmpistri=packed compare implicit length strings, return index
vpcmpistrm=packed compare implicit length strings, return mask
vpcmpq=compare packed integer values into mask
vpcmpub=compare packed byte values into mask
vpcmpud=compare packed integer values into mask
vpcmpuq=compare packed integer values into mask
vpcmpuw=compare packed word values into mask
vpcmpw=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/qword values into dense memory/ register
vpconflictq=detect conflicts within a vector of packed dword/qword values into dense memory/ register
vperm2f128=permute floating-point values
vperm2i128=permute integer values
vpermd=permute packed doublewords/words elements
vpermi2d=full permute from two tables overwriting the index
vpermi2pd=full permute from two tables overwriting the index
vpermi2ps=full permute from two tables overwriting the index
vpermi2q=full permute from two tables overwriting the index
vpermi2w=full permute from two tables overwriting the index
vpermilpd=permute in-lane of pairs of double-precision floating-point values
vpermilps=permute in-lane of quadruples of single-precision floating-point values
vpermpd=permute double-precision floating-point elements
vpermps=permute single-precision floating-point elements
vpermq=qwords element permutation
vpermw=permute packed doublewords/words elements
vpexpandd=load sparse packed doubleword integer values from dense memory / register
vpexpandq=load sparse packed quadword integer values from dense memory / register
vpextrb=extract byte/dword/qword
vpextrd=extract byte/dword/qword
vpextrq=extract byte/dword/qword
vpextrw=extract word
vpgatherdd=gather packed dword values using signed dword/qword indices
vpgatherdq=gather packed qword values using signed dword/qword indices
vpgatherqd=gather packed dword, packed qword with signed qword indices
vpgatherqq=gather packed dword, packed qword with signed qword indices
vphaddd=packed horizontal add
vphaddsw=packed horizontal add and saturate
vphaddw=packed horizontal add
vphminposuw=packed horizontal word minimum
vphsubd=packed horizontal subtract
vphsubsw=packed horizontal subtract and saturate
vphsubw=packed horizontal subtract
vpinsrb=insert byte/dword/qword
vpinsrd=insert byte/dword/qword
vpinsrq=insert byte/dword/qword
vpinsrw=insert word
vplzcntd=count the number of leading zero bits for packed dword, packed qword values
vplzcntq=count the number of leading zero bits for packed dword, packed qword values
vpmaddubsw=multiply and add packed signed and unsigned bytes
vpmaddwd=multiply and add packed integers
vpmaskmovd=conditional simd integer packed loads and stores
vpmaskmovq=conditional simd integer packed loads and stores
vpmaxsb=maximum of packed signed integers
vpmaxsd=maximum of packed signed integers
vpmaxsq=maximum of packed signed integers
vpmaxsw=maximum of packed signed integers
vpmaxub=maximum of packed unsigned integers
vpmaxud=maximum of packed unsigned integers
vpmaxuq=maximum of packed unsigned integers
vpmaxuw=maximum of packed unsigned integers
vpminsb=minimum of packed signed integers
vpminsd=minimum of packed signed integers
vpminsq=minimum of packed signed integers
vpminsw=minimum of packed signed integers
vpminub=minimum of packed unsigned integers
vpminud=minimum of packed unsigned integers
vpminuq=minimum of packed unsigned integers
vpminuw=minimum of packed unsigned integers
vpmovb2m=convert a vector register to a mask
vpmovd2m=convert a vector register to a mask
vpmovdb=down convert dword to byte
vpmovdw=down convert dword to word
vpmovm2b=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
vpmovm2w=convert a mask register to a vector register
vpmovmskb=move byte mask
vpmovq2m=convert a vector register to a mask
vpmovqb=down convert qword to byte
vpmovqd=down convert qword to dword
vpmovqw=down convert qword to word
vpmovsdb=down convert dword to byte
vpmovsdw=down convert dword to word
vpmovsqb=down convert qword to byte
vpmovsqd=down convert qword to dword
vpmovsqw=down convert qword to word
vpmovswb=down convert word to byte
vpmovsxbd=packed move with sign extend
vpmovsxbq=packed move with sign extend
vpmovsxbw=packed move with sign extend
vpmovsxdq=packed move with sign extend
vpmovsxwd=packed move with sign extend
vpmovsxwq=packed move with sign extend
vpmovusdb=down convert dword to byte
vpmovusdw=down convert dword to word
vpmovusqb=down convert qword to byte
vpmovusqd=down convert qword to dword
vpmovusqw=down convert qword to word
vpmovuswb=down convert word to byte
vpmovw2m=convert a vector register to a mask
vpmovwb=down convert word to byte
vpmovzxbd=packed move with zero extend
vpmovzxbq=packed move with zero extend
vpmovzxbw=packed move with zero extend
vpmovzxdq=packed move with zero extend
vpmovzxwd=packed move with zero extend
vpmovzxwq=packed move with zero extend
vpmuldq=multiply packed doubleword integers
vpmulhrsw=packed multiply high with round and scale
vpmulhuw=multiply packed unsigned integers and store high result
vpmulhw=multiply packed signed integers and store high result
vpmulld=multiply packed integers and store low result
vpmullq=multiply packed integers and store low result
vpmullw=multiply packed signed integers and store low result
vpmuludq=multiply packed unsigned doubleword integers
vpor=bitwise logical or
vpord=bitwise logical or
vporq=bitwise logical or
vprold=bit rotate left
vprolq=bit rotate left
vprolvd=bit rotate left
vprolvq=bit rotate left
vprord=bit rotate right
vprorq=bit rotate right
vprorvd=bit rotate right
vprorvq=bit rotate right
vpsadbw=compute sum of absolute differences
vpscatterdd=scatter packed dword, packed qword with signed dword, signed qword indices
vpscatterdq=scatter packed dword, packed qword with signed dword, signed qword indices
vpscatterqd=scatter packed dword, packed qword with signed dword, signed qword indices
vpscatterqq=scatter packed dword, packed qword with signed dword, signed qword indices
vpshufb=packed shuffle bytes
vpshufd=shuffle packed doublewords
vpshufhw=shuffle packed high words
vpshuflw=shuffle packed low words
vpsignb=packed sign
vpsignd=packed sign
vpsignw=packed sign
vpslld=shift packed data left logical
vpslldq=shift double quadword left logical
vpsllq=shift packed data left logical
vpsllvd=variable bit shift left logical
vpsllvq=variable bit shift left logical
vpsllvw=variable bit shift left logical
vpsllw=shift packed data left logical
vpsrad=shift packed data right arithmetic
vpsraq=shift packed data right arithmetic
vpsravd=variable bit shift right arithmetic
vpsravq=variable bit shift right arithmetic
vpsravw=variable bit shift right arithmetic
vpsraw=shift packed data right arithmetic
vpsrld=shift packed data right logical
vpsrldq=shift double quadword right logical
vpsrlq=shift packed data right logical
vpsrlvd=variable bit shift right logical
vpsrlvq=variable bit shift right logical
vpsrlvw=variable bit shift right logical
vpsrlw=shift packed data right logical
vpsubb=subtract packed integers
vpsubd=subtract packed integers
vpsubq=subtract packed quadword integers
vpsubsb=subtract packed signed integers with signed saturation
vpsubsw=subtract packed signed integers with signed saturation
vpsubusb=subtract packed unsigned integers with unsigned saturation
vpsubusw=subtract packed unsigned integers with unsigned saturation
vpsubw=subtract packed integers
vpternlogd=bitwise ternary logic
vpternlogq=bitwise ternary logic
vptest=ptest- logical compare
vptestmb=logical and and set mask
vptestmd=logical and and set mask
vptestmq=logical and and set mask
vptestmw=logical and and set mask
vptestnmb=logical nand and set
vptestnmd=logical nand and set
vptestnmq=logical nand and set
vptestnmw=logical nand and set
vpunpckhbw=unpack high data
vpunpckhdq=unpack high data
vpunpckhqdq=unpack high data
vpunpckhwd=unpack high data
vpunpcklbw=unpack low data
vpunpckldq=unpack low data
vpunpcklqdq=unpack low data
vpunpcklwd=unpack low data
vpxor=logical exclusive or
vpxord=logical exclusive or
vpxorq=logical 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
vrcp14ps=compute approximate reciprocals of packed float32 values
vrcp14sd=compute approximate reciprocal of scalar float64 value
vrcp14ss=compute approximate reciprocal of scalar float32 value
vrcp28pd=approximation to the reciprocal of packed double-precision floating-point values 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
vrcp28sd=approximation to the reciprocal of scalar double-precision floating-point value 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
vrcpps=compute reciprocals of packed single-precision floating-point values
vrcpss=compute reciprocal of scalar single-precision floating-point values
vreducepd=perform reduction transformation on packed float64 values
vreduceps=perform reduction transformation on packed float32 values
vreducesd=perform a reduction transformation on a scalar float64 value
vreducess=perform a reduction transformation on a scalar float32 value
vrndscalepd=round packed float64 values to include a given number of fraction bits
vrndscaleps=round packed float32 values to include a given number of fraction bits
vrndscalesd=round scalar float64 value to include a given number of fraction bits
vrndscaless=round scalar float32 value to include a given number of fraction bits
vroundpd=round packed double precision floating-point values
vroundps=round packed single precision floating-point values
vroundsd=round scalar double precision floating-point values
vroundss=round scalar single precision floating-point values
vrsqrt14pd=compute approximate reciprocals of square roots of packed float64 values
vrsqrt14ps=compute approximate reciprocals of square roots of packed float32 values
vrsqrt14sd=compute approximate reciprocal of square root of scalar float64 value
vrsqrt14ss=compute approximate reciprocal of square root of scalar float32 value
vrsqrt28pd=approximation to the reciprocal square root of packed double-precision floating-point values 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
vrsqrt28sd=approximation to the reciprocal square root of scalar double-precision floating-point value 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
vrsqrtps=compute reciprocals of square roots of packed single-precision floating-point values
vrsqrtss=compute reciprocal of square root of scalar single-precision floating-point value
vscalefpd=scale packed float64 values with float64 values
vscalefps=scale packed float32 values with float32 values
vscalefsd=scale scalar float64 values with float64 values
vscalefss=scale scalar float32 value with float32 value
vscatterdpd=scatter packed single, packed double with signed dword and qword indices
vscatterdps=scatter packed single, packed double with signed dword and qword indices
vscatterpf0dpd=sparse prefetch packed sp/dp data values with signed dword, signed qword indices using t0 hint with intent to write
vscatterpf0dps=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
vscatterpf0qps=sparse prefetch packed sp/dp data values with signed dword, signed qword indices using t0 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
vscatterpf1dps=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
vscatterpf1qps=sparse prefetch packed sp/dp data values with signed dword, signed qword indices using t1 hint with intent to write
vscatterqpd=scatter packed single, packed double with signed dword and qword indices
vscatterqps=scatter packed single, packed double with signed dword and qword indices
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
vshufpd=packed interleave shuffle of pairs of double-precision floating-point values
vshufps=packed interleave shuffle of quadruplets of single-precision floating-point values
vsqrtpd=square root of double-precision floating-point values
vsqrtps=square root of single-precision floating-point values
vsqrtsd=compute square root of scalar double-precision floating-point value
vsqrtss=compute square root of scalar single-precision value
vstmxcsr=store mxcsr register state
vsubpd=subtract packed double-precision floating-point values
vsubps=subtract packed single-precision floating-point values
vsubsd=subtract scalar double-precision floating-point value
vsubss=subtract scalar single-precision floating-point value
vtestpd=packed bit test
vtestps=packed bit test
vucomisd=unordered compare scalar double-precision floating-point values and set eflags
vucomiss=unordered compare scalar single-precision floating-point values and set eflags
vunpckhpd=unpack and interleave high packed double-precision floating-point values
vunpckhps=unpack and interleave high packed single-precision floating-point values
vunpcklpd=unpack and interleave low packed double-precision floating-point values
vunpcklps=unpack and interleave low packed single-precision floating-point values
vxorpd=bitwise logical xor of packed double precision floating-point values
vxorps=bitwise logical xor of packed single precision floating-point values
vzeroall=zero all ymm registers
vzeroupper=zero upper bits of ymm registers
wait=stop process execution until TEST pin activated
wbinvd=write back and invalidate cache
wrfsbase=write fs/gs segment base
wrgsbase=write fs/gs segment base
wrmsr=write to model specific register
wrpkru=write data to user page key register
xabort=transactional abort
xacquire=hardware lock elision prefix hints
xadd=exchange and add
xbegin=transactional begin
xchg=exchange register/memory with register
xend=transactional end
xgetbv=get value of extended control register
xlat=table look-up translation
xlatb=table look-up translation
xor=logical exclusive or
xorpd=bitwise logical xor for double-fp values
xorps=bitwise logical xor for single-fp values
xrelease=hardware lock elision prefix hints
xrstor=restore processor extended states
xrstors=restore processor extended states supervisor
xsave=save processor extended states
xsavec=save processor extended states with compaction
xsaveopt=save processor extended states optimized
xsaves=save processor extended states supervisor
xsetbv=set extended control register
xtest=test if in transactional execution
callf=call procedure
cmovnbe=conditional move - not below nor equal/above (cf=0 and zf=0)
cmovnc=conditional move - not carry/above or equal/not below (cf=0)
cmovne=conditional move - not equal/not zero (zf=0)
cmovng=conditional move - not greater/less or equal (zf=1 or sf!=of)
cmovnge=conditional move - not greater nor equal/less (sf!=of)
cmovnl=conditional move - not less/greater or equal (sf=of)
cmovnle=conditional move - not less nor equal/greater (zf=0 and sf=of)
cmovno=conditional move - not overflow (of=0)
cmovnp=conditional move - not parity/parity odd (pf=0)
cmovns=conditional move - not sign (sf=0)
cmovnz=conditional move - not zero/not equal (zf=0)
cmovo=conditional move - overflow (of=1)
cmovp=conditional move - parity/parity even (pf=1)
cmovpe=conditional move - parity even/parity (pf=1)
cmovpo=conditional move - parity odd/not parity (pf=0)
cmovs=conditional move - sign (sf=1)
cmovz=conditional move - zero/equal (zf=1)
cs=cs segment override prefix
ds=ds segment override prefix
es=es segment override prefix
fcmovnu=fp conditional move - not unordered (pf=0)
fdisi=disable npx (numeric coprocessor extension) interrupt
feni=enable npx (numeric coprocessor extension) interrupt
ffreep=free floating-point register and pop (undocumented)
fndisi=disable npx (numeric coprocessor extension) interrupts (8087 only, otherwise, FNOP)
fneni=enable npx (numeric coprocessor extension) interrupts (8087 only, otherwise, FNOP)
fnsetpm=set protected mode (8087 only, otherwise FNOP)
fsetpm=set protected mode
fs=fs segment override prefix
fstpnce=store floating point value and pop (undocumented)
getsec=getsec leaf functions
gs=gs segment override prefix
hint_nop=hintable nop
icebp=Single byte single-step exception / Invoke ICE
int1=call to interrupt procedure
int3=int 3, software breakpoint
invept=invalidate translations derived from ept
invvpid=invalidate translations based on vpid
iretq=interrupt return (64 bit)
jmpe=jump to ia-64 instruction set
jmpf=jump
loadalld=loads All Registers from memory address es:edi
loadall=load all of the cpu registers
movabs=absolute data moves
popal=pop all general-purpose registers
pushal=push all general-purpose registers
pushfq=push rflags register onto the stack
repe=repeat string
repne=repeat string operation prefix
repnz=repeat string operation prefix
rep=repeats next instruction ECX times
repz=repeat string operation prefix
retf=return from procedure
retn=return from procedure
rex=access to new 8-bit registers
rex.b=extension of r/m field, base field, or opcode reg field
rex.rb=rex.r and rex.b combination
rex.r=extension of modr/m reg field
rex.rxb=rex.r, rex.x and rex.b combination
rex.rx=rex.r and rex.x combination
rex.w=64 bit operand size
rex.wb=rex.w and rex.b combination
rex.wrb=rex.w, rex.r and rex.b combination
rex.wr=rex.w and rex.r combination
rex.wrxb=rex.w, rex.r, rex.x and rex.b combination
rex.wrx=rex.w, rex.r and rex.x combination
rex.wxb=rex.w, rex.x and rex.b combination
rex.wx=rex.w and rex.x combination
rex.xb=rex.x and rex.b combination
rex.x=extension of sib index field
rtdsc=read time-stamp counter into edx:eax
salc=set al if carry
scasq=cmp rax, ES:[rdi+=8]
setnle=set byte on condition - not less nor equal/greater (zf=0 and sf=of)
ss=ss segment override prefix
ud1=undefined instruction
vmcall=call to vm monitor
vmclear=clear virtual-machine control structure
vmlaunch=launch virtual machine
vmptrld=load pointer to virtual-machine control structure
vmptrst=store pointer to virtual-machine control structure
vmread=read field from virtual-machine control structure
vmresume=resume virtual machine
vmwrite=write field to virtual-machine control structure
vmxoff=leave vmx operation
vmxon=enter vmx operation