Table of Contents

https://sysprog.ru/post/komanda-cmp https://flatassembler.net/docs.php?article=manual http://www.club155.ru/x86cmd/MUL

FASM

Data sizes, definitions, Constants and labels

Operator Bits Bytes
byte81
word162
dword324
fword486
pword486
qword648
tbyte8010
tword8010
dqword12816
xword12816
qqword25632
yword25632
dqqword51264
zword51264

Definitions

Size (bytes)Define dataReserve data
1db
file
rb
2dw
du
rw
4ddrd
6dp
df
rp
rf
8dqrq
10dtrt
db 1,2,3
db 'abc'
dp 1234:5678
df 1234:5678
dt 70000:80000
dt 2670.0
db 5 dup (1,2)
file 'data.bin':10h,4

Constants and labels

count = 17
mov cx,count
-
char db 224
mov bx,char
mov dl,[char]
mov ax,[char] - error
mov ax, word [char]
label wchar word at char
mov ax,[wchar]
.label2 (wchar.label2)
@@
@r
@f

—-

Registers

TypeBitsRegisters
General8alcldlblahchdhbh
16axcxdxbxspbpsidi
32eaxecxedxebxespebpesiedi
Segment16escsssdsfsgs
Control32cr0 cr2cr3cr4
Debug32dr0dr1dr2dr3 dr6dr7
FPU80st0st1st2st3st4st5st6st7
MMX64mm0mm1mm2mm3mm4mm5mm6mm7
SSE128xmm0xmm1xmm2xmm3xmm4xmm5xmm6xmm7
AVX256ymm0ymm1ymm2ymm3ymm4ymm5ymm6ymm7
AVX-512512zmm0zmm1zmm2zmm3zmm4zmm5zmm6zmm7
Opmask64k0k1k2k3k4k5k6k7
Bounds128bnd0bnd1bnd2bnd3

Numerical expressions

100110101b
123456701233o
0x01234567890ABCDEF
01234567890ABCDEF$
01234567890ABCDEFh
"234567"
$ (current address)
$$ (base address of current addressing space)
% (number of current repeat in parts of code)
%t (current time stamp)
1.0, 1E0 and 1f define the same floating point value
PriorityOperators
0+ -
1* /
2mod
3and or xor
4shl shr
5not
6bsf bsr
7rva plt

Instruction set

MOV

Processor : 8086+
Flags : No

mov bx,ax       ; general register to general register
mov [char],al   ; general register to memory
mov bl,[char]   ; memory to general register
mov dl,32       ; immediate value to general register
mov [char],32   ; immediate value to memory
mov ax,ds       ; segment register to general register
mov [bx],ds     ; segment register to memory
mov ds,ax       ; general register to segment register
mov ds,[bx]     ; memory to segment register
mov eax,cr0     ; control register to general register
mov cr3,ebx     ; general register to control register

XCHG

Processor : 80386+
Flags : No

xchg ax,bx      ; swap two general registers
xchg al,[char]  ; swap register with memory

PUSH

Processor : 8086+
Flags : No

push ax         ; store general register
push es         ; store segment register
pushw [bx]      ; store word in memory
push 1000h      ; store immediate value
pushd [ax]      ; store double word
push ax bx cx dx; 
pusha           ; store general registers
pushaw
pushad

POP

Processor : 8086+
Flags : No

pop bx          ; restore general register
pop ds          ; restore segment register
popw [si]       ; restore memory

CWD

Processor : 8086+
Flags : No

cwd             ; convert AX to DX:AX using the sign 

CDQ

Processor : 80386+
Flags : No

cdq             ; convert EAX to EDX:EAX using the sign 

CBW

Processor : 8086+
Flags : No

cbw             ; convert AL to AX using the sign

CWDE

Processor : 80386+
Flags : No

cwde            ; convert AX to EAX using the sign 

MOVSX

Processor : 80386+
Flags : No

  movsx ax,al         ; copy byte register to word register with sign
  movsx edx,dl        ; byte register to double word register
  movsx eax,ax        ; word register to double word register
  movsx ax,byte [bx]  ; byte memory to word register
  movsx edx,byte [bx] ; byte memory to double word register
  movsx eax,word [bx] ; word memory to double word register
  

MOVZX

Processor : 80386+
Flags : No

  movsx ax,al         ; copy byte register to word register without sign
  movsx edx,dl        ; byte register to double word register
  movsx eax,ax        ; word register to double word register
  movsx ax,byte [bx]  ; byte memory to word register
  movsx edx,byte [bx] ; byte memory to double word register
  movsx eax,word [bx] ; word memory to double word register

ADD, SUB

Processor : 8086+
Flags : OF, SF, ZF, AF, CF, PF

  add ax,bx       ; add register to register
  sub ax,bx       ; subtract register from register
  add ax,[si]     ; add memory to register
  add [di],al     ; add register to memory
  add al,48       ; add immediate value to register
  add [char],48   ; add immediate value to memory

ADС, SBB

Processor : 8086+
Flags : OF, SF, ZF, AF, CF, PF

  adс ax,bx       ; add register to register with CF
  sbb ax,bx       ; subtract register from register with CF
  adс ax,[si]     ; add memory to register
  adс [di],al     ; add register to memory
  adс al,48       ; add immediate value to register
  adс [char],48   ; add immediate value to memory
  

INС, DEC

Processor : 8086+
Flags : OF, SF, ZF, AF, PF

  inc ax          ; increment register by one
  dec ax          ; decrement register by one    
  inc byte [bx]   ; increment memory by one
  

CMP

Processor : 8086+
Flags : OF, SF, ZF, AF, CF, PF

  cmp ax,bx       ; compare register to register (like a SUB)

NEG

Processor : 8086+
Flags : OF, SF, ZF, AF, PF, CF

  neg ax          ; ax = 0 - ax
  

XADD

Processor : 80486+
Flags : OF, SF, ZF, AF, PF, CF

  xadd eax, ebx     ; ebx = eax & eax = eax + ebx
  

MUL

Processor : 8086+
Flags : OF, CF

  MUL r/m8          ; AX = AL * r/m8 (8086+)
  MUL r/m16         ; DX:AX = AX * r/m16 (8086+)
  MUL r/m32         ; EDX:EAX = EAX * r/m32 (80386+)
  

IMUL

