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_Z  = 0x1E, /* Jump to SubRoutine. */
	JSR    = 0x20, /* JSR Absolute. */
	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. */
	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. */
};