enum base_isa { CPS = 0x00, /* Clear Processor Status. */ ADC = 0x01, /* ADd with Carry. */ AAB = 0x02, /* Add Accumulator with carry by B register. */ ADC_AB = 0x04, /* ADC Absolute. */ LDA_IN = 0x05, /* LDA Indirect. */ ADC_Z = 0x06, /* ADC Zero Matrix. */ PHP = 0x08, /* PusH Processor status to stack. */ CPB = 0x09, /* ComPare B register. */ PHB = 0x0A, /* PusH B register to stack. */ DEC_AB = 0x0C, /* DEC Absolute. */ DEC_Z = 0x0D, /* DEC Zero Matrix. */ JMP_Z = 0x0E, /* JuMP to memory location. */ JMP = 0x10, /* JMP Absolute. */ SBC = 0x11, /* SuBtract with Carry. */ SAB = 0x12, /* Subtract Accumulator with carry by B register. */ SBC_AB = 0x14, /* SBC Absolute. */ STA_IN = 0x15, /* STA Indirect. */ SBC_Z = 0x16, /* SBC Zero Matrix. */ ENT = 0x18, /* ENd Threads. */ CPY = 0x19, /* ComPare Y register. */ PLB = 0x1A, /* PuLl B register to stack. */ INC_AB = 0x1C, /* INC Absolute. */ INC_Z = 0x1D, /* INC Zero Matrix. */ JSR = 0x1E, /* Jump to SubRoutine. */ JSL = 0x20, /* Jump to Subroutine Long. */ AND = 0x21, /* bitwise AND with accumulator. */ ABA = 0x22, /* bitwise And with Accumulator, and B register. */ AND_AB = 0x24, /* AND Absolute. */ CMP_IN = 0x25, /* CMP Indirect. */ AND_Z = 0x26, /* AND Zero Matrix. */ PLP = 0x28, /* PuLl Processor status from stack. */ CPX = 0x29, /* ComPare X register. */ PHY = 0x2A, /* PusH Y register to stack. */ CPB_AB = 0x2C, /* CPB Absolute. */ CPB_Z = 0x2D, /* CPB Zero Matrix. */ BPO_Z = 0x2E, /* Branch if POsitive. */ BPO = 0x30, /* BPO Absolute. */ ORA = 0x31, /* bitwise OR with Accumulator. */ OAB = 0x32, /* bitwise Or with Accumulator, and B register. */ ORA_AB = 0x34, /* ORA Absolute. */ LDB_IN = 0x35, /* LDB Indirect. */ ORA_Z = 0x36, /* ORA Zero Matrix. */ STT = 0x38, /* STart Threads. */ LDA_ZY = 0x39, /* LDA Zero Matrix, indexed with Y. */ PLY = 0x3A, /* PuLl Y register from stack. */ CPX_AB = 0x3C, /* CPX Absolute. */ CPY_Z = 0x3D, /* CPY Zero Matrix. */ BNG_Z = 0x3E, /* Branch if NeGative. */ BNG = 0x40, /* BNG Absolute. */ XOR = 0x41, /* bitwise XOR with accumulator. */ XAB = 0x42, /* bitwise Xor with Accumulator, and B register. */ XOR_AB = 0x44, /* XOR Absolute. */ STB_IN = 0x45, /* STB Indirect. */ XOR_Z = 0x46, /* XOR Zero Matrix. */ PHA = 0x48, /* PusH Accumulator to stack. */ STA_ZY = 0x49, /* STA Zero Matrix, indexed with Y. */ PHX = 0x4A, /* PusH X register to stack. */ CPY_AB = 0x4C, /* CPY Absolute. */ CPX_Z = 0x4D, /* CPX Zero Matrix. */ BCS_Z = 0x4E, /* Branch if Carry Set. */ BCS = 0x50, /* BCS Absolute. */ LSL = 0x51, /* Logical Shift Left. */ LLB = 0x52, /* Logical shift Left accumulator by B. */ LSL_AB = 0x54, /* LSL Absolute. */ CPB_IN = 0x55, /* CPB Indirect. */ LSL_Z = 0x56, /* LSL Zero Matrix. */ CLC = 0x58, /* CLear Carry flag. */ LDB_ZY = 0x59, /* LDB Zero Matrix, indexed with Y. */ PLX = 0x5A, /* PuLl X register from stack. */ LDA_IY = 0x5C, /* LDA Indirect Indexed. */ LDA_IX = 0x5D, /* LDA Indexed Indirect. */ BCC_Z = 0x5E, /* Branch if Carry Clear. */ BCC = 0x60, /* BCC Absolute. */ LSR = 0x61, /* Logical Shift Right. */ LRB = 0x62, /* Logical shift Right accumulator by B. */ LSR_AB = 0x64, /* LSR Absolute. */ LDY_IN = 0x65, /* LDY Indirect. */ LSR_Z = 0x66, /* LSR Zero Matrix. */ PLA = 0x68, /* PuLl Accumulator from stack. */ STB_ZY = 0x69, /* STB Zero Matrix, indexed with Y. */ TAB = 0x6A, /* Transfer Accumulator to B. */ STA_IY = 0x6C, /* STA Indirect Indexed. */ STA_IX = 0x6D, /* STA Indexed Indirect. */ BEQ_Z = 0x6E, /* Branch if EQual. */ BEQ = 0x70, /* BEQ Absolute. */ ROL = 0x71, /* ROtate Left. */ RLB = 0x72, /* Rotate Left accumulator by B. */ ROL_AB = 0x74, /* ROL Absolute. */ STY_IN = 0x75, /* STY Indirect. */ ROL_Z = 0x76, /* ROL Zero Matrix. */ SEC = 0x78, /* SEt Carry flag. */ LDA_ZX = 0x79, /* LDA Zero Matrix, indexed with X. */ TBA = 0x7A, /* Transfer B to Accumulator. */ CMP_IY = 0x7C, /* CMP Indirect Indexed. */ CMP_IX = 0x7D, /* CMP Indexed Indirect. */ BNE_Z = 0x7E, /* Branch if Not Equal. */ BNE = 0x80, /* BNE Absolute. */ ROR = 0x81, /* ROtate Right. */ RRB = 0x82, /* Rotate Right accumulator by B. */ ROR_AB = 0x84, /* ROR Absolute. */ CPY_IN = 0x85, /* CPY Indirect. */ ROR_Z = 0x86, /* ROR Zero Matrix. */ DEY = 0x88, /* DEcrement Y register. */ STA_ZX = 0x89, /* STA Zero Matrix, indexed with X. */ TAY = 0x8A, /* Transfer Accumulator to Y. */ LDB_IY = 0x8C, /* LDB Indirect Indexed. */ LDB_IX = 0x8D, /* LDB Indexed Indirect. */ BVS_Z = 0x8E, /* Branch if oVerflow Set. */ BVS = 0x90, /* BVS Absolute. */ MUL = 0x91, /* MULtiply accumulator. */ MAB = 0x92, /* Multiply Accumulator by B. */ MUL_AB = 0x94, /* MUL Absolute. */ LDX_IN = 0x95, /* LDX Indirect. */ MUL_Z = 0x96, /* MUL Zero Matrix. */ CLI = 0x98, /* CLear Interupt flag. */ LDB_ZX = 0x99, /* LDB Zero Matrix, indexed with X. */ TYA = 0x9A, /* Transfer Y to Accumulator. */ STB_IY = 0x9C, /* STB Indirect Indexed. */ STB_IX = 0x9D, /* STB Indexed Indirect. */ BVC_Z = 0x9E, /* Branch if oVerflow Clear. */ BVC = 0xA0, /* BVC Absolute. */ DIV = 0xA1, /* DIVide with accumulator. */ DAB = 0xA2, /* Divide Accumulator by B. */ DIV_AB = 0xA4, /* DIV Absolute. */ STX_IN = 0xA5, /* STX Indirect. */ DIV_Z = 0xA6, /* DIV Zero Matrix. */ INY = 0xA8, /* INcrement Y register. */ STB_ZX = 0xA9, /* STB Zero Matrix, indexed with X. */ TAX = 0xAA, /* Transfer Accumulator to X. */ CPB_IY = 0xAC, /* CPB Indirect Indexed. */ CPB_IX = 0xAD, /* CPB Indexed Indirect. */ RTS = 0xAE, /* ReTurn from Subroutine. */ RTL = 0xB0, /* ReTurn from subroutine Long. */ CMP = 0xB1, /* CoMPare accumulator. */ CAB = 0xB2, /* Compare Accumulator, and B. */ CMP_AB = 0xB4, /* CMP Absolute. */ CPX_IN = 0xB5, /* CPX Indirect. */ CMP_Z = 0xB6, /* CMP Zero Matrix. */ SEI = 0xB8, /* SEt Interupt flag. */ LDX = 0xB9, /* LoaD X register. */ TXA = 0xBA, /* Transfer X to Accumulator. */ LDX_AB = 0xBC, /* LDX Absolute. */ LDX_Z = 0xBD, /* LDX Zero Matrix. */ JSR_IN = 0xBE, /* JSR Indirect. */ RTI = 0xC0, /* ReTurn from Interrupt. */ LDA = 0xC1, /* LoaD Accumulator. */ LDA_AB = 0xC4, /* LDA Absolute. */ DEX = 0xC5, /* DEcrement X register. */ LDA_Z = 0xC6, /* LDA Zero Matrix. */ CLV = 0xC8, /* CLear oVerflow flag. */ LDX_ZY = 0xC9, /* LDX Zero Matrix, indexed with Y. */ TYX = 0xCA, /* Transfer Y to X. */ STA = 0xCC, /* STA Absolute. */ STA_Z = 0xCD, /* STore Accumulator. */ JMP_IN = 0xCE, /* JMP Indirect. */ TSX = 0xD0, /* Transfer Stack pointer to X. */ LDB = 0xD1, /* LoaD B register. */ LDB_AB = 0xD4, /* LDB Absolute. */ INX = 0xD5, /* INcrement X register. */ LDB_Z = 0xD6, /* LDB Zero Matrix. */ WAI = 0xD8, /* WAit for Interrupt. */ STX_ZY = 0xD9, /* STX Zero Matrix, indexed with Y. */ TXY = 0xDA, /* Transfer X to Y. */ STB = 0xDC, /* STB Absolute. */ STB_Z = 0xDD, /* STore B register. */ TXS = 0xE0, /* Transfer X to Stack pointer. */ LDY = 0xE1, /* LoaD Y register. */ LDY_AB = 0xE4, /* LDY Absolute. */ DEC = 0xE5, /* DECrement accumulator. */ LDY_Z = 0xE6, /* LDY Zero Matrix. */ BRK = 0xE8, /* BReaK. */ LDY_ZX = 0xE9, /* LDY Zero Matrix, indexed with X. */ NOP = 0xEA, /* No OPeration. */ STY = 0xEC, /* STY Absolute. */ STY_Z = 0xED, /* STore Y register. */ DEB = 0xEE, /* Decrement B register. */ ASR = 0xF1, /* Arithmetic Shift Right. */ ARB = 0xF2, /* Arithmetic shift Right accumulator by B. */ ASR_AB = 0xF4, /* ASR Absolute. */ INC = 0xF5, /* INCrement accumulator. */ ASR_Z = 0xF6, /* ASR Zero Matrix. */ STY_ZX = 0xF9, /* STY Zero Matrix, indexed with X. */ STX = 0xFC, /* STX Absolute. */ STX_Z = 0xFD, /* STore X register. */ INB = 0xFE /* Increment B register. */ }; enum base_ext { ADC_E = 0x01, /* ADC E Indirect. */ LEA_ZX = 0x02, /* LEA Zero Matrix, indexed with X. */ LEA_SX = 0x03, /* LEA Stack Pointer, offset with X. */ ADD = 0x04, /* ADD without carry. */ LLM = 0x05, /* Logical shift Left, on Memory. */ PHE = 0x08, /* PusH Effective address register to stack. */ CPB_E = 0x09, /* CPB E Indirect. */ DEC_E = 0x0C, /* DEC E Indirect. */ JMP_E = 0x10, /* JMP E Indirect. */ SBC_E = 0x11, /* SBC E Indirect. */ LEA_ZY = 0x12, /* LEA Zero Matrix, indexed with Y. */ LEA_SY = 0x13, /* LEA Stack Pointer, offset with Y. */ ADD_E = 0x14, /* ADD E Indirect. */ LLM_Z = 0x15, /* LLM Zero Matrix. */ CPY_E = 0x19, /* CPY E Indirect. */ INC_E = 0x1C, /* INC E Indirect. */ JSR_E = 0x20, /* JSR E Indirect. */ AND_E = 0x21, /* AND E Indirect. */ PEA_ZX = 0x22, /* PEA Zero Matrix, indexed with X. */ PEA_SX = 0x23, /* PEA Stack Pointer, offset with X. */ SUB = 0x24, /* SUBtract without carry. */ LLM_E = 0x25, /* LLM E Indirect. */ PLE = 0x28, /* PuLl Effective address register from stack. */ CPX_E = 0x29, /* CPX E Indirect. */ DEE = 0x2C, /* DEcrement Effective address register. */ BPO_E = 0x30, /* BPO E Indirect. */ ORA_E = 0x31, /* ORA E Indirect. */ PEA_ZY = 0x32, /* PEA Zero Matrix, indexed with Y. */ PEA_SY = 0x33, /* PEA Stack Pointer, offset with Y. */ SUB_E = 0x34, /* SUB E Indirect. */ LRM = 0x35, /* Logical shift Right, on Memory. */ CPE = 0x39, /* ComPare Effective address register. */ INE = 0x3C, /* INcrement Effective address register. */ BNG_E = 0x40, /* BNG E Indirect. */ XOR_E = 0x41, /* XOR E Indirect. */ LEA_AX = 0x42, /* LEA Absolute, indexed with X. */ LEA_SI = 0x43, /* LEA Stack Pointer, Immediate offset. */ ADE = 0x44, /* ADd Effective address register. */ LRM_Z = 0x45, /* LRM Zero Matrix. */ CPE_AB = 0x49, /* CPE Absolute. */ DES = 0x4C, /* DEcrement Stack pointer. */ BCS_E = 0x50, /* BCS E Indirect. */ LSL_E = 0x51, /* LSL E Indirect. */ LEA_AY = 0x52, /* LEA Absolute, indexed with Y. */ LEA_RE = 0x53, /* LEA Relative. */ ADE_A = 0x54, /* ADE with Accumulator. */ LRM_E = 0x55, /* LRM E Indirect. */ CPE_Z = 0x59, /* CPE Zero Matrix. */ INS = 0x5C, /* INcrement Stack pointer. */ BCC_E = 0x60, /* BCC E Indirect. */ LSR_E = 0x61, /* LSR E Indirect. */ PEA_AX = 0x62, /* PEA Absolute, indexed with X. */ PEA_SI = 0x63, /* PEA Stack Pointer, Immediate offset. */ SBE = 0x64, /* SuBtract Effective address register. */ RLM = 0x65, /* Rotate Left, on Memory. */ ICE = 0x69, /* Interlocked Compare, and Exchange. */ BEQ_E = 0x70, /* BEQ E Indirect. */ ROL_E = 0x71, /* ROL E Indirect. */ PEA_AY = 0x72, /* PEA Absolute, indexed with Y. */ PEA_RE = 0x73, /* PEA Relative. */ RLM_Z = 0x75, /* RLM Zero Matrix. */ ICE_Z = 0x79, /* ICE Zero Matrix. */ STE = 0x7C, /* STore Effective address register. */ BNE_E = 0x80, /* BNE E Indirect. */ ROR_E = 0x81, /* ROR E Indirect. */ LEA_IX = 0x82, /* LEA Indexed Indirect. */ LEA_IN = 0x83, /* LEA Indirect. */ ADS = 0x84, /* ADd Stack pointer. */ RLM_E = 0x85, /* RLM E Indirect. */ ICE_E = 0x89, /* ICE E Indirect. */ STE_Z = 0x8C, /* STE Zero Matrix. */ BVS_E = 0x90, /* BVS E Indirect. */ MUL_E = 0x91, /* MUL E Indirect. */ LEA_IY = 0x92, /* LEA Indirect Indexed. */ LEA_AI = 0x93, /* LEA Absolute Indirect. */ ADS_A = 0x94, /* ADS with Accumulator. */ RRM = 0x95, /* Rotate Right, on Memory. */ STZ = 0x9C, /* STore Zero. */ BVC_E = 0xA0, /* BVC E Indirect. */ DIV_E = 0xA1, /* DIV E Indirect. */ PEA_IX = 0xA2, /* PEA Indexed Indirect. */ PEA_IN = 0xA3, /* PEA Indirect. */ SBS = 0xA4, /* SuBtract Stack pointer. */ RRM_ZM = 0xA5, /* RRM Zero Matrix. */ STZ_ZM = 0xAC, /* STZ Zero Matrix. */ CMP_E = 0xB1, /* CMP E Indirect. */ PEA_IY = 0xB2, /* PEA Indirect Indexed. */ PEA_AI = 0xB3, /* PEA Absolute Indirect. */ SBS_A = 0xB4, /* SBS with Accumulator. */ RRM_E = 0xB5, /* RRM E Indirect. */ LDX_E = 0xB9, /* LDX E Indirect. */ STZ_E = 0xBC, /* STZ E Indirect. */ LDA_E = 0xC1, /* LDA E Indirect. */ LEA_AIX = 0xC2, /* LEA Absolute Indexed Indirect. */ LEA_Z = 0xC3, /* LEA Zero Matrix. */ NOT = 0xC4, /* bitwise NOT with accumulator. */ ARM = 0xC5, /* Arithmetic shift Right, on Memory. */ LDE = 0xC9, /* LoaD Effective address register. */ STA_E = 0xCC, /* STA E Indirect. */ LDB_E = 0xD1, /* LDB E Indirect. */ LEA_AIY = 0xD2, /* LEA Absolute Indirect Indexed. */ LEA = 0xD3, /* Load Effective Address. */ NOT_AB = 0xD4, /* NOT Absolute. */ ARM_Z = 0xD5, /* ARM Zero Matrix. */ LDE_AB = 0xD9, /* LDE Absolute. */ STB_E = 0xDC, /* STB E Indirect. */ LDY_E = 0xE1, /* LDY E Indirect. */ PEA_AIX = 0xE2, /* PEA Absolute Indexed Indirect. */ PEA_Z = 0xE3, /* PEA Zero Matrix. */ NOT_Z = 0xE4, /* NOT Zero Matrix. */ ARM_E = 0xE5, /* ARM E Indirect. */ LDE_Z = 0xE9, /* LDE Zero Matrix. */ STY_E = 0xEC, /* STY E Indirect. */ ASR_E = 0xF1, /* ASR E Indirect. */ PEA_AIY = 0xF2, /* PEA Absolute Indirect Indexed. */ PEA = 0xF3, /* Push Effective Address. */ NOT_E = 0xF4, /* NOT E Indirect. */ STX_E = 0xFC, /* STX E Indirect. */ }; enum am { /* Part of Base ISA. */ IMM, /* Immediate Data. */ ZM, /* Zero Matrix. */ ZMX, /* Zero Matrix, indexed with X. */ ZMY, /* Zero Matrix, indexed with Y. */ IND, /* Indirect. */ INDX, /* Indexed Indirect. */ INDY, /* Indirect Indexed. */ ABS, /* Absolute. */ IMPL, /* Implied. */ /* Part of Base Extension. */ ABSX, /* Absolute, Indexed with X. */ ABSY, /* Absolute, Indexed with Y. */ SPI, /* Stack Pointer, Immediate Offset. */ SPX, /* Stack Pointer, Offset with X. */ SPY, /* Stack Pointer, Offset with Y. */ REL, /* Relative to Program Counter. */ INA, /* Absolute Indirect. */ INAX, /* Absolute Indexed Indirect. */ INAY, /* Absolute Indirect Indexed. */ EIND, /* Effective Address Register, Indirect. */ };