Blinkenlights

your pc binary emulating visualizer

i8086 Encoding Rundown

┌──────ModR/M-i8086─────┬────┬────┬────┬────┬────┬────┬────┬────┐
│byte mode              │%al │%cl │%dl │%bl │%ah │%ch │%dh │%bh │
│word mode              │%ax │%cx │%dx │%bx │%sp │%bp │%si │%di │
│segment mode           │%es │%cs │%ss │%ds │%fs │%gs │    │    │
│Reg                    │0   │1   │2   │3   │4   │5   │6   │7   │
├───────────────┬───┬───┼────────────────────────┴─────────┴────┤
│Address        │Mod│R/M│Value of ModR/M Byte (in Octal)        │
├───────────────┼───┼───┼────────────────────────┬─────────┬────┤
│(%bx,%si)      │ 0 │ 0 │\000│\010│\020│\030│\040│\050│\060│\070│
│(%bx,%di)      │   │ 1 │\001│\011│\021│\031│\041│\051│\061│\071│
│(%bp,%si)      │   │ 2 │\002│\012│\022│\032│\042│\052│\062│\072│
│(%bp,%di)      │   │ 3 │\003│\013│\023│\033│\043│\053│\063│\073│
│(%si)          │   │ 4 │\004│\014│\024│\034│\044│\054│\064│\074│
│(%di)          │   │ 5 │\005│\015│\025│\035│\045│\055│\065│\075│
│abs16          │   │ 6 │\006│\016│\026│\036│\046│\056│\066│\076│
│(%bx)          │   │ 7 │\007│\017│\027│\037│\047│\057│\067│\077│
├───────────────┼───┼───┼────┼────┼────┼────┼────┼────┼────┼────┤
│disp8(%bx,%si) │ 1 │ 0 │\100│\110│\120│\130│\140│\150│\160│\170│
│disp8(%bx,%di) │   │ 1 │\101│\111│\121│\131│\141│\151│\161│\171│
│disp8(%bp,%si) │   │ 2 │\102│\112│\122│\132│\142│\152│\162│\172│
│disp8(%bp,%di) │   │ 3 │\103│\113│\123│\133│\143│\153│\163│\173│
│disp8(%si)     │   │ 4 │\104│\114│\124│\134│\144│\154│\164│\174│
│disp8(%di)     │   │ 5 │\105│\115│\125│\135│\145│\155│\165│\175│
│disp8(%bp)     │   │ 6 │\106│\116│\126│\136│\146│\156│\166│\176│
│disp8(%bx)     │   │ 7 │\107│\117│\127│\137│\147│\157│\167│\177│
├───────────────┼───┼───┼────┼────┼────┼────┼────┼────┼────┼────┤
│disp16(%bx,%si)│ 2 │ 0 │\200│\210│\220│\230│\240│\250│\260│\270│
│disp16(%bx,%di)│   │ 1 │\201│\211│\221│\231│\241│\251│\261│\271│
│disp16(%bp,%si)│   │ 2 │\202│\212│\222│\232│\242│\252│\262│\272│
│disp16(%bp,%di)│   │ 3 │\203│\213│\223│\233│\243│\253│\263│\273│
│disp16(%si)    │   │ 4 │\204│\214│\224│\234│\244│\254│\264│\274│
│disp16(%di)    │   │ 5 │\205│\215│\225│\235│\245│\255│\265│\275│
│disp16(%bp)    │   │ 6 │\206│\216│\226│\236│\246│\256│\266│\276│
│disp16(%bx)    │   │ 7 │\207│\217│\227│\237│\247│\257│\267│\277│
├───────────────┼───┼───┼────┼────┼────┼────┼────┼────┼────┼────┤
│%al/%ax/%st(0) │ 3 │ 0 │\300│\310│\320│\330│\340│\350│\360│\370│
│%cl/%cx/%st(1) │   │ 1 │\301│\311│\321│\331│\341│\351│\361│\371│
│%dl/%dx/%st(2) │   │ 2 │\302│\312│\322│\332│\342│\352│\362│\372│
│%bl/%bx/%st(3) │   │ 3 │\303│\313│\323│\333│\343│\353│\363│\373│
│%ah/%sp/%st(4) │   │ 4 │\304│\314│\324│\334│\344│\354│\364│\374│
│%ch/%bp/%st(5) │   │ 5 │\305│\315│\325│\335│\345│\355│\365│\375│
│%dh/%si/%st(6) │   │ 6 │\306│\316│\326│\336│\346│\356│\366│\376│
│%bh/%di/%st(7) │   │ 7 │\307│\317│\327│\337│\347│\357│\367│\377│
└───────────────┴───┴───┴────┴────┴────┴────┴────┴────┴────┴────┘