Processor : 8086+, 80386+
Flags : OF, CF

  IMUL r/m8         ; AX=AL*r/m8 (8086+)
  IMUL r/m16        ; DX:AX=AX*r/m16 (8086+)
  IMUL r/m32        ; EDX:EAX=EAX*r/m32 (80386+)
  IMUL r16,r/m16    ; r16=r16*r/m16 (80386+)
  IMUL r32,r/m32    ; r32=r32*r/m32 (80386+)
  IMUL r16,r/m16,imm8    ; r16=r/m16*(знакорасширенное imm8) (80186+)
  IMUL r32,r/m32,imm8    ; r32=r/m32*(знакорасширенное imm8) (80386+)
  IMUL r16,imm8     ; r16=r16*(знакорасширенное imm8) (80186+)
  IMUL r32,imm8     ; r32=r32*(знакорасширенное imm8) (80386+)
  IMUL r16,r/m16,imm16    ; r16=r/m16*(знакорасширенное imm16) (80186+)
  IMUL r32,r/m32,imm16    ; r32=r/m32*(знакорасширенное imm16) (80386+)
  IMUL r16,imm16    ; r16=r16*imm16 (80186+)
  IMUL r32,imm32    ; r32=r32*imm32 (80386+)
  

DIV

Processor : 8086+
Flags : no

  DIV AL,r/m8       ; Беззнаковое деление AX на r/m8, частное помещается в AL, остаток от деления - в AH
                    ; (8086+)
  DIV AX,r/m16      ; Беззнаковое деление DX:AX на r/m16, частное помещается в AX, остаток от деления - в DX
                    ; (8086+)
  DIV EAX,r/m32     ; Беззнаковое деление EDX:EAX на r/m32, частное помещается в EAX,
                    ; остаток от деления - в EDX (80386+)
                    

IDIV

Processor : 8086+
Flags : no

  IDIV AL,r/m8      ; Знаковое деление AX на r/m8, частное помещается в AL, остаток от деления - в AH
                    ; (8086+)
  IDIV AX,r/m16     ; Знаковое деление DX:AX на r/m16, частное помещается в AX, остаток от деления - в DX
                    ; (8086+)
  IDIV EAX,r/m32    ; Знаковое деление EDX:EAX на r/m32, частное помещается в EAX,
                    ; остаток от деления - в EDX (80386+)
                    

DAA

Processor : 8086+
Flags : SF, ZF, AF, PF, CF

  DAA               ; Десятичная коррекция AL после сложения
                                         

DAS

Processor : 8086+
Flags : SF, ZF, AF, PF, CF

  DAS               ; Десятичная коррекция AL после вычитания                           
  

AAA

Processor : 8086+
Flags : AF, CF

  AAA               ; ASCII коррекция AL после сложения
                  

AAS

Processor : 8086+
Flags : AF, CF

  AAS               ; ASCII коррекция AL после вычитания
  

AAM

Processor : 8086+
Flags : SF, ZF, PF

  AAM               ; ASCII коррекция AX после умножения
  AAM imm8          ; ASCII коррекция AX после умножения по числу, базирующемуся на imm8
  

AAD

Processor : 8086+
Flags : SF, ZF, PF

  AAD               ; ASCII коррекция AX перед делением
  AAD imm8          ; ASCII коррекция AX перед делением по числу, базирующемуся на imm8

NOT

Processor : 8086+
Flags : no

  NOT r/m8          ; r/m8 = NOT r/m8 (8086+)
  NOT r/m16         ; r/m16 = NOT r/m16 (8086+)
  NOT r/m32         ; r/m32 = NOT r/m32 (80386+)

AND

Processor : 8086+
Flags : OF, SF, ZF, PF, CF

20 /r   AND r/m8,r8        ; r/m8 AND r8 (8086+)
21 /r   AND r/m16,r16      ; r/m16 AND r16 (8086+)
21 /r   AND r/m32,r32      ; r/m32 AND r32 (80386+)
22 /r   AND r8,r/m8        ; r8 AND r/m8 (8086+)
23 /r   AND r16,r/m16      ; r16 AND r/m16 (8086+)
23 /r   AND r32,r/m32      ; r32 AND r/m32 (80386+)
24 ib   AND AL,imm8        ; АL AND imm8 (8086+)
25 iw   AND AX,imm16       ; AX AND imm16 (8086+)
25 id   AND EAX,imm32      ; EAX AND imm32 (80386+)
80 /4 ib  AND r/m8,imm8    ; r/m8 AND imm8 (8086+)
81 /4 iw  AND r/m16,imm16  ; r/m16 AND imm16 (8086+)
81 /4 id  AND r/m32,imm32  ; r/m32 AND imm32 (80386+)
83 /4 ib  AND r/m16,imm8   ; r/m16 AND imm8 (знакорасшир.) (8086+)
83 /4 ib  AND r/m32,imm8   ; r/m32 AND imm8 (знакорасшир.) (80386+)

OR

Processor : 8086+
Flags : OF, SF, ZF, PF, CF

0C ib     OR AL,imm8         ; AL = AL OR imm8 (8086+)
0D iw     OR AX,imm16        ; AX = AX OR imm16 (8086+)
0D id     OR EAX,imm32       ; EAX = EAX OR imm32 (80386+)
80 /1 ib  OR r/m8,imm8     ; r/m8 = r/m8 OR imm8 (8086+)
81 /1 iw  OR r/m16,imm16   ; r/m16 = r/m16 OR imm16 (8086+)
81 /1 id  OR r/m32,imm32   ; r/m32 = r/m32 OR imm32 (80386+)
83 /1 ib  OR r/m16,imm8    ; r/m16 = r/m16 OR (Знакорасширенное imm8) (8086+)
83 /1 ib  OR r/m32,imm8    ; r/m32 = r/m32 OR (Знакорасширенное  imm8) (80386+)
08 /r     OR r/m8,r8       ; r/m8 = r/m8 OR r8 (8086+)
09 /r     OR r/m16,r16     ; r/m16 = r/m16 OR r16 (8086+)
09 /r     OR r/m32,r32     ; r/m32 = r/m32 OR r32 (80386+)
0A /r     OR r8,r/m8       ; r8 = r8 OR r/m8 (8086+)
0B /r     OR r16,r/m16     ; r16 = r16 OR r/m16 (8086+)
0B /r     OR r32,r/m32     ; r32 = r32 OR r/m32 (80386+)

XOR

Processor : 8086+
Flags : OF, SF, ZF, PF, CF

34 ib     XOR AL,imm8      ; AL = AL XOR imm8 (8086+)
35 iw     XOR AX,imm16     ; AX = AX XOR imm16 (8086+)
35 id     XOR EAX,imm32    ; EAX = EAX XOR imm32 (80386+)
80 /6 ib  XOR r/m8,imm8    ; r/m8 = r/m8 XOR imm8 (8086+)
81 /6 iw  XOR r/m16,imm16  ; r/m16 = r/m16 XOR imm16 (8086+)
81 /6 id  XOR r/m32,imm32  ; r/m32 = r/m32 XOR imm32 (80386+)
83 /6 ib  XOR r/m16,imm8   ; r/m16 = r/m16 XOR (Знакорасширенное imm8) (8086+)
83 /6 ib  XOR r/m32,imm8   ; r/m32 = r/m32 XOR (Знакорасширенное  imm8) (80386+)
30 /r     XOR r/m8,r8      ; r/m8 = r/m8 XOR r8 (8086+)
31 /r     XOR r/m16,r16    ; r/m16 = r/m16 XOR r16 (8086+)
31 /r     XOR r/m32,r32    ; r/m32 = r/m32 XOR r32 (80386+)
32 /r     XOR r8,r/m8      ; r8 = r8 XOR r/m8 (8086+)
33 /r     XOR r16,r/m16    ; r16 = r16 XOR r/m16 (8086+)
33 /r     XOR r32,r/m32    ; r32 = r32 XOR r/m32 (80386+)

