80X86 INSTRUCTION SET CHART

00 /r       ADD eb,rb      Add byte register into EA byte
01 /r       ADD ew,rw      Add word register into EA word
02 /r       ADD rb,eb      Add EA byte into byte register
03 /r       ADD rw,ew      Add EA word into word register
04 ib       ADD AL,ib      Add immediate byte into AL
05 iw       ADD AX,iw      Add immediate word into AX
06          PUSH ES        Set [SP-2] to ES, then decrement SP by 2
07          POP ES         Set ES to top of stack, increment SP by 2
08 /r       OR eb,rb       Logical-OR byte register into EA byte
09 /r       OR ew,rw       Logical-OR word register into EA word
0A /r       OR rb,eb       Logical-OR EA byte into byte register
0B /r       OR rw,ew       Logical-OR EA word into word register
0C ib       OR AL,ib       Logical-OR immediate byte into AL
0D iw       OR AX,iw       Logical-OR immediate word into AX
0E          PUSH CS        Set [SP-2] to CS, then decrement SP by 2
0F 00 /0   *SLDT ew        Store Local Descriptor Table register to EA word
0F 00 /1   *STR ew         Store Task Register to EA word
0F 00 /2   *LLDT ew        Load selector ew into Local Descriptor Table reg
0F 00 /3   *LTR ew         Load EA word into Task Register
0F 00 /4   *VERR ew        Set ZF=1 if segment can be read, selector ew
0F 00 /5   *VERW ew        Set ZF=1 if segment can be written to, selector ew
0F 01 /0   *SGDT m         Store 6-byte Global Descriptor Table register to M
0F 01 /1   *SIDT m         Store 6-byte Interrupt Descriptor Table register to M
0F 01 /2   *LGDT m         Load 6 bytes at m into Global Descriptor Table reg
0F 01 /3   *LIDT m         Load 6 bytes at m into Interrupt Descriptor Table reg
0F 01 /4   *SMSW ew        Store Machine Status Word to EA word
0F 01 /6   *LMSW ew        Load EA word into Machine Status Word
0F 02 /r   *LAR rw,ew      Load: high(rw) = Access Rights byte, selector ew
0F 03 /r   *LSL rw,ew      Load: rw = Segment Limit, selector ew
0F 06      *CLTS           Clear task switched flag
0F 10/0    #TESTBIT eb,CL  Test bit CL of eb, set Z flag
0F 11/0    #TESTBIT ew,CL  Test bit CL of ew, set Z flag
0F 12/0    #CLRBIT eb,CL   Clear bit CL of eb
0F 13/0    #CLRBIT ew,CL   Clear bit CL of ew
0F 14/0    #SETBIT eb,CL   Set bit CL of eb
0F 15/0    #SETBIT ew,CL   Set bit CL of ew
0F 16/0    #NOTBIT eb,CL   Complement bit CL of eb
0F 17/0    #NOTBIT ew,CL   Complement bit CL of ew
0F 18/0 ib #TESTBIT eb,ib  Test bit ib of eb, set Z flag
0F 19/0 ib #TESTBIT ew,ib  Test bit ib of ew, set Z flag
0F 1A/0 ib #CLRBIT eb,ib   Clear bit ib of eb
0F 1B/0 ib #CLRBIT ew,ib   Clear bit ib of ew
0F 1C/0 ib #SETBIT eb,ib   Set bit ib of eb
0F 1D/0 ib #SETBIT ew,ib   Set bit ib of ew
0F 1E/0 ib #NOTBIT eb,ib   Complement bit ib of eb
0F 1F/0 ib #NOTBIT ew,ib   Complement bit ib of ew
0F 20      #ADD4S          Add CL nibbles BCD from DS:SI into ES:DI (CL even,NZ)
0F 22      #SUB4S          Sub CL nibbles BCD at DS:SI from ES:DI (CL even,NZ)
0F 26      #CMP4S          Compare CL nibbles CD at DS:SI from ES:DI (CL even,NZ)
0F 28/0    #ROL4 eb        Rotate nibbles: Heb=Leb   HAL,Leb=LAL  LAL=Heb
0F 2A/0    #ROR4 eb        Rotate nibbles: Leb=Heb   Heb=LAL  AL=eb
0F 31/r    #STOBITS rb,rb  Store AX to ES:DI,bit rb (incr. DI,rb), rb+1 bits
0F 33/r    #LODBITS rb,rb  Load AX with DS:SI,bit rb (incr. SI,rb), rb+1 bits
0F 39/0 ib #STOBITS rb,ib  Store AX to ES:DI,bit rb (incr. DI,rb), ib+1 bits
0F 3B/0 ib #LODBITS rb,ib  Load AX with DS:SI,bit rb (incr. SI,rb), ib+1 bits
0F FF ib   #CALL80 ib      Call 8080-emulation code at INT number ib