$:  immediate
u8: unsigned 8-bit integer
i8: sign-extended 8-bit integer
Gb: modrm.reg selects byte register
Eb: modrm.rm selects byte register or memory
Gw: modrm.reg selects word register
Ew: modrm.rm selects word register or memory
etc.

\000      add Gb,Eb              Add
\001      add Gw,Ew              Add
\002      add Eb,Gb              Add
\003      add Ew,Gw              Add
\004      add $u8,%al            Add
\005      add $i16,%ax           Add
\006      push %es               Push Word, Doubleword or Quadword Onto the Stack
\007      pop %es                Pop a Value from the Stack
\010      or Gb,Eb               Logical Inclusive OR
\011      or Gw,Ew               Logical Inclusive OR
\012      or Eb,Gb               Logical Inclusive OR
\013      or Ew,Gw               Logical Inclusive OR
\014      or $u8,%al             Logical Inclusive OR
\015      or $i16,%ax            Logical Inclusive OR
\016      push %cs               Push Word, Doubleword or Quadword Onto the Stack
\017      pop %cs                Pop a Value from the Stack
\020      adc Gb,Eb              Add with Carry
\021      adc Gw,Ew              Add with Carry
\022      adc Eb,Gb              Add with Carry
\023      adc Ew,Gw              Add with Carry
\024      adc $u8,%al            Add with Carry
\025      adc $i16,%ax           Add with Carry
\026      push %ss               Push Word, Doubleword or Quadword Onto the Stack
\027      pop %ss                Pop a Value from the Stack
\030      sbb Gb,Eb              Integer Subtraction with Borrow
\031      sbb Gw,Ew              Integer Subtraction with Borrow
\032      sbb Eb,Gb              Integer Subtraction with Borrow
\033      sbb Ew,Gw              Integer Subtraction with Borrow
\034      sbb $u8,%al            Integer Subtraction with Borrow
\035      sbb $i16,%ax           Integer Subtraction with Borrow
\036      push %ds               Push Word, Doubleword or Quadword Onto the Stack
\037      pop %ds                Pop a Value from the Stack
\040      and Gb,Eb              Logical AND
\041      and Gw,Ew              Logical AND
\042      and Eb,Gb              Logical AND
\043      and Ew,Gw              Logical AND
\044      and $u8,%al            Logical AND
\045      and $i16,%ax           Logical AND
\046      es %es                 ES segment override prefix
\047      daa %al                Decimal Adjust AL after Addition
\050      sub Gb,Eb              Subtract
\051      sub Gw,Ew              Subtract
\052      sub Eb,Gb              Subtract
\053      sub Ew,Gw              Subtract
\054      sub $u8,%al            Subtract
\055      sub $i16,%ax           Subtract
\056      cs %cs                 CS segment override prefix
\057      das %al                Decimal Adjust AL after Subtraction
\060      xor Gb,Eb              Logical Exclusive OR
\061      xor Gw,Ew              Logical Exclusive OR
\062      xor Eb,Gb              Logical Exclusive OR
\063      xor Ew,Gw              Logical Exclusive OR
\064      xor $u8,%al            Logical Exclusive OR
\065      xor $i16,%ax           Logical Exclusive OR
\066      ss %ss                 SS segment override prefix
\067      aaa %ah,%al            ASCII Adjust After Addition
\070      cmp Gb,Eb              Compare Two Operands
\071      cmp Gw,Ew              Compare Two Operands
\072      cmp Eb,Gb              Compare Two Operands
\073      cmp Ew,Gw              Compare Two Operands
\074      cmp $u8,%al            Compare Two Operands
\075      cmp $i16,%ax           Compare Two Operands
\076      ds %ds                 DS segment override prefix
\077      aas %ah,%al            ASCII Adjust AL After Subtraction
\100      inc %ax                Increment by 1
\101      inc %cx                Increment by 1
\102      inc %dx                Increment by 1
\103      inc %bx                Increment by 1
\104      inc %sp                Increment by 1
\105      inc %bp                Increment by 1
\106      inc %si                Increment by 1
\107      inc %di                Increment by 1
\110      dec %ax                Decrement by 1
\111      dec %cx                Decrement by 1
\112      dec %dx                Decrement by 1
\113      dec %bx                Decrement by 1
\114      dec %sp                Decrement by 1
\115      dec %bp                Decrement by 1
\116      dec %si                Decrement by 1
\117      dec %di                Decrement by 1
\120      push %ax               Push Word, Doubleword or Quadword Onto the Stack
\120      push %cx               Push Word, Doubleword or Quadword Onto the Stack
\120      push %dx               Push Word, Doubleword or Quadword Onto the Stack
\120      push %bx               Push Word, Doubleword or Quadword Onto the Stack
\120      push %sp               Push Word, Doubleword or Quadword Onto the Stack
\120      push %bp               Push Word, Doubleword or Quadword Onto the Stack
\120      push %si               Push Word, Doubleword or Quadword Onto the Stack
\120      push %di               Push Word, Doubleword or Quadword Onto the Stack
\130      pop %ax                Pop a Value from the Stack
\130      pop %cx                Pop a Value from the Stack
\130      pop %dx                Pop a Value from the Stack
\130      pop %bx                Pop a Value from the Stack
\130      pop %sp                Pop a Value from the Stack
\130      pop %bp                Pop a Value from the Stack
\130      pop %si                Pop a Value from the Stack
\130      pop %di                Pop a Value from the Stack
\146      osz                    Operand-size override prefix
\147      asz                    Address-size override prefix
\150      push Ivs               Push Word, Doubleword or Quadword Onto the Stack
\151      imul $i16,Ew,Gw        Signed Multiply
\152      push $i8               Push Word, Doubleword or Quadword Onto the Stack
\153      imul $i8,Ew,Gw         Signed Multiply
\154      insb %dx,Yb            Input from Port to String
\155      insw %dx,Ywo           Input from Port to String
\156      outsb Xb,%dx           Output String to Port
\157      outsw Xwo,%dx          Output String to Port
\160      jo Jbs                 Jump short if overflow (OF=1)
\161      jno Jbs                Jump short if not overflow (OF=0)
\162      jb Jbs                 Jump short if below/not above or equal/carry (CF=1)
\163      jae Jbs                Jump short if not below/above or equal/not carry (CF=0)
\164      je Jbs                 Jump short if zero/equal (ZF=1)
\165      jne Jbs                Jump short if not zero/not equal (ZF=0)
\166      jbe Jbs                Jump short if below or equal/not above (CF=1 OR ZF=1)
\167      ja Jbs                 Jump short if not below or equal/above (CF=0 AND ZF=0)
\170      js Jbs                 Jump short if sign (SF=1)
\171      jns Jbs                Jump short if not sign (SF=0)
\172      jp Jbs                 Jump short if parity/parity even (PF=1)
\173      jnp Jbs                Jump short if not parity/parity odd (PF=0)
\174      jl Jbs                 Jump short if less/not greater (SF!=OF)
\175      jge Jbs                Jump short if not less/greater or equal (SF=OF)
\176      jle Jbs                Jump short if less or equal/not greater ((ZF=1) OR (SF!=OF))
\177      jg Jbs                 Jump short if not less nor equal/greater ((ZF=0) AND (SF=OF))
\200 \.0. add $u8,Eb             Add
\200 \.1. or $u8,Eb              Logical Inclusive OR
\200 \.2. adc $u8,Eb             Add with Carry
\200 \.3. sbb $u8,Eb             Integer Subtraction with Borrow
\200 \.4. and $u8,Eb             Logical AND
\200 \.5. sub $u8,Eb             Subtract
\200 \.6. xor $u8,Eb             Logical Exclusive OR
\200 \.7. cmp $u8,Eb             Compare Two Operands
\201 \.0. add $i16,Ew            Add
\201 \.1. or $i16,Ew             Logical Inclusive OR
\201 \.2. adc $i16,Ew            Add with Carry
\201 \.3. sbb $i16,Ew            Integer Subtraction with Borrow
\201 \.4. and $i16,Ew            Logical AND
\201 \.5. sub $i16,Ew            Subtract
\201 \.6. xor $i16,Ew            Logical Exclusive OR
\201 \.7. cmp $i16,Ew            Compare Two Operands
\203 \.0. add $i8,Ew             Add
\203 \.2. adc $i8,Ew             Add with Carry
\203 \.3. sbb $i8,Ew             Integer Subtraction with Borrow
\203 \.5. sub $i8,Ew             Subtract
\203 \.7. cmp $i8,Ew             Compare Two Operands
\204      test Gb,Eb             Logical Compare
\205      test Gw,Ew             Logical Compare
\206      xchg Eb,Gb             Exchange Register/Memory with Register
\207      xchg Ew,Gw             Exchange Register/Memory with Register
\210      mov Gb,Eb              Move
\211      mov Gw,Ew              Move
\212      mov Eb,Gb              Move
\213      mov Ew,Gw              Move
\214      mov Sw,Mw              Move
\215      lea M,Gw               Load Effective Address
\216      mov Ew,Sw              Move
\217 \.0. pop Ev                 Pop a Value from the Stack
\220      xchg %ax,Zvqp          Exchange Register/Memory with Register
\220      nop                    No Operation
\230      cbtw %al,%ax           Convert Byte to Word
\231      cwtd %ax,%dx           Convert Word to Doubleword
\232      lcall Ap               Call Procedure
\233      fwait                  Check pending unmasked floating-point exceptions
\233      fwait                  Prefix                                                   |
\234      pushf Fwo              Push FLAGS Register onto the Stack
\235      popf Fwo               Pop Stack into FLAGS Register
\236      sahf %ah               Store AH into Flags
\237      lahf %ah               Load Status Flags into AH Register
\240      mov Ob,%al             Move
\241      mov Ovqp,%ax           Move
\242      mov %al,Ob             Move
\243      mov %ax,Ovqp           Move
\244      movsb Xb,Yb            Move Data from String to String
\245      movsw Xwo,Ywo          Move Data from String to String
\246      cmpsb Xb,Yb            Compare String Operands
\247      cmpsw Xwo,Ywo          Compare String Operands
\250      test $u8,%al           Logical Compare
\251      test $i16,%ax          Logical Compare
\252      stosb %al,Yb           Store String
\253      stosw %ax,Ywo          Store String
\254      lodsb Xb,%al           Load String
\255      lodsw Xwo,%ax          Load String
\256      scasb %al,Yb           Scan String
\257      scasw %ax,Ywo          Scan String
\260      mov $u8,Zb             Move
\270      mov Ivqp,Zvqp          Move
\300 \.0. rol $u8,Eb             Rotate
\300 \.1. ror $u8,Eb             Rotate
\300 \.2. rcl $u8,Eb             Rotate
\300 \.3. rcr $u8,Eb             Rotate
\300 \.4. shl $u8,Eb             Shift
\300 \.5. shr $u8,Eb             Shift
\300 \.7. sar $u8,Eb             Shift
\301 \.0. rol $u8,Ew             Rotate
\301 \.1. ror $u8,Ew             Rotate
\301 \.2. rcl $u8,Ew             Rotate
\301 \.3. rcr $u8,Ew             Rotate
\301 \.4. shl $u8,Ew             Shift
\301 \.5. shr $u8,Ew             Shift
\301 \.7. sar $u8,Ew             Shift
\302      retn Iw                Return from procedure
\303      retn                   Return from procedure
\304      les Mp,Gv,%es          Load Far Pointer
\305      lds Mp,Gv,%ds          Load Far Pointer
\306 \.0. mov $u8,Eb             Move
\307 \.0. mov $i16,Ew            Move
\310      enter $u8,Iw,%bp       Make Stack Frame for Procedure Parameters
\311      leave %bp              High Level Procedure Exit
\312      retf Iw                Return from procedure
\313      retf                   Return from procedure
\314      int3                   Call to Interrupt Procedure
\315      int Fv,$u8             Call to Interrupt Procedure
\316      into Fv                Call to Interrupt Procedure
\317      iret Fwo               Interrupt Return
\317      iretd Fdo              Interrupt Return
\320 \.0. rol $1,Eb              Rotate
\320 \.1. ror $1,Eb              Rotate
\320 \.2. rcl $1,Eb              Rotate
\320 \.3. rcr $1,Eb              Rotate
\320 \.4. shl $1,Eb              Shift
\320 \.5. shr $1,Eb              Shift
\320 \.7. sar $1,Eb              Shift
\321 \.0. rol $1,Ew              Rotate
\321 \.1. ror $1,Ew              Rotate
\321 \.2. rcl $1,Ew              Rotate
\321 \.3. rcr $1,Ew              Rotate
\321 \.4. shl $1,Ew              Shift
\321 \.5. shr $1,Ew              Shift
\321 \.7. sar $1,Ew              Shift
\322 \.0. rol %cl,Eb             Rotate
\322 \.1. ror %cl,Eb             Rotate
\322 \.2. rcl %cl,Eb             Rotate
\322 \.3. rcr %cl,Eb             Rotate
\322 \.4. shl %cl,Eb             Shift
\322 \.5. shr %cl,Eb             Shift
\322 \.7. sar %cl,Eb             Shift
\323 \.0. rol %cl,Ew             Rotate
\323 \.1. ror %cl,Ew             Rotate
\323 \.2. rcl %cl,Ew             Rotate
\323 \.3. rcr %cl,Ew             Rotate
\323 \.4. shl %cl,Ew             Shift
\323 \.5. shr %cl,Ew             Shift
\323 \.7. sar %cl,Ew             Shift
\324      aam %ah,%al            ASCII Adjust AX After Multiply
\324      amx $u8,%ah,%al        Adjust AX After Multiply
\325      aad %ah,%al            ASCII Adjust AX Before Division
\325      adx $u8,%ah,%al        Adjust AX Before Division
\326      salc %al               Set AL If Carry
\327      xlat BBb,%al           Table Look-up Translation
\330 \.0. fadd Msr,%st           Add
\330 \.1. fmul Msr,%st           Multiply
\330 \.2. fcom ESsr,%st          Compare Real
\330 \.2. fcom %st(1),%st        Compare Real
\330 \.3. fcomp ESsr,%st         Compare Real and Pop
\330 \.3. fcomp %st(1),%st       Compare Real and Pop
\330 \.4. fsub Msr,%st           Subtract
\330 \.5. fsubr Msr,%st          Reverse Subtract
\330 \.6. fdiv Msr,%st           Divide
\330 \.7. fdivr Msr,%st          Reverse Divide
\331 \.0. fld ESsr,%st           Load Floating Point Value
\331 \.1. fxch EST,%st           Exchange Register Contents
\331 \.1. fxch %st(1),%st        Exchange Register Contents
\331 \.2. fst %st,Msr            Store Floating Point Value
\331 \.2. fnop                   No Operation
\331 \.3. fstp %st,Msr           Store Floating Point Value and Pop
\331 \.4. fldenv Me              Load x87 FPU Environment
\331 \.4. fchs %st               Change Sign
\331 \.4. fabs %st               Absolute Value
\331 \.4. ftst %st               Test
\331 \.4. fxam %st               Examine
\331 \.5. fldcw Mw               Load x87 FPU Control Word
\331 \.5. fld1 %st               Load Constant +1.0
\331 \.5. fldl2t %st             Load Constant log_210
\331 \.5. fldl2e %st             Load Constant log_2e
\331 \.5. fldpi %st              Load Constant π
\331 \.5. fldlg2 %st             Load Constant log_102
\331 \.5. fldln2 %st             Load Constant log_e2
\331 \.5. fldz %st               Load Constant +0.0
\331 \.6. fnstenv Me             Store x87 FPU Environment
\331 \.6. fstenv Me              Store x87 FPU Environment
\331 \.6. f2xm1 %st              Compute 2^x-1
\331 \.6. fyl2x %st,%st(1)       Compute y × log_2x and Pop
\331 \.6. fptan %st              Partial Tangent
\331 \.6. fpatan %st,%st(1)      Partial Arctangent and Pop
\331 \.6. fxtract %st            Extract Exponent and Significand
\331 \.6. fprem1 %st(1),%st      IEEE Partial Remainder
\331 \.6. fdecstp                Decrement Stack-Top Pointer
\331 \.6. fincstp                Increment Stack-Top Pointer
\331 \.7. fnstcw Mw              Store x87 FPU Control Word
\331 \.7. fstcw Mw               Store x87 FPU Control Word
\331 \.7. fprem %st(1),%st       Partial Remainder (for compatibility with i8087 and i287)
\331 \.7. fyl2xp1 %st,%st(1)     Compute y × log_2(x+1) and Pop
\331 \.7. fsqrt %st              Square Root
\331 \.7. fsincos %st            Sine and Cosine
\331 \.7. frndint %st            Round to Integer
\331 \.7. fscale %st(1),%st      Scale
\331 \.7. fsin %st               Sine
\331 \.7. fcos %st               Cosine
\332 \.0. fiadd Mdi,%st          Add
\332 \.0. fcmovb EST,%st         FP Conditional Move - below (CF=1)
\332 \.1. fimul Mdi,%st          Multiply
\332 \.1. fcmove EST,%st         FP Conditional Move - equal (ZF=1)
\332 \.2. ficom Mdi,%st          Compare Integer
\332 \.2. fcmovbe EST,%st        FP Conditional Move - below or equal (CF=1 or ZF=1)
\332 \.3. ficomp Mdi,%st         Compare Integer and Pop
\332 \.3. fcmovu EST,%st         FP Conditional Move - unordered (PF=1)
\332 \.4. fisub Mdi,%st          Subtract
\332 \.5. fisubr Mdi,%st         Reverse Subtract
\332 \.6. fidiv Mdi,%st          Divide
\332 \.7. fidivr Mdi,%st         Reverse Divide
\333 \.0. fild Mdi,%st           Load Integer
\333 \.0. fcmovnb EST,%st        FP Conditional Move - not below (CF=0)
\333 \.1. fcmovne EST,%st        FP Conditional Move - not equal (ZF=0)
\333 \.2. fist %st,Mdi           Store Integer
\333 \.2. fcmovnbe EST,%st       FP Conditional Move - below or equal (CF=0 and ZF=0)
\333 \.3. fistp %st,Mdi          Store Integer and Pop
\333 \.3. fcmovnu EST,%st        FP Conditional Move - not unordered (PF=0)
\333 \.4. fndisi nop             Treated as Integer NOP
\333 \.4. fnclex                 Clear Exceptions
\333 \.4. fclex                  Clear Exceptions
\333 \.4. fninit                 Initialize Floating-Point Unit
\333 \.4. finit                  Initialize Floating-Point Unit
\333 \.4. fnsetpm                Set Protected Mode
\333 \.4. fsetpm                 Set Protected Mode
\333 \.5. fld Mer,%st            Load Floating Point Value
\333 \.5. fucomi EST,%st         Unordered Compare Floating Point Values and Set EFLAGS
\333 \.6. fcomi EST,%st          Compare Floating Point Values and Set EFLAGS
\333 \.7. fstp %st,Mer           Store Floating Point Value and Pop
\334 \.0. fadd Mdr,%st           Add
\334 \.0. fadd %st,EST           Add
\334 \.1. fmul Mdr,%st           Multiply
\334 \.1. fmul %st,EST           Multiply
\334 \.2. fcom Mdr,%st           Compare Real
\334 \.3. fcomp Mdr,%st          Compare Real and Pop
\334 \.4. fsub Mdr,%st           Subtract
\334 \.4. fsubr %st,EST          Reverse Subtract
\334 \.5. fsubr Mdr,%st          Reverse Subtract
\334 \.5. fsub %st,EST           Subtract
\334 \.6. fdiv Mdr,%st           Divide
\334 \.6. fdivr %st,EST          Reverse Divide
\334 \.7. fdivr Mdr,%st          Reverse Divide
\334 \.7. fdiv %st,EST           Divide and Pop
\335 \.0. fld Mdr,%st            Load Floating Point Value
\335 \.0. ffree EST              Free Floating-Point Register
\335 \.2. fst %st,Mdr            Store Floating Point Value
\335 \.2. fst EST,%st            Store Floating Point Value
\335 \.3. fstp %st,Mdr           Store Floating Point Value and Pop
\335 \.3. fstp EST,%st           Store Floating Point Value and Pop
\335 \.4. frstor ST2,%st(1),%st  Restore x87 FPU State
\335 \.6. fnsave %st(1),%st,Mst  Store x87 FPU State
\335 \.6. fsave %st(1),%st,Mst   Store x87 FPU State
\335 \.7. fnstsw Mw              Store x87 FPU Status Word
\335 \.7. fstsw Mw               Store x87 FPU Status Word
\336 \.0. fiadd Mwi,%st          Add
\336 \.0. faddp %st,EST          Add and Pop
\336 \.0. faddp %st,%st(1)       Add and Pop
\336 \.1. fimul Mwi,%st          Multiply
\336 \.1. fmulp %st,EST          Multiply and Pop
\336 \.1. fmulp %st,%st(1)       Multiply and Pop
\336 \.2. ficom Mwi,%st          Compare Integer
\336 \.3. ficomp Mwi,%st         Compare Integer and Pop
\336 \.3. fcompp %st(1),%st      Compare Real and Pop Twice
\336 \.4. fisub Mwi,%st          Subtract
\336 \.4. fsubrp %st,EST         Reverse Subtract and Pop
\336 \.4. fsubrp %st,%st(1)      Reverse Subtract and Pop
\336 \.5. fisubr Mwi,%st         Reverse Subtract
\336 \.5. fsubp %st,EST          Subtract and Pop
\336 \.5. fsubp %st,%st(1)       Subtract and Pop
\336 \.6. fidiv Mwi,%st          Divide
\336 \.6. fdivrp %st,EST         Reverse Divide and Pop
\336 \.6. fdivrp %st,%st(1)      Reverse Divide and Pop
\336 \.7. fidivr Mwi,%st         Reverse Divide
\336 \.7. fdivp %st,EST          Divide and Pop
\336 \.7. fdivp %st,%st(1)       Divide and Pop
\337 \.0. fild Mwi,%st           Load Integer
\337 \.0. ffreep EST             Free Floating-Point Register and Pop
\337 \.2. fist %st,Mwi           Store Integer
\337 \.3. fistp %st,Mwi          Store Integer and Pop
\337 \.4. fbld Mbcd,%st          Load Binary Coded Decimal
\337 \.4. fnstsw %ax             Store x87 FPU Status Word
\337 \.4. fstsw %ax              Store x87 FPU Status Word
\337 \.5. fild Mqi,%st           Load Integer
\337 \.5. fucomip EST,%st        Unordered Compare Floating Point Values and Set EFLAGS and Pop
\337 \.6. fbstp %st,Mbcd         Store BCD Integer and Pop
\337 \.6. fcomip EST,%st         Compare Floating Point Values and Set EFLAGS and Pop
\337 \.7. fistp %st,Mqi          Store Integer and Pop
\340      loopnz Jbs,%cx         Decrement count; Jump short if count!=0 and ZF=0
\341      loope Jbs,%cx          Decrement count; Jump short if count!=0 and ZF=1
\342      loop Jbs,%cx           Decrement count; Jump short if count!=0
\343      jcxz %cx,Jbs           Jump short if eCX register is 0
\344      inb $u8,%al            Input from Port
\345      inw $u8,%ax            Input from Port
\346      outb %al,$u8           Output to Port
\347      outw %ax,$u8           Output to Port
\350      call Jvds              Call Procedure
\351      jmp Jvds               Jump
\352      ljmp Ap                Jump
\353      jmp Jbs                Jump
\354      inb %dx,%al            Input from Port
\355      inw %dx,%ax            Input from Port
\356      outb %al,%dx           Output to Port
\357      outw %ax,%dx           Output to Port
\360      lock                   Assert LOCK# Signal Prefix
\362      repnz %cx              Repeat String Operation Prefix
\363      rep %cx                Repeat String Operation Prefix
\364      hlt                    Halt
\365      cmc                    Complement Carry Flag
\366 \.0. test $u8,Eb            Logical Compare
\366 \.2. not Eb                 One's Complement Negation
\366 \.3. neg Eb                 Two's Complement Negation
\366 \.4. mul Eb,%al,%ax         Unsigned Multiply
\366 \.5. imul Eb,%al,%ax        Signed Multiply
\366 \.6. div %ax,%ah,%al        Unsigned Divide
\366 \.7. idiv %ax,%ah,%al       Signed Divide
\367 \.0. test $i16,Ew           Logical Compare
\367 \.2. not Ew                 One's Complement Negation
\367 \.3. neg Ew                 Two's Complement Negation
\367 \.4. mul Ew,%ax,%dx         Unsigned Multiply
\367 \.5. imul Ew,%ax,%dx        Signed Multiply
\367 \.6. div Ew,%ax,%dx         Unsigned Divide
\367 \.7. idiv Ew,%ax,%dx        Signed Divide
\370      clc                    Clear Carry Flag
\371      stc                    Set Carry Flag
\372      cli                    Clear Interrupt Flag
\373      sti                    Set Interrupt Flag
\374      cld                    Clear Direction Flag
\375      std                    Set Direction Flag
\376 \.0. inc Eb                 Increment by 1
\376 \.1. dec Eb                 Decrement by 1
\377 \.0. inc Ew                 Increment by 1
\377 \.1. dec Ew                 Decrement by 1
\377 \.2. call Ev                Call Procedure
\377 \.3. lcall Mptp             Call Procedure
\377 \.4. jmp Ev                 Jump
\377 \.5. ljmp Mptp              Jump
\377 \.6. push Ev                Push Word, Doubleword or Quadword Onto the Stack