BT

Processor : 80386+
Flags : CF

0F A3     BT r/m16,r16     ; Сохранить выбираемый r16 бит r/m16 в CF
0F A3     BT r/m32,r32     ; Сохранить выбираемый r32 бит r/m32 в CF
0F BA /4 ib  BT r/m16,imm8 ; Сохранить выбираемый imm8 бит r/m16 в CF
0F BA /4 ib  BT r/m32,imm8 ; Сохранить выбираемый imm8 бит r/m32 в CF

BTS

Processor : 80386+
Flags : CF

0F A3     BT r/m16,r16     ; Сохранить выбираемый r16 бит r/m16 в CF
0F AB     BTS r/m16,r16    ; Выбрать по r16 бит из r/m16 в CF установить этот бит
0F AB     BTS r/m32,r32    ; Выбрать по r32 бит из r/m32 в CF установить этот бит
0F BA /5 ib  BTS r/m16,imm8  ; Выбрать по imm8 бит из r/m16 в CF установить этот бит
0F BA /5 ib  BTS r/m32,imm8  ; Выбрать по imm8 бит из r/m32 в CF установить этот бит

BTR

Processor : 80386+
Flags : CF

0F B3        BTR r/m16,r16      ; Выбрать по r16 бит из r/m16 в CF сбросить этот бит
0F B3        BTR r/m32,r32      ; Выбрать по r32 бит из r/m32 в CF сбросить этот бит
0F BA /6 ib  BTR r/m16,imm8     ; Выбрать по imm8 бит из r/m16 в CF сбросить этот бит
0F BA /6 ib  BTR r/m32,imm8     ; Выбрать по imm8 бит из r/m32 в CF сбросить этот бит

BTC

Processor : 80386+
Flags : CF

0F BB        BTC r/m16,r16      ; Выбрать по r16 бит из r/m16 в CF инвертировать этот бит
0F BB        BTC r/m32,r32      ; Выбрать по r32 бит из r/m32 в CF инвертировать этот бит
0F BA /7 ib  BTC r/m16,imm8     ; Выбрать по imm8 бит из r/m16 в CF инвертировать этот бит
0F BA /7 ib  BTC r/m32,imm8     ; Выбрать по imm8 бит из r/m32 в CF инвертировать этот бит

BSF

Processor : 80386+
Flags : ZF

0F BC        BSF r16,r/m16      ; Сканирование битов r/m16 вперед
0F BC        BSF r32,r/m32      ; Сканирование битов r/m32 вперед

BSR

Processor : 80386+
Flags : ZF

0F BD        BSR r16,r/m16      ; Сканирование битов r/m16 назад
0F BD        BSR r32,r/m32      ; Сканирование битов r/m32 назад

SHL, SHR, SAL, SAR

Processor : 8086+
Flags : SF, ZF, PF, CF

D0 /4       SAL r/m8,1          ; Арифметический сдвиг r/m8 влево (r/m8 = r/m8 * 2) (8086+)
D2 /4       SAL r/m8,CL         ; Арифметический сдвиг r/m8 влево (r/m8 = r/m8 * 2^CL) (8086+)
C0 /4 ib    SAL r/m8,imm8       ; Арифметический сдвиг r/m8 влево (r/m8 = r/m8 * 2^imm8) (8086+)
D1 /4       SAL r/m16,1         ; Арифметический сдвиг r/m16 влево (r/m16 = r/m16 * 2) (8086+)
D3 /4       SAL r/m16,CL        ; Арифметический сдвиг r/m16 влево (r/m16 = r/m16 * 2^CL) (8086+)
C1 /4 ib    SAL r/m16,imm8      ; Арифметический сдвиг r/m16 влево (r/m16 = r/m16 * 2^imm8) (8086+)
D1 /4       SAL r/m32,1         ; Арифметический сдвиг r/m32 влево (r/m32 = r/m32 * 2) (80386+)
D3 /4       SAL r/m32,CL        ; Арифметический сдвиг r/m32 влево (r/m32 = r/m32 * 2^CL) (80386+)
C1 /4 ib    SAL r/m32,imm8      ; Арифметический сдвиг r/m32 влево (r/m32 = r/m32 * 2^imm8) (80386+)
D0 /7       SAR r/m8,1          ; Арифметический сдвиг r/m8 вправо (r/m8 = sign(r/m8) * r/m8 / 2) (8086+)
D2 /7       SAR r/m8,CL         ; Арифметический сдвиг r/m8 вправо (r/m8 = sign(r/m8) * r/m8 / 2^CL) (8086+)
C0 /7 ib    SAR r/m8,imm8       ; Арифметический сдвиг r/m8 вправо (r/m8 = sign(r/m8) * r/m8 / 2^imm8) (8086+)
D1 /7       SAR r/m16,1         ; Арифметический сдвиг r/m16 вправо (r/m16 = sign(r/m16) * r/m16 / 2) (8086+)
D3 /7       SAR r/m16,CL        ; Арифметический сдвиг r/m16 вправо (r/m16 = sign(r/m16) * r/m16 / 2^CL)
C1 /7 ib    SAR r/m16,imm8      ; Арифметический сдвиг r/m16 вправо (r/m16 = sign(r/m16) * r/m16 / 2^imm8) (8086+)
D1 /7       SAR r/m32,1         ; Арифметический сдвиг r/m32 вправо (r/m32 = sign(r/m32) * r/m32 / 2) (80386+)
D3 /7       SAR r/m32,CL        ; Арифметический сдвиг r/m32 вправо (r/m32 = sign(r/m32) * r/m32 / 2^CL) (80386+)
C1 /7 ib    SAR r/m32,imm8      ; Арифметический сдвиг r/m32 вправо (r/m32 = sign(r/m32) * r/m32 / 2^imm8) (80386+)
D0 /4       SHL r/m8,1          ; Логический сдвиг r/m8 влево (r/m8 = r/m8 * 2)
D2 /4       SHL r/m8,CL         ; Логический сдвиг r/m8 влево (r/m8 = r/m8 * 2^CL) (8086+)
C0 /4 ib    SHL r/m8,imm8       ; Логический сдвиг r/m8 влево (r/m8 = r/m8 * 2^imm8) (8086+)
D1 /4       SHL r/m16,1         ; Логический сдвиг r/m16 влево (r/m16 = r/m16 * 2) (8086+)
D3 /4       SHL r/m16,CL        ; Логический сдвиг r/m16 влево (r/m16 = r/m16 * 2^CL) (8086+)
C1 /4 ib    SHL r/m16,imm8      ; Логический сдвиг r/m16 влево (r/m16 = r/m16 * 2^imm8) (8086+)
D1 /4       SHL r/m32,1         ; Логический сдвиг r/m32 влево (r/m32 = r/m32 * 2) (80386+)
D3 /4       SHL r/m32,CL        ; Логический сдвиг r/m32 влево (r/m32 = r/m32 * 2^CL) (80386+)
C1 /4 ib    SHL r/m32,imm8      ; Логический сдвиг r/m32 влево (r/m32 = r/m32 * 2^imm8) (80386+)
D0 /5       SHR r/m8,1          ; Логический сдвиг r/m8 вправо (r/m8 = |r/m8| / 2) (8086+)
D2 /5       SHR r/m8,CL         ; Логический сдвиг r/m8 вправо (r/m8 =  |r/m8| / 2^CL)
C0 /5 ib    SHR r/m8,imm8       ; Логический сдвиг r/m8 вправо (r/m8 = |r/m8| / 2^imm8) (8086+)
D1 /5       SHR r/m16,1         ; Логический сдвиг r/m16 вправо (r/m16 = |r/m16| / 2) (8086+)
D3 /5       SHR r/m16,CL        ; Логический сдвиг r/m16 вправо (r/m16 = |r/m16| / 2^CL) (8086+)
C1 /5 ib    SHR r/m16,imm8      ; Логический сдвиг r/m16 вправо (r/m16 = |r/m16| / 2^imm8) (8086+)
D1 /5       SHR r/m32,1         ; Логический сдвиг r/m32 вправо (r/m32 = |r/m32| / 2)(80386+)
D3 /5       SHR r/m32,CL        ; Логический сдвиг r/m32 вправо (r/m32 = |r/m32| / 2^CL) (80386+)
C1 /5 ib    SHR r/m32,imm8      ; Логический сдвиг r/m32 вправо (r/m32 = |r/m32| / 2^imm8) (80386+)