10 /r       ADC eb,rb      Add with carry byte register into EA byte
11 /r       ADC ew,rw      Add with carry word register into EA word
12 /r       ADC rb,eb      Add with carry EA byte into byte register
13 /r       ADC rw,ew      Add with carry EA word into word register
14 ib       ADC AL,ib      Add with carry immediate byte into AL
15 iw       ADC AX,iw      Add with carry immediate word into AX
16          PUSH SS        Set [SP-2] to SS, then decrement SP by 2
17          POP SS         Set SS to top of stack, increment SP by 2
18 /r       SBB eb,rb      Subtract with borrow byte register from EA byte
19 /r       SBB ew,rw      Subtract with borrow word register from EA word
1A /r       SBB rb,eb      Subtract with borrow EA byte from byte register
1B /r       SBB rw,ew      Subtract with borrow EA word from word register
1C ib       SBB AL,ib      Subtract with borrow immediate byte from AL
1D iw       SBB AX,iw      Subtract with borrow immediate word from AX
1E          PUSH DS        Set [SP-2] to DS, then decrement SP by 2
1F          POP DS         Set DS to top of stack, increment SP by 2

20 /r       AND eb,rb      Logical-AND byte register into EA byte
21 /r       AND ew,rw      Logical-AND word register into EA word
22 /r       AND rb,eb      Logical-AND EA byte into byte register
23 /r       AND rw,ew      Logical-AND EA word into word register
24 ib       AND AL,ib      Logical-AND immediate byte into AL
25 iw       AND AX,iw      Logical-AND immediate word into AX
27          DAA            Decimal adjust AL after addition
28 /r       SUB eb,rb      Subtract byte register from EA byte
29 /r       SUB ew,rw      Subtract word register from EA word
2A /r       SUB rb,eb      Subtract EA byte from byte register
2B /r       SUB rw,ew      Subtract EA word from word register
2C ib       SUB AL,ib      Subtract immediate byte from AL
2D iw       SUB AX,iw      Subtract immediate word from AX
2F          DAS            Decimal adjust AL after subtraction

30 /r       XOR eb,rb      Exclusive-OR byte register into EA byte
31 /r       XOR ew,rw      Exclusive-OR word register into EA word
32 /r       XOR rb,eb      Exclusive-OR EA byte into byte register
33 /r       XOR rw,ew      Exclusive-OR EA word into word register
34 ib       XOR AL,ib      Exclusive-OR immediate byte into AL
35 iw       XOR AX,iw      Exclusive-OR immediate word into AX
37          AAA            ASCII adjust AL (carry into AH) after addition
38 /r       CMP eb,rb      Subtract byte register from EA byte for flags only
39 /r       CMP ew,rw      Subtract word register from EA word for flags only
3A /r       CMP rb,eb      Subtract EA byte from byte register for flags only
3B /r       CMP rw,ew      Subtract EA word from word register for flags only
3C ib       CMP AL,ib      Subtract immediate byte from AL for flags only
3D iw       CMP AX,iw      Subtract immediate word from AX for flags only
3F          AAS            ASCII adjust AL (borrow from AH) after subtraction

40+rw       INC rw         Increment word register by 1
48+rw       DEC rw         Decrement word register by 1

