╔════════╦═════════════╦═══════════════════════════════════════════╦═══════╦════════╦════════╗
║ Opcode ║ Instruction ║                description                ║ modif ║  modif ║  clock ║
║        ║             ║                                           ║ flags ║  regs  ║ cycles ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 0h     ║ nop         ║ no operation                              ║ -     ║ -      ║ 1      ║
╠════════╩═════════════╩═══════════════════════════════════════════╩═══════╩════════╩════════╣
║                                    Transfer instructions                                   ║
╠════════╦═════════════╦═══════════════════════════════════════════╦═══════╦════════╦════════╣
║ 1h     ║ scf (0/1)   ║ sets Carry flag                           ║ C     ║ -      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 2h     ║ cff         ║ writes Carry flag to DX                   ║ -     ║ DX     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 3h     ║ cof         ║ writes Overflow flag to DX                ║ -     ║ DX     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 4h     ║ czf         ║ writes Zero flag to DX                    ║ -     ║ DX     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 2Dh    ║ cbp         ║ writes Base Pointer to DX                 ║ -     ║ DX     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 2Eh    ║ cpc         ║ writes Program Counter to DX              ║ -     ║ DX     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 5h     ║ mov [A],B   ║ copies to address A, value from reg B     ║ -     ║ -      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 6h     ║ mov B,[A]   ║ copies to reg B, value from address A     ║ -     ║ B      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 7h     ║ mov B,C     ║ copies to reg B, value from reg C         ║ -     ║ B      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 8h     ║ mov B,(x)   ║ copies to reg B, integer value X          ║ -     ║ B      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 2Ah    ║ mov <A>,B   ║ copies to abs address A, value from reg B ║ -     ║ -      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 2Bh    ║ mov B,<A>   ║ copies to reg B, value from abs address A ║ -     ║ B      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 27h    ║ lea A,[B]   ║ copies to reg A value from memory         ║ -     ║ A      ║ 1      ║
║        ║             ║ on address from reg B                     ║       ║        ║        ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 2Ch    ║ lea [A],B   ║ copies to memory address from reg A       ║ -     ║ -      ║ 1      ║
║        ║             ║ value from reg B                          ║       ║        ║        ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 2Fh    ║ lea A,<B>   ║ copies to reg A value from memory         ║ -     ║ A      ║ 1      ║
║        ║             ║ on abs address from reg B                 ║       ║        ║        ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 30h    ║ lea <A>,B   ║ copies to memory abs address from reg A   ║ -     ║ -      ║ 1      ║
║        ║             ║ value from reg B                          ║       ║        ║        ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 9h     ║ pop A       ║ pops value from stack to reg A            ║ -     ║ A, SP  ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ Ah     ║ out         ║ sends data from DX on address from BX     ║ Z     ║ -      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 28h    ║ in          ║ downloads data to DX on address from BX   ║ Z     ║ DX     ║ 1-2    ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 29h    ║ xch A,B     ║ exchanges values from regs A and B        ║ -     ║ A,B    ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ Bh     ║ push A      ║ pushes value to stack from reg A          ║ -     ║ SP     ║ 1      ║
╠════════╩═════════════╩═══════════════════════════════════════════╩═══════╩════════╩════════╣
║                                   Arithmetic instructions                                  ║
╠════════╦═════════════╦═══════════════════════════════════════════╦═══════╦════════╦════════╣
║ Ch     ║ add A,B     ║ sums A + B                                ║ C,O,Z ║ A      ║ 2      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ Dh     ║ adc A,B     ║ sums A + B + CF                           ║ C,O,Z ║ A      ║ 2      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ Eh     ║ sub A,B     ║ subtracts A - B                           ║ C,O,Z ║ A      ║ 2      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ Fh     ║ suc A,B     ║ subtracts A - B - CF                      ║ C,O,Z ║ A      ║ 2      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 10h    ║ mul8 A,B    ║ [8bit]multiplies A times B, result: A     ║ Z     ║ A      ║ 2?     ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 11h    ║ mul6 A,B    ║ [16bit]multiplies A times B, result: B:A  ║ Z     ║ B:A    ║ 2?     ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 12h    ║ div8 A,B    ║ [8bit]divides A/B, result: A              ║ Z     ║ A      ║ 2?     ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 13h    ║ div6 A,B    ║ [16bit]divides A/B, result: B:A           ║ Z     ║ B:A    ║ 2?     ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 14h    ║ cmp A,B     ║ compares A with B,                        ║ C,O,Z ║ -      ║ 2      ║
║        ║             ║ A=B Z=1, A>B O=1, A<B C=1                 ║       ║        ║        ║
╠════════╩═════════════╩═══════════════════════════════════════════╩═══════╩════════╩════════╣
║                                     Logic instructions                                     ║
╠════════╦═════════════╦═══════════════════════════════════════════╦═══════╦════════╦════════╣
║ 15h    ║ and A,B     ║ A & B                                     ║ -     ║ A      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 16h    ║ neg A       ║ 2's complement negation                   ║ -     ║ A      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 17h    ║ not A       ║ not A                                     ║ -     ║ A      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 18h    ║ or A,B      ║ A | B                                     ║ -     ║ A      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 19h    ║ shl A       ║ A << 1                                    ║ -     ║ A      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 1Ah    ║ shr A       ║ A >> 1                                    ║ -     ║ A      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 1Bh    ║ xor A,B     ║ A ^ B                                     ║ -     ║ A      ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 1Ch    ║ test A,B    ║ if A=B Z=1, A!=B Z=0                      ║ Z     ║ -      ║ 1      ║
╠════════╩═════════════╩═══════════════════════════════════════════╩═══════╩════════╩════════╣
║                                      Jump instructions                                     ║
╠════════╦═════════════╦═══════════════════════════════════════════╦═══════╦════════╦════════╣
║ 1Dh    ║ int (x)     ║ calls interrupt with code x,              ║ C,O,Z ║ AX,BX  ║ 1+x    ║
║        ║             ║ also can be used to abs jumps to program  ║       ║ CX,DX  ║        ║
║        ║             ║ flags and regs are not saved autmatically ║       ║ SP, PC ║        ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 1Eh    ║ call [x]    ║ jumps to subroutine on address x,         ║ C,O,Z ║ AX,BX  ║ 1+x    ║
║        ║             ║ flags and regs are not saved autmatically ║       ║ CX,DX  ║        ║
║        ║             ║                                           ║       ║ SP, PC ║        ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 1Fh    ║ ret         ║ jumps back from subroutine                ║ -     ║ SP, PC ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 20h    ║ jmp [x]     ║ jumps to x label address in program       ║ -     ║ PC     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 31h    ║ jmp <x>     ║ jumps to x abs address in program         ║ -     ║ PC     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 32h    ║ jmp X       ║ jumps to address in program from X reg    ║ -     ║ PC     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 33h    ║ jmp <X>     ║ jumps to absaddress from X reg in program ║ -     ║ PC     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 21h    ║ jc [x]      ║ jumps if CF = 1                           ║ -     ║ PC     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 22h    ║ jnc [x]     ║ jumps if CF = 0                           ║ -     ║ PC     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 23h    ║ jz [x]      ║ jumps if ZF = 1                           ║ -     ║ PC     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 24h    ║ jnz [x]     ║ jumps if ZF = 0                           ║ -     ║ PC     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 25h    ║ jo [x]      ║ jumps if OF = 1                           ║ -     ║ PC     ║ 1      ║
╠════════╬═════════════╬═══════════════════════════════════════════╬═══════╬════════╬════════╣
║ 26h    ║ jno [x]     ║ jumps if OF = 0                           ║ -     ║ PC     ║ 1      ║
╚════════╩═════════════╩═══════════════════════════════════════════╩═══════╩════════╩════════╝