SHLD, SHRD

Processor : 80386+
Flags : SF, ZF, PF, CF

OF A4       SHLD r/m16,r16,imm8 ; Сдвинуть r/m16 влево на imm8 бит, заполнив сдвинутые биты битами из r16
OF A4       SHLD r/m32,r32,imm8 ; Сдвинуть r/m32 влево на imm8 бит, заполнив сдвинутые биты битами из r32
OF A5       SHLD r/m16,r16,CL   ; Сдвинуть r/m16 влево на CL бит, заполнив сдвинутые биты битами из r16
OF A5       SHLD r/m32,r32,CL   ; Сдвинуть r/m32 влево на CL бит, заполнив сдвинутые биты битами из r32
OF AC       SHRD r/m16,r16,imm8 ; Сдвинуть r/m16 вправо на imm8 бит, заполнив сдвинутые биты битами из r16
OF AC       SHRD r/m32,r32,imm8 ; Сдвинуть r/m32 вправо на imm8 бит, заполнив сдвинутые биты битами из r32
OF AD       SHRD r/m16,r16,CL   ; Сдвинуть r/m16 вправо на CL бит, заполнив сдвинутые биты битами из r16
OF AD       SHRD r/m32,r32,CL   ; Сдвинуть r/m32 вправо на CL бит, заполнив сдвинутые биты битами из r32

RCR, RCL, ROL, ROR

Processor : 8086+
Flags : OF, CF