50+rw       PUSH rw        Set [SP-2] to word register, then decrement SP by 2
58+rw       POP rw         Set word register to top of stack, increment SP by 2

60         *PUSHA          Push AX,CX,DX,BX,original SP,BP,SI,DI
61         *POPA           Pop DI,SI,BP,SP,BX,DX,CX,AX (SP value is ignored)
62 /r      *BOUND rw,md    INT 5 if rw not between [md] and [md+2] inclusive
63 /r      *ARPL ew,rw     Adjust RPL of EA word not smaller than RPL of rw
64         #REPNC (prfix)  Repeat following CMPS or SCAS CX times or until CF=1
65         #REPC (prefix)  Repeat following CMPS or SCAS CX times or until CF=0
68 iw      *PUSH iw        Set [SP-2] to immediate word, then decrement SP by 2
69 /r iw   *IMUL rw,ew,iw  Signed multiply (rw = EA word * immediate word)
69 /r iw   *IMUL rw,iw     Signed multiply immediate word into word register
6A ib      *PUSH ib        Push sign-extended immediate byte
6B /r ib   *IMUL rw,ew,ib  Signed multiply (rw = EA word * immediate byte)
6B /r ib   *IMUL rw,ib     Signed multiply immediate byte into word register

6C         *INS eb,DX      Input byte from port DX into [DI]
6C         *INSB           Input byte from port DX into ES:[DI]
6D         *INS ew,DX      Input word from port DX into [DI]
6D         *INSW           Input word from port DX into ES:[DI]
6E         *OUTS DX,eb     Output byte [SI] to port number DX, advance SI
6E         *OUTSB          Output byte DS:[SI] to port number DX, advance SI
6F         *OUTS DX,ew     Output word [SI] to port number DX, advance SI
6F         *OUTSW          Output word DS:[SI] to port number DX, advance SI

70 cb       JO cb          Jump short if overflow (OF=1)
71 cb       JNO cb         Jump short if not overflow (OF=0)
72 cb       JB cb          Jump short if below (CF=1)             below=UNSIGNED
72 cb       JC cb          Jump short if carry (CF=1)
72 cb       JNAE cb        Jump short if not above or equal (CF=1)
73 cb       JAE cb         Jump short if above or equal (CF=0)
73 cb       JNB cb         Jump short if not below (CF=0)
73 cb       JNC cb         Jump short if not carry (CF=0)
74 cb       JE cb          Jump short if equal (ZF=1)
74 cb       JZ cb          Jump short if zero (ZF=1)
75 cb       JNE cb         Jump short if not equal (ZF=0)
75 cb       JNZ cb         Jump short if not zero (ZF=0)
76 cb       JBE cb         Jump short if below or equal (CF=1 or ZF=1)
76 cb       JNA cb         Jump short if not above (CF=1 or ZF=1)
77 cb       JA cb          Jump short if above (CF=0 and ZF=0)   above=UNSIGNED
77 cb       JNBE cb        Jump short if not below or equal (CF=0 and ZF=0)
78 cb       JS cb          Jump short if sign (SF=1)
79 cb       JNS cb         Jump short if not sign (SF=0)
7A cb       JP cb          Jump short if parity (PF=1)
7A cb       JPE cb         Jump short if parity even (PF=1)
7B cb       JNP cb         Jump short if not parity (PF=0)
7B cb       JPO cb         Jump short if parity odd (PF=0)
7C cb       JL cb          Jump short if less (SF/=OF) less=SIGNED
7C cb       JNGE cb        Jump short if not greater or equal (SF/=OF)
7D cb       JGE cb         Jump short if greater or equal (SF=OF)
7D cb       JNL cb         Jump short if not less (SF=OF)
7E cb       JLE cb         Jump short if less or equal (ZF=1 or SF/=OF)
7E cb       JNG cb         Jump short if not greater (ZF=1 or SF/=OF)
7F cb       JG cb          Jump short if greater (ZF=0 and SF=OF) greater=SIGNED
7F cb       JNLE cb        Jump short if not less or equal (ZF=0 and SF=OF)

