-------------------- E16 INSTRUCTION SUMMARY ----------------------------

T = top-of-stack register               L = literal register
R = top of return stack                 A = address register
S = top of data stack (2nd stack item)  P = program counter

OPCODE  MNEMONIC  ACTIONS               DESCRIPTION
------  --------  ------------------    ---------------------------------
  00    NOP       T=T                   No operation
  01    LAND      T=T&L                 AND with literal
  02    LXOR      T=T^L                 XOR with literal
  03    MLT       T=L                   Move L to T
  04    L+        T=T+L                 Add literal
  05    LC+       T=T+L+cf              Add literal and carry
  06    L+C       T=T+L                 Add literal, latch carry
  07    LC+C      T=T+L+cf              Add literal and carry, latch carry
  08    NIP       T=T, sp--             Remove second stack item
  09    AND       T=T&S, sp--           Logical AND
  0A    XOR       T=T^S, sp--           Logical exclusive OR
  0B    DROP      T=S, sp--             Drop top stack item
  0C    +         T=T+S, sp--           Add
  0D    C+        T=T+S+CY, sp--        Add with carry
  0E    +C        T=T+S, sp--           Add, latch carry
  0F    C+C       T=T+S+CY, sp--        Add with carry, latch carry
  10    R>DROP    T=T, rp--             Drop item from return stack
  11    R>AND     T=T&R, rp--           AND with R, drop R
  12    R>XOR     T=T^R, rp--           XOR with R, drop R
  13    DROPR>    T=R, rp--             Overwrite T with R
  14    R>+       T=T+R, rp--           Add R, drop R
  15    R>C+      T=T+R+CY, rp--        Add R and carry, drop R
  16    R>+C      T=T+R, rp--           Add R, latch carry, drop R
  17    R>C+C     T=T+R+CY, rp--        Add R and carry, latch carry, drop R
  18    RST0      rp++, R=P, P=80       Call ISR at 80
  19    RST1      rp++, R=P, P=10       Call ISR at 10
  1A    RST2      rp++, R=P, P=20       Call ISR at 20
  1B    RST3      rp++, R=P, P=30       Call ISR at 30
  1C    RST4      rp++, R=P, P=40       Call ISR at 40
  1D    RST5      rp++, R=P, P=50       Call ISR at 50
  1E    RST6      rp++, R=P, P=60       Call ISR at 60
  1F    RST7      rp++, R=P, P=70       Call ISR at 70
  20    BRU       P=P+L if Usrbit=1     Branch if user bit = 1
  21    BRA       P=P+L                 Unconditional branch
  22    BCC       P=P+L if cf=0         Branch if carry = 0
  23    BMS       P=P+L if R<0          Branch if minus return stack
  24    BMI       P=P+L if T<0          Branch if minus
  25    BGE       P=P+L if T>=0         Branch if positive
  26    BEQ       P=P+L if T=0          Branch if equal
  27    BNE       P=P+L if T<>0         Branch if not equal
  28    FU        sp++, S=T, T=cc       Flag: -1 if user bit = 1
  29    FT        sp++, S=T, T=-1       Push -1 onto stack
  2A    FCC       sp++, S=T, T=cc       Flag: -1 if carry=0
  2C    FMI       sp++, S=T, T=cc       Flag: -1 if T<0
  2D    FGE       sp++, S=T, T=cc       Flag: -1 if T>=0
  2E    FEQ       sp++, S=T, T=cc       Flag: -1 if T=0
  2F    FNE       sp++, S=T, T=cc       Flag: -1 if T<>0
  30    SKU       skip if usr=1         Skip group if user bit = 1
  31    SKIP      skip one group        Skip group
  32    SCC       skip if cf=0          Skip group if carry=0
  33    SMS       skip if R<0           Skip group if R<0
  34    SMI       skip if T<0           Skip group if T<0
  35    SGE       skip if T>=0          Skip group if T>=0
  36    SEQ       skip if T=0           Skip group if T=0
  37    SNE       skip if T<>0          Skip group if T<>0
  38    BSR       rp++, R=P, P=P+L      Call relative
  39    CALL      rp++, R=P, P=L        Call absolute
  3A    CALLT     rp++, R=P, P=T        Execute
  3C    JMP       P=L                   Unconditional jump
  3E    RET       P=R, rp--             Return from subroutine
  3F    RETI      P=R, rp--             Return from ISR
  41    MTL       L=T                   Move T to L
  42    MLR       R=L                   Move L to R
  43    MTR       R=T                   Move T to R
  44    SWAPAS    A=S,   S=A            Swap A with S
  45    SWAPAR    A=R,   R=A            Swap A with top of return stack
  46    MTA       A=T                   Move T to A
  47    MLA       A=L                   Move L to A
  48    MSPT      T=SP                  Move SP to T
  49    MRPT      T=RP                  Move RP to T
  4A    SWAP      T=S, S=T              Swap T with S
  4B    SWAPR     T=R, R=T              Swap T with R
  4C    POPL      L=R, rp--             Pop L from return stack
  4E    2*        T=T*2                 Multiply by 2
  4F    2/        T=T/2                 Divide by 2 (signed)
  50    MAL       L=A                   Move A to L
  51    MPL       L=P                   Move P to L
  52    MAT       T=A                   Move A to T
  53    MPT       T=P                   Move P to T
  54    MSL       L=S                   Move S to L
  55    MRL       L=R                   Move R to L
  56    MSA       A=S                   Move S to A
  57    MRA       A=R                   Move R to A
  58    MUL       T=T*2(+S) A=A*2|T15   Partial multiply
  59    OVER+     T=T+S                 Add second stack item
  5A    }!        mA=T, A=A+L           Store to memory
  5B    !{        addr=A                Start memory write cycle
  5C    ASL       L=L+S                 Add S to L
  5D    ARL       L=L+R                 Add R to L
  5E    ALA       A=A+L                 Add L to A
  5F    ALAC      A=A+L+cf              Add L to A with carry
  60    LIT       sp++, S=T, T=L        Literal
  61    USR@      sp++, S=T, T=userdata Fetch miscellaneous user data
  62    A@        sp++, S=T, T=A        Fetch A register
  63    }@        sp++, S=T, T=mem[A]   Push mem[A] to stack
  64    DUP       sp++, S=T             Duplicate top of stack
  65    DUP>R     rp++, R=T             Store to return stack
  66    UNLIT     sp++, S=L             Push literal under TOS
  67    LIT>R     rp++, R=L             Push literal onto the return stack
  68    @{        addr=A                Start memory read cycle
  69    }@T       T=mem[A]              Fetch word to T
  6A    }@L       L=mem[A]              Fetch word to L
  6B    }@A       A=mem[A]              Fetch pointer: A=mem[A]
  6C    JMPD      P=mem[A]              Jump dynamic:  P=mem[A]
  6D    CALLD     rp++, R=P, P=mem[A]   Call dynamic