D0 /2       RCL r/m8,1          ; Сдвинуть по кругу влево на 1 бит 9 бит (CF, r/m8) (8086+)
D2 /2       RCL r/m8,CL         ; Сдвинуть по кругу влево на CL бит 9 бит (CF, r/m8)(8086
C0 /2 ib    RCL r/m8,imm8       ; Сдвинуть по кругу влево на imm8 бит 9 бит (CF, r/m8) (80286+)
D1 /2       RCL r/m16,1         ; Сдвинуть по кругу влево на 1 бит 17 бит (CF, r/m16) (8086+)
D3 /2       RCL r/m16,CL        ; Сдвинуть по кругу влево на CL бит 17 бит (CF, r/m16) (8086+)
C1 /2 ib    RCL r/m16,imm8      ; Сдвинуть по кругу влево на imm8 бит 17 бит (CF, r/m16) (80286+)
D1 /2       RCL r/m32,1         ; Сдвинуть по кругу влево на 1 бит 33 бита (CF, r/m32) (80386+)
D3 /2       RCL r/m32,CL        ; Сдвинуть по кругу влево на CL бит 33 бита (CF, r/m32) (80386+)
C1 /2 ib    RCL r/m32,imm8      ; Сдвинуть по кругу влево на imm8 бит 33 бита (CF, r/m32) (80386+)
D0 /3       RCR r/m8,1          ; Сдвинуть по кругу вправо на 1 бит 9 бит (CF, r/m8) (8086+)
D2 /3       RCR r/m8,CL         ; Сдвинуть по кругу вправо на CL бит 9 бит (CF, r/m8) (8086+)
C0 /3 ib    RCR r/m8,imm8       ; Сдвинуть по кругу вправо на imm8 бит 9 бит (CF, r/m8) (80286+)
D1 /3       RCR r/m16,1         ; Сдвинуть по кругу вправо на 1 бит 17 бит (CF, r/m16) (8086+)
D3 /3       RCR r/m16,CL        ; Сдвинуть по кругу вправо на CL бит 17 бит (CF, r/m16) (8086+)
C1 /3 ib    RCR r/m16,imm8      ; Сдвинуть по кругу вправо на imm8 бит 17 бит (CF, r/m16) (80286+)
D1 /3       RCR r/m32,1         ; Сдвинуть по кругу вправо на 1 бит 33 бита (CF, r/m32) (80386+)
D3 /3       RCR r/m32,CL        ; Сдвинуть по кругу вправо на CL бит 33 бита (CF, r/m32) (80386+)
C1 /3 ib    RCR r/m32,imm8      ; Сдвинуть по кругу вправо на imm8 бит 33 бита (CF, r/m32) (80386+)
D0 /0       ROL r/m8,1          ; Сдвинуть по кругу влево на 1 бит 8 бит (r/m8) (8086+)
D2 /0       ROL r/m8,CL         ; Сдвинуть по кругу влево на CL бит 8 бит (r/m8) (8086+)
C0 /0 ib    ROL r/m8,imm8       ; Сдвинуть по кругу влево на imm8 бит 8 бит (r/m8) (80286+)
D1 /0       ROL r/m16,1         ; Сдвинуть по кругу влево на 1 бит 16 бит (r/m16) (8086+)
D3 /0       ROL r/m16,CL        ; Сдвинуть по кругу влево на CL бит 16 бит (r/m16) (8086+)
C1 /0 ib    ROL r/m16,imm8      ; Сдвинуть по кругу влево на imm8 бит 16 бит (r/m16) (80286+)
D1 /0       ROL r/m32,1         ; Сдвинуть по кругу влево на 1 бит 32 бита (r/m32) (80386+)
D3 /0       ROL r/m32,CL        ; Сдвинуть по кругу влево на CL бит 32 бита (r/m32) (80386+)
C1 /0 ib    ROL r/m32,imm8      ; Сдвинуть по кругу влево на imm8 бит 32 бита (r/m32) (80386+)
D0 /1       ROR r/m8,1          ; Сдвинуть по кругу вправо на 1 бит 8 бит (r/m8) (8086+)
D2 /1       ROR r/m8,CL         ; Сдвинуть по кругу вправо на CL бит 8 бит (r/m8) (8086+)
C0 /1 ib    ROR r/m8,imm8       ; Сдвинуть по кругу вправо на imm8 бит 8 бит (r/m8) (80286+)
D1 /1       ROR r/m16,1         ; Сдвинуть по кругу вправо на 1 бит 16 бит (r/m16) (8086+)
D3 /1       ROR r/m16,CL        ; Сдвинуть по кругу вправо на CL бит 16 бит (r/m16) (8086+)
C1 /1 ib    ROR r/m16,imm8      ; Сдвинуть по кругу вправо на imm8 бит 16 бит (r/m16) (80286+)
D1 /1       ROR r/m32,1         ; Сдвинуть по кругу вправо на 1 бит 32 бита (r/m32) (80386+)
D3 /1       ROR r/m32,CL        ; Сдвинуть по кругу вправо на CL бит 32 бита (r/m32) (80386+)
C1 /1 ib    ROR r/m32,imm8      ; Сдвинуть по кругу вправо на imm8 бит 32 бита (r/m32) (80386+)

TEST

Processor : 8086+
Flags : OF, SF, ZF, PF

A8 ib       TEST AL,imm8        ; Установить флаги SF, ZF, PF по результату операции imm8 AND AL (8086+)
A9 iw       TEST AX,imm16       ; Установить флаги SF, ZF, PF по результату операции imm16 AND AX (8086+)
A9 id       TEST EAX,imm32      ; Установить флаги SF, ZF, PF по результату операции imm32 AND EAX (80386+)
F6 /0 ib    TEST r/m8,imm8      ; Установить флаги SF, ZF, PF по результату операции imm8 AND r/m8 (8086+)
F7 /0 iw    TEST r/m16,imm16    ; Установить флаги SF, ZF, PF по результату операции imm16 AND r/m16 (8086+)
F7 /0 id    TEST r/m32,imm32    ; Установить флаги SF, ZF, PF по результату операции imm32 AND r/m32 (80386+)
84 /r       TEST r/m8,r8        ; Установить флаги SF, ZF, PF по результату операции r/m8 AND r8 (8086+)
85 /r       TEST r/m16,r16      ; Установить флаги SF, ZF, PF по результату операции r/m16 AND r168086
85 /r       TEST r/m32,r32      ; Установить флаги SF, ZF, PF по результату операции r/m32 AND r32 (80386+)

BSWAP

Processor : 80486+
Flags : no

0F C8+rd    BSWAP r32           ; Перестановка байтов в 32-битном регистре

JMP

Processor : 8086+
Flags : no

EB cb       JMP rel8            ; Короткий переход, 8-битное знаковое смещение задается относительно следующей команды (8086+)
E9 cw       JMP rel16           ; Ближний переход, 16-битное знаковое смещение задается относительно следующей команды (8086+)
E9 cd       JMP rel32           ; Ближний переход, 32-битное знаковое смещение задается относительно следующей команды (Intel386+)
FF /4       JMP r/m16           ; Ближний косвенный переход, r/m16 задает абсолютное смещение адреса назначения (8086+)
FF /4       JMP r/m32           ; Ближний косвенный переход, r/m32 задает абсолютное смещение адреса назначения (Intel386+)
EA cd       JMP ptr16:16        ; Дальний межсегментный переход, абсолютный адрес назначения задается 4-байтным непосредственным операндом ptr16:16 (8086+)
EA cp       JMP ptr16:32        ; Дальний межсегментный переход, абсолютный адрес назначения задается 6-байтным непосредственным операндом ptr16:32 (Intel386+)
FF /5       JMP m16:16          ; Дальний косвенный межсегментный переход, абсолютный адрес назначения задается 4-байтным операндом в ячейке памяти m16:16 (8086+)
FF /5       JMP m16:32          ; Дальний косвенный межсегментный переход, абсолютный адрес назначения задается 6-байтным операндом в ячейке памяти m16:32 (Intel386+)

CALL

Processor : 8086+
Flags : no

E8 cw       CALL rel16         ; Ближний вызов, 16-битное смещение указывается относительно следующей команды (8086+)
E8 cd       CALL rel32         ; Ближний вызов, 32-битное смещение указывается относительно следующей команды (Intel386+)
FF /2       CALL r/m16         ; Ближний вызов, 2-байтный адрес указывается в r/m16 (8086+)
FF /2       CALL r/m32         ; Ближний вызов, 4-байтный адрес указывается в r/m32 (Intel386+)
9A cd       CALL ptr16:16      ; Дальний вызов, указывается 4-байтный непосредственный адрес (8086+)
9A cp       CALL ptr16:32      ; Дальний вызов, указывается 6-байтный непосредственный адрес (Intel386+)
FF /3       CALL m16:16        ; Дальний вызов по адресу, указанному в операнде в памяти (8086+)
FF /3       CALL m16:32        ; Дальний вызов по адресу, указанному в операнде в памяти (Intel386+)

RET, RETN, RETF

Processor : 8086+
Flags : no

C3          RET               ; Ближний возврат из процедуры (8086+)
CB          RET               ; Дальний возврат из процедуры (8086+)
C2 iw       RET imm16         ; Ближний возврат из процедуры с освобождением imm16 байт в стеке (8086+)
CA iw       RET imm16         ; Дальний возврат из процедуры с освобождением imm16 байт в стеке (8086+)

IRET, IRETD

Processor : 8086+
Flags : OF, DF, IF, TF, SF, ZF, AF, PF, CF

CF          IRET              ; Возврат из прерывания при 16-битном размере операнда (8086+)
CF          IRETD             ; Возврат из прерывания при 32-битном размере операнда (80386+)

JA, JAE, JB, JBE, JC, JCXZ, JECXZ, JE, JZ, JG, JGE, JL, JLE, JNA, JNAE, JNB, JNBE, JNC, JNE, JNG, JNGE, JNL, JNLE, JNO, JNP, JNS, JNZ, JO, JP, JPE, JPO, JS

Processor : 8086+
Flags : OF, DF, IF, TF, SF, ZF, AF, PF, CF

77 cb       JA rel8           ; Короткий переход, если выше (CF=0 и ZF=0) 8086
73 cb       JAE rel8          ; Короткий переход, если выше или равно (CF=0)8086
72 cb       JB rel8           ; Короткий переход, если ниже (CF=1)8086
76 cb       JBE rel8          ; Короткий переход, если ниже или равно (CF=1 или ZF=1)8086
72 cb       JC rel8           ; Короткий переход, если перенос (CF=1)8086
E3 cb       JCXZ rel8         ; Короткий переход, если CX=0 8086
E3 cb       JECXZ rel8        ; Короткий переход, если ECX=0 Intel386
74 cb       JE rel8           ; Короткий переход, если равно (ZF=1) 8086
74 cb       JZ rel8           ; Короткий переход, если нуль (ZF=1) 8086
7F cb       JG rel8           ; Короткий переход, если больше (ZF=0 и SF=OF) 8086
7D cb       JGE rel8          ; Короткий переход, если больше или равно (SF=OF) 8086
7C cb       JL rel8           ; Короткий переход, если меньше (SF<>OF) 8086
7E cb       JLE rel8          ; Короткий переход, если меньше или равно (ZF=1 или SF<>OF) 8086
76 cb       JNA rel8          ; Короткий переход, если не выше (CF=1 или ZF=1) 8086
72 cb       JNAE rel8         ; Короткий переход, если не выше или равно (CF=1) 8086
73 cb       JNB rel8          ; Короткий переход, если не ниже (CF=0) 8086
77 cb       JNBE rel8         ; Короткий переход, если не ниже или равно (CF=0 и ZF=0) 8086
73 cb       JNC rel8          ; Короткий переход, если не перенос (CF=0) 8086
75 cb       JNE rel8          ; Короткий переход, если не равно (ZF=0) 8086
7E cb       JNG rel8          ; Короткий переход, если не больше (ZF=1 или SF<>OF) 8086
7C cb       JNGE rel8         ; Короткий переход, если не больше или равно (SF<>OF) 8086
7D cb       JNL rel8          ; Короткий переход, если не меньше (SF=OF) 8086
7F cb       JNLE rel8         ; Короткий переход, если не меньше или равно (ZF=0 и SF=OF) 8086
71 cb       JNO rel8          ; Короткий переход, если не переполнение (OF=0) 8086
7B cb       JNP rel8          ; Короткий переход, если нечетно (PF=0) 8086
79 cb       JNS rel8          ; Короткий переход, если положительно (SF=0) 8086
75 cb       JNZ rel8          ; Короткий переход, если не нуль (ZF=0) 8086
70 cb       JO rel8           ; Короткий переход, если переполнение (OF=1) 8086
7A cb       JP rel8           ; Короткий переход, если паритет (PF=1) 8086
7A cb       JPE rel8          ; Короткий переход, если четно (PF=1) 8086
7B cb       JPO rel8          ; Короткий переход, если нечетно (PF=0) 8086
78 cb       JS rel8           ; Короткий переход, если отрицательно (SF=1) 8086
0F 87 cw/cd JA rel16/32       ; Ближний переход, если выше (CF=0 и ZF=0) Intel386
0F 83 cw/cd JAE rel16/32      ; Ближний переход, если выше или равно (CF=0) Intel386
0F 82 cw/cd JB rel16/32       ; Ближний переход, если ниже (CF=1) Intel386
0F 86 cw/cd JBE rel16/32      ; Ближний переход, если ниже или равно (CF=1 или ZF=1) Intel386
0F 82 cw/cd JC rel16/32       ; Ближний переход, если перенос (CF=1) Intel386
0F 84 cw/cd JE rel16/32       ; Ближний переход, если равно (ZF=1) Intel386
0F 84 cw/cd JZ rel16/32       ; Ближний переход, если нуль (ZF=1) Intel386
0F 8F cw/cd JG rel16/32       ; Ближний переход, если больше (ZF=0 и SF=OF) Intel386
0F 8D cw/cd JGE rel16/32      ; Ближний переход, если больше или равно (SF=OF) Intel386
0F 8C cw/cd JL rel16/32       ; Ближний переход, если меньше (SF<>OF) Intel386
0F 8E cw/cd JLE rel16/32      ; Ближний переход, если меньше или равно (ZF=1 или SF<>OF) Intel386
0F 86 cw/cd JNA rel16/32      ; Ближний переход, если не выше (CF=1 или ZF=1) Intel386
0F 82 cw/cd JNAE rel16/32     ; Ближний переход, если не выше или равно (CF=1) Intel386
0F 83 cw/cd JNB rel16/32      ; Ближний переход, если не ниже (CF=0) Intel386
0F 87 cw/cd JNBE rel16/32     ; Ближний переход, если не ниже или равно (CF=0 и ZF=0) Intel386
0F 83 cw/cd JNC rel16/32      ; Ближний переход, если не перенос (CF=0) Intel386
0F 85 cw/cd JNE rel16/32      ; Ближний переход, если не равно (ZF=0) Intel386
0F 8E cw/cd JNG rel16/32      ; Ближний переход, если не больше (ZF=1 или SF<>OF) Intel386
0F 8C cw/cd JNGE rel16/32     ; Ближний переход, если не больше или равно (SF<>OF) Intel386
0F 8D cw/cd JNL rel16/32      ; Ближний переход, если не меньше (SF=OF) Intel386
0F 8F cw/cd JNLE rel16/32     ; Ближний переход, если не меньше или равно (ZF=0 и SF=OF) Intel386
0F 81 cw/cd JNO rel16/32      ; Ближний переход, если не переполнение (OF=0) Intel386
0F 8B cw/cd JNP rel16/32      ; Ближний переход, если нечетно (PF=0) Intel386
0F 89 cw/cd JNS rel16/32      ; Ближний переход, если положительно (SF=0) Intel386
0F 85 cw/cd JNZ rel16/32      ; Ближний переход, если не нуль (ZF=0) Intel386
0F 80 cw/cd JO rel16/32       ; Ближний переход, если переполнение (OF=1) Intel386
0F 8A cw/cd JP rel16/32       ; Ближний переход, если паритет (PF=1) Intel386
0F 8A cw/cd JPE rel16/32      ; Ближний переход, если четно (PF=1) Intel386
0F 8B cw/cd JPO rel16/32      ; Ближний переход, если нечетно (PF=0) Intel386
0F 88 cw/cd JS rel16/32       ; Ближний переход, если отрицательно (SF=1) Intel386

LOOP, LOOPE, LOOPZ, LOOPNE, LOOPNZ

Processor : 8086+
Flags : no

E2 cb       LOOP rel8         ; Уменьшить (E)CX и выполнить короткий переход, если (E)CX <> 0 (8086+)
E1 cb       LOOPE rel8        ; Уменьшить(E)CX и выполнить короткий переход, если (E)CX<>0 и ZF=1 (8086+)
E1 cb       LOOPZ rel8        ; Уменьшить(E)CX и выполнить короткий переход, если (E)CX<>0 и ZF=1 (8086+)
E0 cb       LOOPNE rel8       ; Уменьшить(E)CX и выполнить короткий переход, если (E)CX<>0 и ZF=0 (8086+)
E0 cb       LOOPNZ rel8       ; Уменьшить(E)CX и выполнить короткий переход, если (E)CX<>0 и ZF=0 (8086+)

INT

Processor : 8086+
Flags : no

CC          INT 3             ; Вызов прерывания 3 (#BP, точка останова) (8086+)
CD ib       INT imm8          ; Вызов прерывания imm8 (8086+)
CE          INTO              ; Вызов прерывания 4 (#OF, переполнение), если EFLAGS.OF=1 (8086+)

BOUND

Processor : 8086+
Flags : no

62 /r       BOUND r16,m16&16  ; Проверяет индекс r16 на выход за границы массива m16&16 (80186+)
62 /r       BOUND r32,m32&32  ; Проверяет индекс r32 на выход за границы массива m32&32 (80386+)

IN

Processor : 8086+
Flags : no

E4 ib       IN AL,imm8        ; Загрузить байт из порта в/в imm8 в регистр AL (8086+)
E5 ib       IN AX,imm8        ; Загрузить слово из порта в/в imm8 в регистр AL (8086+)
E5 ib       IN EAX,imm8       ; Загрузить двойное слово из порта в/в imm8 в регистр AL (80386+)
EC          IN AL,DX          ; Загрузить байт из порта в/в DX в регистр AL (8086+)
ED          IN AX,DX          ; Загрузить слово из порта в/в DX в регистр AL (8086+)
ED          IN EAX,DX         ; Загрузить двойное слово из порта в/в DX в регистр AL (80386+)

OUT

Processor : 8086+
Flags : no

E6 ib       OUT imm8,AL       ; Вывести байт из AL в порт в/в по адресу imm8 (8086+)
E7 ib       OUT imm8,AX       ; Вывести слово из AX в порт в/в по адресу imm8 (8086+)
E7 ib       OUT imm8,EAX      ; Вывести двойное слово из EAX в порт в/в по адресу imm8 (80386+)
EE          OUT DX,AL         ; Вывести байт из AL в порт в/в по адресу в DX (8086+)
EF          OUT DX,AX         ; Вывести слово из AX в порт в/в по адресу в DX (8086+)
EF          OUT DX,EAX        ; Вывести двойное слово из EAX в порт в/в по адресу в DX (80386+)

MOVS, MOVSB, MOVSW, MOVSD

Processor : 8086+
Flags : no

A4          MOVS m8,m8        ; Записать в ячейку по адресу ES:(E)DI байт из ячейки с адресом DS:(E)SI (8086+)
A5          MOVS m16,m16      ; Записать в ячейку по адресу ES:(E)DI слово из ячейки с адресом DS:(E)SI (8086+)
A5          MOVS m32,m32      ; Записать в ячейку по адресу ES:(E)DI двойное слово из ячейки с адресом DS:(E)SI (80386+)
A4          MOVSB             ; Записать в ячейку по адресу ES:(E)DI байт из ячейки с адресом DS:(E)SI (8086+)
A5          MOVSW             ; Записать в ячейку по адресу ES:(E)DI слово из ячейки с адресом DS:(E)SI (8086+)
A5          MOVSD             ; Записать в ячейку по адресу ES:(E)DI двойное слово из ячейки с адресом DS:(E)SI (80386+)

CMPS, CMPSB, CMPSW, CMPSD

Processor : 8086+
Flags : OF, SF, ZF, AF, PF, CF

A6          CMPS m8,m8        ; Сравнить байт по адресу DS:(E)SI с байтом по адресу ES:(E)DI (8086+)
A7          CMPS m16,m16      ; Сравнить слово по адресу DS:(E)SI со словом по адресу ES:(E)DI (8086+)
A7          CMPS m32,m32      ; Сравнить двойное слово по адресу DS:(E)SI с двойным словом по адресу ES:(E)DI (80386+)
A6          CMPSB             ; Сравнить байт по адресу DS:(E)SI с байтом по адресу ES:(E)DI (8086+)
A7          CMPSW             ; Сравнить слово по адресу DS:(E)SI со словом по адресу ES:(E)DI (8086+)
A7          CMPSD             ; Сравнить двойное слово по адресу DS:(E)SI с двойным словом по адресу ES:(E)DI (80386+)

SCAS, SCASB, SCASW, SCASD

Processor : 8086+
Flags : OF, SF, ZF, AF, PF, CF

AE          SCAS m8           ; Сравнить байт по адресу ES:(E)DI с AL (8086+)
AF          SCAS m16          ; Сравнить слово по адресу ES:(E)DI с AX (8086+)
AF          SCAS m32          ; Сравнить двойное слово по адресу ES:(E)DI с EAX (80386+)
AE          SCASB             ; Сравнить байт по адресу ES:(E)DI с AL (8086+)
AF          SCASW             ; Сравнить байт по адресу ES:(E)DI с AX(8086+)
AF          SCASD             ; Сравнить байт по адресу ES:(E)DI с EAX (80386+)

STOS, STOSB, STOSW, STOSD

Processor : 8086+
Flags : no

AA          STOS m8          ; Сохранить AL по адресу ES:(E)DI (8086+)
AB          STOS m16         ; Сохранить AX по адресу ES:(E)DI (8086+)
AB          STOS m32         ; Сохранить EAX по адресу ES:(E)DI (80386+)
AA          STOSB            ; Сохранить AL по адресу ES:(E)DI (8086+)
AB          STOSW            ; Сохранить AX по адресу ES:(E)DI (8086+)
AB          STOSD            ; Сохранить EAX по адресу ES:(E)DI (80386+)

LODS, LODSB, LODSW, LODSD

Processor : 8086+
Flags : no

AC          LODS m8          ; Считать байт по адресу DS:(E)SI в AL (8086+)  
AD          LODS m16         ; Считать слово по адресу DS:(E)SI в AX (8086+)
AD          LODS m32         ; Считать двойное слово по адресу DS:(E)SI в EAX (80386+)
AC          LODSB            ; Считать байт по адресу DS:(E)SI в AL (8086+)
AD          LODSW            ; Считать байт по адресу DS:(E)SI в AX (8086+)
AD          LODSD            ; Считать байт по адресу DS:(E)SI в EAX (80386+)

INS, INSB, INSW, INSD

Processor : 80286+
Flags : no

6C          INS m8,DX        ; Загрузить байт из порта в/в DX в память по адресу ES:(E)DI (80286+)
6D          INS m16,DX       ; Загрузить слово из порта в/в DX в память по адресу ES:(E)DI (80286+)
6D          INS m32,DX       ; Загрузить двойное слово из порта в/в DX в память по адресу ES:(E)DI (80386+)
6C          INSB             ; Загрузить байт из порта в/в DX в память по адресу ES:(E)DI (80286+)
6D          INSW             ; Загрузить слово из порта в/в DX в память по адресу ES:(E)DI (80286+)
6D          INSD             ; Загрузить двойное слово из порта в/в DX в память по адресу ES:(E)DI (80386+)

OUTS, OUTSB, OUTSW, OUTSD

Processor : 80286+
Flags : no

6E          OUTS DX,m8       ; Вывести байт из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80286+)
6F          OUTS DX,m16      ; Вывести слово из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80286+)
6F          OUTS DX,m32      ; Вывести двойное слово из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80386+)
6E          OUTSB            ; Вывести байт из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80286+)
6F          OUTSW            ; Вывести слово из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80286+)
6F          OUTSD            ; Вывести двойное слово из ячейки памяти DS:(E)SI в порт в/в по адресу в DX (80386+)