80 /0 ib    ADD eb,ib      Add immediate byte into EA byte
80 /1 ib    OR eb,ib       Logical-OR immediate byte into EA byte
80 /2 ib    ADC eb,ib      Add with carry immediate byte into EA byte
80 /3 ib    SBB eb,ib      Subtract with borrow immediate byte from EA byte
80 /4 ib    AND eb,ib      Logical-AND immediate byte into EA byte
80 /5 ib    SUB eb,ib      Subtract immediate byte from EA byte
80 /6 ib    XOR eb,ib      Exclusive-OR immediate byte into EA byte
80 /7 ib    CMP eb,ib      Subtract immediate byte from EA byte for flags only
81 /0 iw    ADD ew,iw      Add immediate word into EA word
81 /1 iw    OR ew,iw       Logical-OR immediate word into EA word
81 /2 iw    ADC ew,iw      Add with carry immediate word into EA word
81 /3 iw    SBB ew,iw      Subtract with borrow immediate word from EA word
81 /4 iw    AND ew,iw      Logical-AND immediate word into EA word
81 /5 iw    SUB ew,iw      Subtract immediate word from EA word
81 /6 iw    XOR ew,iw      Exclusive-OR immediate word into EA word
81 /7 iw    CMP ew,iw      Subtract immediate word from EA word for flags only
83 /0 ib    ADD ew,ib      Add immediate byte into EA word
83 /1 ib    OR ew,ib       Logical-OR immediate byte into EA word
83 /2 ib    ADC ew,ib      Add with carry immediate byte into EA word
83 /3 ib    SBB ew,ib      Subtract with borrow immediate byte from EA word
83 /4 ib    AND ew,ib      Logical-AND immediate byte into EA word
83 /5 ib    SUB ew,ib      Subtract immediate byte from EA word
83 /6 ib    XOR ew,ib      Exclusive-OR immediate byte into EA word
83 /7 ib    CMP ew,ib      Subtract immediate byte from EA word for flags only
84 /r       TEST eb,rb     AND byte register into EA byte for flags only
84 /r       TEST rb,eb     AND EA byte into byte register for flags only
85 /r       TEST ew,rw     AND word register into EA word for flags only
85 /r       TEST rw,ew     AND EA word into word register for flags only
86 /r       XCHG eb,rb     Exchange byte register with EA byte
86 /r       XCHG rb,eb     Exchange EA byte with byte register
87 /r       XCHG ew,rw     Exchange word register with EA word
87 /r       XCHG rw,ew     Exchange EA word with word register
88 /r       MOV eb,rb      Move byte register into EA byte
89 /r       MOV ew,rw      Move word register into EA word
8A /r       MOV rb,eb      Move EA byte into byte register
8B /r       MOV rw,ew      Move EA word into word register
8C /0       MOV ew,ES      Move ES into EA word
8C /1       MOV ew,CS      Move CS into EA word
8C /2       MOV ew,SS      Move SS into EA word
8C /3       MOV ew,DS      Move DS into EA word
8D /r       LEA rw,m       Calculate EA offset given by m, place in rw
8E /0       MOV ES,mw      Move memory word into ES
8E /0       MOV ES,rw      Move word register into ES
8E /2       MOV SS,mw      Move memory word into SS
8E /2       MOV SS,rw      Move word register into SS
8E /3       MOV DS,mw      Move memory word into DS
8E /3       MOV DS,rw      Move word register into DS
8F /0       POP mw         Set memory word to top of stack, increment SP by 2

90          NOP            No Operation
98          CBW            Convert byte into word (AH = top bit of AL)
99          CWD            Convert word to doubleword (DX = top bit of AX)
9A cd       CALL cd        Call far segment, immediate 4-byte address
9B          WAIT           Wait until BUSY pin is inactive (HIGH)
9C          PUSHF          Set [SP-2] to flags register, then decrement SP by 2
9D          POPF           Set flags register to top of stack, increment SP by 2
9E          SAHF           Store AH into flags  SF ZF xx AF xx PF xx CF
9F          LAHF           Load: AH = flags  SF ZF xx AF xx PF xx CF
9r          XCHG AX,rw     Exchange word register with AX
9r          XCHG rw,AX     Exchange  with word register

A0 iw       MOV AL,xb      Move byte variable (offset iw) into AL
A1 iw       MOV AX,xw      Move word variable (offset iw) into AX
A2 iw       MOV xb,AL      Move AL into byte variable (offset iw)
A3 iw       MOV xw,AX      Move AX into word register (offset iw)
A4          MOVS mb,mb     Move byte [SI] to ES:[DI], advance SI and DI
A4          MOVSB          Move byte DS:[SI] to ES:[DI], advance SI and DI
A5          MOVS mw,mw     Move word [SI] to ES:[DI], advance SI and DI
A5          MOVSW          Move word DS:[SI] to ES:[DI], advance SI and DI
A6          CMPS mb,mb     Compare bytes ES:[DI] from [SI], advance SI and DI
A6          CMPSB          Compare bytes ES:[DI] from DS:[SI], advance SI and DI
A7          CMPS mw,mw     Compare words ES:[DI] from [SI], advance SI and DI
A7          CMPSW          Compare words ES:[DI] from DS:[SI], advance SI and DI
A8 ib       TEST AL,ib     AND immediate byte into AL for flags only
A9 iw       TEST AX,iw     AND immediate word into AX for flags only
AA          STOS mb        Store AL to byte [DI], advance DI
AA          STOSB          Store AL to byte ES:[DI], advance DI
AB          STOS mw        Store AX to word [DI], advance DI
AB          STOSW          Store AX to word ES:[DI], advance DI
AC          LODS mb        Load byte [SI] into AL, advance SI
AC          LODSB          Load byte [SI] into AL, advance SI
AD          LODS mw        Load word [SI] into AX, advance SI
AD          LODSW          Load word [SI] into AX, advance SI
AE          SCAS mb        Compare bytes AL - ES:[DI], advance DI
AE          SCASB          Compare bytes AX - ES:[DI], advance DI
AF          SCAS mw        Compare words AL - ES:[DI], advance DI
AF          SCASW          Compare words AX - ES:[DI], advance DI

B0+rb ib    MOV rb,ib      Move immediate byte into byte register
B8+rw iw    MOV rw,iw      Move immediate word into word register


C0 /0 ib   *ROL eb,ib      Rotate 8-bit EA byte left ib times
C0 /1 ib   *ROR eb,ib      Rotate 8-bit EA byte right ib times
C0 /2 ib   *RCL eb,ib      Rotate 9-bit quantity (CF, EA byte) left ib times
C0 /3 ib   *RCR eb,ib      Rotate 9-bit quantity (CF, EA byte) right ib times
C0 /4 ib   *SAL eb,ib      Multiply EA byte by 2, ib times
C0 /4 ib   *SHL eb,ib      Multiply EA byte by 2, ib times
C0 /5 ib   *SHR eb,ib      Unsigned divide EA byte by 2, ib times
C0 /7 ib   *SAR eb,ib      Signed divide EA byte by 2, ib times
C1 /0 ib   *ROL ew,ib      Rotate 16-bit EA word left ib times
C1 /1 ib   *ROR ew,ib      Rotate 16-bit EA word right ib times
C1 /2 ib   *RCL ew,ib      Rotate 17-bit quantity (CF, EA word) left ib times
C1 /3 ib   *RCR ew,ib      Rotate 17-bit quantity (CF, EA word) right ib times
C1 /4 ib   *SAL ew,ib      Multiply EA word by 2, ib times
C1 /4 ib   *SHL ew,ib      Multiply EA word by 2, ib times
C1 /5 ib   *SHR ew,ib      Unsigned divide EA word by 2, ib times
C1 /7 ib   *SAR ew,ib      Signed divide EA word by 2, ib times
C2 iw       RET iw         RET (near), pop offset, iw bytes pushed before Call
C3          RET            Return to near caller (pop offset only)
C4 /r       LES rw,ed      Load EA doubleword into ES and word register
C5 /r       LDS rw,ed      Load EA doubleword into DS and word register
C6 /0 ib    MOV eb,ib      Move immediate byte into EA byte
C7 /0 iw    MOV ew,iw      Move immediate word into EA word
C8 iw 00   *ENTER iw,0     Make stack frame, iw bytes local storage, 0 levels
C8 iw 01   *ENTER iw,1     Make stack frame, iw bytes local storage, 1 level
C8 iw ib   *ENTER iw,ib    Make stack frame, iw bytes local storage, ib levels
C9         *LEAVE          Set SP to BP, then POP BP (reverses previous ENTER)
CA iw       RETF iw        RET (far), pop offset, seg, iw bytes
CB          RETF           Return to far caller (pop offset, then seg)
CC          INT 3          Interrupt 3 (trap to debugger) (far call, with flags
CD ib       INT ib         Interrupt numbered by immediate byte pushed first)
CE          INTO           Interrupt 4 if overflow flag is 1
CF          IRET           Interrupt return (far return and pop flags)