REP, REPE, REPNE

Processor : 8086+
Flags : no

F3 6C       REP INS r/m8,DX  ; Загрузить (E)CX байт из порта в/в DX в память по адресу ES:(E)DI (80286+)
F3 6D       REP INS r/m16,DX ; Загрузить (E)CX  слов из порта в/в DX в память по адресу ES:(E)DI (80286+)
F3 6D       REP INS r/m32,DX ; Загрузить (E)CX  двойных слов из порта в/в DX в память по адресу ES:(E)DI (80386+)
F3 A4       REP MOVS m8,m8   ; Записать по адресу ES:(E)DI блок из (E)CX байт, считываемый по адресу DS:(E)SI (8086+)
F3 A5       REP MOVS m16,m16 ; Записать по адресу ES:(E)DI блок из (E)CX  слов, считываемый по адресу DS:(E)SI (8086+)
F3 A5       REP MOVS m32,m32 ; Записать по адресу ES:(E)DI блок из (E)CX  двойных слов, считываемый по адресу DS:(E)SI (80386+)
F3 6E       REP OUTS DX,r/m8 ; Вывести блок из (E)CX байт из памяти по адресу DS:(E)SI в порт в/в по адресу в DX (80286+)
F3 6F       REP OUTS DX,r/m16 ; Вывести блок из (E)CX слов из памяти по адресу DS:(E)SI в порт в/в по адресу в DX (80286+)
F3 6F       REP OUTS DX,r/m32 ; Вывести блок из (E)CX  двойных слов из памяти по адресу DS:(E)SI в порт в/в по адрсу в DX (80386+)
F3 AC       REP LODS AL      ; Считать блок из (E)CX байт по адресу DS:(E)SI в AL (8086+)
F3 AD       REP LODS AX      ; Считать блок из (E)CX слов по адресу DS:(E)SI в AX 8086
F3 AD       REP LODS EAX     ; Считать блок из (E)CX двойных слов по адресу DS:(E)SI в EAX (80386+)
F3 AA       REP STOS m8      ; Заполнить блок из (E)CX байт по адресу ES:(E)DI содержимым AL (8086+)
F3 AB       REP STOS m16     ; Заполнить блок из (E)CX слов по адресу ES:(E)DI содержимым AX (8086+)
F3 AB       REP STOS m32     ; Заполнить блок из (E)CX двойных слов по адресу ES:(E)DI содержимым EAX (80386+)
F3 A6       REPE CMPS m8,m8  ; Найти неравные байты в блоках из (E)CX байт по адресам DS:(E)SI и ES:(E)DI (8086+)
F3 A7       REPE CMPS m16,m16 ; Найти неравные слова в блоках из (E)CX слов по адресу DS:(E)SI и ES:(E)DI (8086+)
F3 A7       REPE CMPS m32,m32 ; Найти неравные двойные слова в блоках из (E)CX двойных слов по адресу DS:(E)SI и ES:(E)DI (80386+)
F3 AE       REPE SCAS m8     ; Найти байт не равный AL в блоке из (E)CX байт по адресу ES:(E)DI (8086+)
F3 AF       REPE SCAS m16    ; Найти слово не равное AX в блоке из (E)CX слов по адресу ES:(E)DI (8086+)
F3 AF       REPE SCAS m32    ; Найти двойное слово не равное EAX в блоке из (E)CX двойных слов по адресу ES:(E)DI (80386+)
F2 A6       REPNE CMPS m8,m8 ; Найти равные байты в блоках из (E)CX байт по адресам DS:(E)SI и ES:(E)DI (8086+)
F2 A7       REPNE CMPS m16,m16 ; Найти равные слова в блоках из (E)CX слов по адресу DS:(E)SI и ES:(E)DI (8086+)
F2 A7       REPNE CMPS m32,m32 ; Найти равные двойные слова в блоках из (E)CX двойных слов по адресу DS:(E)SI и ES:(E)DI (80386+)
F2 AE       REPNE SCAS m8    ; Найти байт равный AL в блоке из (E)CX байт по адресу ES:(E)DI (8086+)
F2 AF       REPNE SCAS m16   ; Найти слово равное AX в блоке из (E)CX слов по адресу ES:(E)DI (8086+)
F2 AF       REPNE SCAS m32   ; Найти двойное слово равное EAX в блоке из (E)CX двойных слов по адресу ES:(E)DI (80386+)

STC

Processor : 8086+
Flags : CF

F9          STC              ; Установить EFLAGS.CF = 1

CLC

Processor : 8086+
Flags : CF

F8          CLC              ; Сброс флага EFLAGS.CF

CMC

Processor : 8086+
Flags : CF

F5          CMC              ; Инверсия флага EFLAGS.CF

STD

Processor : 8086+
Flags : DF

FD          STD              ; Установить EFLAGS.DF = 1

CLD

Processor : 8086+
Flags : DF

FC          CLD              ; Сброс флага EFLAGS.DF

STI

Processor : 8086+
Flags : IF

FB          STI              ; Установить флаг разрешения внешних маскируемых прерываний

CLI

Processor : 8086+
Flags : IF

FA          CLI              ; Сброс флага EFLAGS.IF (внешние маскируемые прерывания запрещены)

LAHF

Processor : 8086+
Flags : no

9F          LAHF             ; AH = EFLAGS(SF,ZF,0,AF,0,PF,1,CF)