D0 /0       ROL eb,1       Rotate 8-bit EA byte left once
D0 /1       ROR eb,1       Rotate 8-bit EA byte right once
D0 /2       RCL eb,1       Rotate 9-bit quantity (CF, EA byte) left once
D0 /3       RCR eb,1       Rotate 9-bit quantity (CF, EA byte) right once
D0 /4       SAL eb,1       Multiply EA byte by 2, once
D0 /4       SHL eb,1       Multiply EA byte by 2, once
D0 /5       SHR eb,1       Unsigned divide EA byte by 2, once
D0 /7       SAR eb,1       Signed divide EA byte by 2, once
D1 /0       ROL ew,1       Rotate 16-bit EA word left once
D1 /1       ROR ew,1       Rotate 16-bit EA word right once
D1 /2       RCL ew,1       Rotate 17-bit quantity (CF, EA word) left once
D1 /3       RCR ew,1       Rotate 17-bit quantity (CF, EA word) right once
D1 /4       SAL ew,1       Multiply EA word by 2, once
D1 /4       SHL ew,1       Multiply EA word by 2, once
D1 /5       SHR ew,1       Unsigned divide EA word by 2, once
D1 /7       SAR ew,1       Signed divide EA word by 2, once
D2 /0       ROL eb,CL      Rotate 8-bit EA byte left CL times
D2 /1       ROR eb,CL      Rotate 8-bit EA byte right CL times
D2 /2       RCL eb,CL      Rotate 9-bit quantity (CF, EA byte) left CL times
D2 /3       RCR eb,CL      Rotate 9-bit quantity (CF, EA byte) right CL times
D2 /4       SAL eb,CL      Multiply EA byte by 2, CL times
D2 /4       SHL eb,CL      Multiply EA byte by 2, CL times
D2 /5       SHR eb,CL      Unsigned divide EA byte by 2, CL times
D2 /7       SAR eb,CL      Signed divide EA byte by 2, CL times
D3 /0       ROL ew,CL      Rotate 16-bit EA word left CL times
D3 /1       ROR ew,CL      Rotate 16-bit EA word right CL times
D3 /2       RCL ew,CL      Rotate 17-bit quantity (CF, EA word) left CL times
D3 /3       RCR ew,CL      Rotate 17-bit quantity (CF, EA word) right CL times
D3 /4       SAL ew,CL      Multiply EA word by 2, CL times
D3 /4       SHL ew,CL      Multiply EA word by 2, CL times
D3 /5       SHR ew,CL      Unsigned divide EA word by 2, CL times
D3 /7       SAR ew,CL      Signed divide EA word by 2, CL times
D4 0A       AAM            ASCII adjust after multiply (AL/10: AH=Quo AL=Rem)
D5 0A       AAD            ASCII adjust before division (AX = 10*AH + AL)
D7          XLAT mb        Set AL to memory byte [BX + unsigned AL]
D7          XLATB          Set AL to memory byte DS:[BX + unsigned AL]

E0 cb       LOOPNE cb      noflags DEC CX; jump short if CX/=0 and not equal
E0 cb       LOOPNZ cb      noflags DEC CX; jump short if CX/=0 and ZF=0
E1 cb       LOOPE cb       noflags DEC CX; jump short if CX/=0 and equal (ZF=1)
E1 cb       LOOPZ cb       noflags DEC CX; jump short if CX/=0 and zero (ZF=1)
E2 cb       LOOP cb        noflags DEC CX; jump short if CX/=0
E3 cb       JCXZ cb        Jump short if CX register is zero
E4 ib       IN AL,ib       Input byte from immediate port into AL
E5 ib       IN AX,ib       Input word from immediate port into AX
E6 ib       OUT ib,AL      Output byte AL to immediate port number ib
E7 ib       OUT ib,AX      Output word AX to immediate port number ib
E8 cw       CALL cw        Call near, offset relative to next instruction
E9 cw       JMP cw         Jump near (word offset relative to next instruction)
EA cd       JMP cd         Jump far (4-byte immediate address)
EB cb       JMP cb         Jump short (signed byte relative to next instruction)
EC          IN AL,DX       Input byte from port DX into AL
ED          IN AX,DX       Input word from port DX into AX
EE          OUT DX,AL      Output byte AL to port number DX
EF          OUT DX,AX      Output word AX to port number DX

F0          LOCK (prefix)  Assert BUSLOCK signal for the next instruction
F2          REPNE (prfix)  Repeat following CMPS or SCAS CX times or until ZF=1
F2          REPNZ (prfix)  Repeat following CMPS or SCAS CX times or until ZF=1
F3          REP (prefix)   Repeat following MOVS,LODS,STOS,INS, or OUTS CX times
F3          REPE (prefix)  Repeat following CMPS or SCAS CX times or until ZF=0
F3          REPZ (prefix)  Repeat following CMPS or SCAS CX times or until ZF=0
F4          HLT            Halt
F5          CMC            Complement carry flag
F6 /0 ib    TEST eb,ib     AND immediate byte into EA byte for flags only
F6 /2       NOT eb         Reverse each bit of EA byte
F6 /3       NEG eb         Two's complement negate EA byte
F6 /4       MUL eb         Unsigned multiply (AX = AL * EA byte)
F6 /5       IMUL eb        Signed multiply (AX = AL * EA byte)
F6 /6       DIV eb         Unsigned divide AX by EA byte (AL=Quo AH=Rem)
F6 /7       IDIV eb        Signed divide AX by EA byte (AL=Quo AH=Rem)
F7 /0 iw    TEST ew,iw     AND immediate word into EA word for flags only
F7 /2       NOT ew         Reverse each bit of EA word
F7 /3       NEG ew         Two's complement negate EA word
F7 /4       MUL ew         Unsigned multiply (DXAX = AX * EA word)
F7 /5       IMUL ew        Signed multiply (DXAX = AX * EA word)
F7 /6       DIV ew         Unsigned divide DXAX by EA word (AX=Quo DX=Rem)
F7 /7       IDIV ew        Signed divide DXAX by EA word (AX=Quo DX=Rem)
F8          CLC            Clear carry flag
F9          STC            Set carry flag
FA          CLI            Clear interrupt enable flag; interrupts disabled
FB          STI            Set interrupt enable flag, interrupts enabled
FC          CLD            Clear direction flag so SI and DI will increment
FD          STD            Set direction flag so SI and DI will decrement
FE /0       INC eb         Increment EA byte by 1
FE /1       DEC eb         Decrement EA byte by 1
FF /0       INC ew         Increment EA word by 1
FF /1       DEC ew         Decrement EA word by 1
FF /2       CALL ew        Call near, offset absolute at EA word
FF /3       CALL ed        Call far segment, address at EA doubleword
FF /4       JMP ew         Jump near to EA word (absolute offset)
FF /5       JMP md         Jump far (4-byte address in memory doubleword)
FF /6       PUSH mw        Set [SP-2] to memory word, then decrement SP by 2
