/*
const CONTROL_PCC               = 0b00000000000000000000000000000001;   // PC CLK UP
const CONTROL_PCI               = 0b00000000000000000000000000000010;   // PC Input Enable
const CONTROL_SPD               = 0b00000000000000000000000000000100;   // SP Count Down
const CONTROL_SPC               = 0b00000000000000000000000000001000;   // SP CLK (UP / DOWN)
const CONTROL_SPI               = 0b00000000000000000000000000010000;   // SP Input Enable
const CONTROL_RAIL              = 0b00000000000000000000000000100000;   // GPA LOW Input Enable
const CONTROL_RAIH              = 0b00000000000000000000000001000000;   // GPA HIGH Input Enable
const CONTROL_RBIL              = 0b00000000000000000000000010000000;   // GPB LOW Input Enable
const CONTROL_RBIH              = 0b00000000000000000000000100000000;   // GPB HIGH Input Enable
const CONTROL_RCIL              = 0b00000000000000000000001000000000;   // GPC LOW Input Enable
const CONTROL_RCIH              = 0b00000000000000000000010000000000;   // GPC HIGH Input Enable
const CONTROL_RDIL              = 0b00000000000000000000100000000000;   // GPD LOW Input Enable
const CONTROL_RDIH              = 0b00000000000000000001000000000000;   // GPD HIGH Input Enable
const CONTROL_RRI               = 0b00000000000000000010000000000000;   // LOW Ram Register Input Enable
const CONTROL_RHI               = 0b00000000000000000100000000000000;   // HIGH Ram Register Input Enable
const CONTROL_ALUM0             = 0b00000000000000001000000000000000;   // ALU MUX 0
const CONTROL_ALUM1             = 0b00000000000000010000000000000000;   // ALU MUX 1
const CONTROL_ALUI              = 0b00000000000000100000000000000000;   // ALU Invert (high side)
const CONTROL_ALUC              = 0b00000000000001000000000000000000;   // ALU Carry Input
const CONTROL_ALUSL             = 0b00000000000010000000000000000000;   // ALU Shift Left
const CONTROL_ALUSR             = 0b00000000000100000000000000000000;   // ALU Shift Right
const CONTROL_OEM0              = 0b00000000001000000000000000000000;   // Output Enable MUX 0
const CONTROL_OEM1              = 0b00000000010000000000000000000000;   // Output Enable MUX 1
const CONTROL_OEM2              = 0b00000000100000000000000000000000;   // Output Enable MUX 2
const CONTROL_OEM3              = 0b00000001000000000000000000000000;   // Output Enable MUX 3
const CONTROL_OEM4              = 0b00000010000000000000000000000000;   // Output Enable MUX 4
const CONTROL_OEME              = 0b00000100000000000000000000000000;   // Output Enable MUX Enable
const CONTROL_RI                = 0b00010000000000000000000000000000;   // RAM Input Enable
const CONTROL_IRI               = 0b00100000000000000000000000000000;   // Instruction Register Input Enable
const CONTROL_MCL0              = 0b01000000000000000000000000000000;   // Microcode Counter to 0
const CONTROL_MCL8              = 0b10000000000000000000000000000000;    // Microcode Counter to 8
*/

/*
        Free Instructions:
        0x000
        0x001
        0x003
        0x005
        0x007
        0x009
 */

let Instructions = new Array();

const InstructionTypes = {
    SingleWord: {
        Name: `Singe Word`,
        toString() {
            return this.Name;
        }
    },
    Immediate: {
        Name: `Immediate`,
        toString() {
            return this.Name;
        }
    },
    Indirect: {
        Name: `Indirect`,
        toString() {
            return this.Name;
        }
    },
    Absolute: {
        Name: `Absolute`,
        toString() {
            return this.Name;
        }
    },
    Register: {
        Name: `Register`,
        toString() {
            return this.Name;
        }
    },
    RegisterImmediate: {
        Name: `Register Immediate`,
        toString() {
            return this.Name;
        }
    },
    RegisterAbsolute: {
        Name: `Register Absolute`,
        toString() {
            return this.Name;
        }
    }
};

function IsRegister(reg) {
    reg = reg.toLowerCase().replace("%","").replace("[","").replace("]","");
    switch (reg) {
        case "a":
        case "b":
        case "c":
        case "d":
        case "pc":
        case "sp":
        case "ab":
        case "ac":
        case "ad":
        case "ba":
        case "bc":
        case "bd":
        case "ca":
        case "cb":
        case "cd":
        case "da":
        case "db":
        case "dc":
            return true;
            break;
    }

    return false;
}

function ValidateInstruction(line) {
    let linearr = line.split(" ");
    let label = false;
    let type = false;
    if (linearr[0] !== "") label = linearr[0];
    if (linearr.length > 2) {
        let operands = linearr[2].split(",");
        if (operands.length > 0) {
            if (operands.length === 1) {
                if (operands[0].substring(0,1) === '$') type = InstructionTypes.Immediate;
                if (operands[0].substring(0,1) === '[') type = InstructionTypes.Indirect;
                if (IsRegister(operands[0])) type = InstructionTypes.Register;
                if (type === false) type = InstructionTypes.Absolute;
            } else {
                // more then one operand
            }
        }
    }
    console.log(linearr[1]);
    let foundinstruction = FindInstructon({Instruction: linearr[1]}, type);
    return foundinstruction;
}

function FindInstructon(ins,type = false) {
    for (let a = 0; a < Instructions.length; a++) {
        if (Instructions[a].Mnemonic.toLowerCase() === ins.Instruction.toLowerCase()) {
            if (type) {
                if (Instructions[a].Type === type) return Instructions[a];
            } else {
                return Instructions[a];
            }
        }
    }
    return false;
}

function GenerateMicrocode(mcarray,cpu) {
     for (let a = 0; a < mcarray.length; a++) {


         for (let c = 0; c < 3; c++) {
             let offset = 0;
             if (c === 1) offset = 0b1000000000000000;
             if (c === 2) offset = 0b0100000000000000;

             for (let b = 0; b < 16; b++) {
                 let bytecode = mcarray[a].Bytecode;
                 let mca = mcarray[a].Bytecode << 4;
                 mca |= b;
                 let mcv = mcarray[a].Microcode[b];
                 if (mcarray[a].UsesZero && c === 1) mcv = mcarray[a].MicrocodeZero[b];
                 if (mcarray[a].UsesCarry && c === 2) mcv = mcarray[a].MicrocodeCarry[b];
                 cpu.MCRAM[offset + mca] = mcv;
                 //console.log(`[${bytecode.toString(16)}] ${mca.toString(16)}: ${mcv.toString(2)}`);
             }
         }
     }
}

class Microcode_Instruction {
    constructor() {
        this.Bytecode = 0x000;             // MAX IS 0x3ff
        this.Mnemonic = "NOP";
        this.LongName = "";
        this.Aliases = new Array();
        this.Microcode = new Array(16);
        this.Operands = new Array();
        this.UsesCarry = false;
        this.UsesZero = false;
        this.Words = 1;
        this.Cycles = 2;

        this.Type = InstructionTypes.SingleWord;

        this.Microcode[0] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[1] = CONTROL_OUT_RO | CONTROL_IRI | CONTROL_PCC;
        for (let a = 2; a < 16; a++) {
            this.Microcode[a] = CONTROL_MCL0;
        }
    }
}

//--------------------------- General Purpose Registers LDx Immediates ---------------------------

class IS_LDA_imm8 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x002;
        this.Mnemonic = "LDA";
        this.LongName = "LOAD Register A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});

        this.Words = 2;
        this.Cycles = 4;

        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_PCC;
    }
}
is_LDA_i = new IS_LDA_imm8;
Instructions.push(is_LDA_i);

class IS_LDB_imm8 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x004;
        this.Mnemonic = "LDB";
        this.LongName = "LOAD Register B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RBIL | CONTROL_PCC;
    }
}
is_LDB_i = new IS_LDB_imm8;
Instructions.push(is_LDB_i);

class IS_LDC_imm8 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x006;
        this.Mnemonic = "LDC";
        this.LongName = "LOAD Register C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RCIL | CONTROL_PCC;
    }
}
is_LDC_i = new IS_LDC_imm8;
Instructions.push(is_LDC_i);

class IS_LDD_imm8 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x008;
        this.Mnemonic = "LDD";
        this.LongName = "LOAD Register D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RDIL | CONTROL_PCC;
    }
}
is_LDD_i = new IS_LDD_imm8;
Instructions.push(is_LDD_i);

class IS_LDAB_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x00A;
        this.Mnemonic = "LDAB";
        this.LongName = "LOAD Register A and B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_RBIH | CONTROL_PCC;
    }
}
is_LDAB_i = new IS_LDAB_imm16;
Instructions.push(is_LDAB_i);

class IS_LDAC_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x00B;
        this.Mnemonic = "LDAC";
        this.LongName = "LOAD Register A and C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_RCIH | CONTROL_PCC;
    }
}
is_LDAC_i = new IS_LDAC_imm16;
Instructions.push(is_LDAC_i);

class IS_LDAD_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x00C;
        this.Mnemonic = "LDAD";
        this.LongName = "LOAD Register A and D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_RDIH | CONTROL_PCC;
    }
}
is_LDAD_i = new IS_LDAD_imm16;
Instructions.push(is_LDAD_i);

class IS_LDBA_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x00D;
        this.Mnemonic = "LDBA";
        this.LongName = "LOAD Register B and A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RBIL | CONTROL_RAIH | CONTROL_PCC;
    }
}
is_LDBA_i = new IS_LDBA_imm16;
Instructions.push(is_LDBA_i);

class IS_LDBC_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x00E;
        this.Mnemonic = "LDBC";
        this.LongName = "LOAD Register B and C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RBIL | CONTROL_RCIH | CONTROL_PCC;
    }
}
is_LDBC_i = new IS_LDBC_imm16;
Instructions.push(is_LDBC_i);

class IS_LDBD_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x00F;
        this.Mnemonic = "LDBD";
        this.LongName = "LOAD Register B and D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RBIL | CONTROL_RDIH | CONTROL_PCC;
    }
}
is_LDBD_i = new IS_LDBD_imm16;
Instructions.push(is_LDBD_i);

class IS_LDCA_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x010;
        this.Mnemonic = "LDCA";
        this.LongName = "LOAD Register C and A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RCIL | CONTROL_RAIH | CONTROL_PCC;
    }
}
is_LDCA_i = new IS_LDCA_imm16;
Instructions.push(is_LDCA_i);

class IS_LDCB_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x011;
        this.Mnemonic = "LDCB";
        this.LongName = "LOAD Register C and B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RCIL | CONTROL_RBIH | CONTROL_PCC;
    }
}
is_LDCB_i = new IS_LDCB_imm16;
Instructions.push(is_LDCB_i);

class IS_LDCD_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x012;
        this.Mnemonic = "LDCD";
        this.LongName = "LOAD Register C and D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RCIL | CONTROL_RDIH | CONTROL_PCC;
    }
}
is_LDCD_i = new IS_LDCD_imm16;
Instructions.push(is_LDCD_i);

class IS_LDDA_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x013;
        this.Mnemonic = "LDDA";
        this.LongName = "LOAD Register D and A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RDIL | CONTROL_RAIH | CONTROL_PCC;
    }
}
is_LDDA_i = new IS_LDDA_imm16;
Instructions.push(is_LDDA_i);

class IS_LDDB_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x014;
        this.Mnemonic = "LDDB";
        this.LongName = "LOAD Register D and B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RDIL | CONTROL_RBIH | CONTROL_PCC;
    }
}
is_LDDB_i = new IS_LDDB_imm16;
Instructions.push(is_LDDB_i);

class IS_LDDC_imm16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x015;
        this.Mnemonic = "LDDC";
        this.LongName = "LOAD Register D and C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RDIL | CONTROL_RCIH | CONTROL_PCC;
    }
}
is_LDDC_i = new IS_LDDC_imm16;
Instructions.push(is_LDDC_i);



//--------------------------- General Purpose Registers LDx Absolutes ---------------------------


class IS_LDA_abs16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x042;
        this.Mnemonic = "LDA";
        this.LongName = "LOAD Register A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Absolute;
        this.Operands = new Array({Operand: "", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 5;

        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_PCC;
    }
}
is_LDA_a = new IS_LDA_abs16;
Instructions.push(is_LDA_a);

class IS_LDB_abs16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x044;
        this.Mnemonic = "LDB";
        this.LongName = "LOAD Register B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Absolute;
        this.Operands = new Array({Operand: "", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RBIL | CONTROL_PCC;
    }
}
is_LDB_a = new IS_LDB_abs16;
Instructions.push(is_LDB_a);

class IS_LDC_abs16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x046;
        this.Mnemonic = "LDC";
        this.LongName = "LOAD Register C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Absolute;
        this.Operands = new Array({Operand: "", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RCIL | CONTROL_PCC;
    }
}
is_LDC_a = new IS_LDC_abs16;
Instructions.push(is_LDC_a);

class IS_LDD_abs16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x048;
        this.Mnemonic = "LDD";
        this.LongName = "LOAD Register D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Absolute;
        this.Operands = new Array({Operand: "", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RDIL | CONTROL_PCC;
    }
}
is_LDD_a = new IS_LDD_abs16;
Instructions.push(is_LDD_a);

class IS_LDA_abs24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x062;
        this.Mnemonic = "LDA";
        this.LongName = "LOAD Register A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Absolute;
        this.Operands = new Array({Operand: "", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 12;

        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[6] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[7] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_2O | CONTROL_RHI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_PCC;
        this.Microcode[10] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[11] = CONTROL_OUT_RO | CONTROL_RHI;
    }
}
is_LDA_a24 = new IS_LDA_abs24;
Instructions.push(is_LDA_a24);

class IS_LDB_abs24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x064;
        this.Mnemonic = "LDB";
        this.LongName = "LOAD Register B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Absolute;
        this.Operands = new Array({Operand: "", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 12;

        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[6] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[7] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_2O | CONTROL_RHI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RBIL | CONTROL_PCC;
        this.Microcode[10] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[11] = CONTROL_OUT_RO | CONTROL_RHI;
    }
}
is_LDB_a24 = new IS_LDB_abs24;
Instructions.push(is_LDB_a24);

class IS_LDC_abs24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x066;
        this.Mnemonic = "LDC";
        this.LongName = "LOAD Register C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Absolute;
        this.Operands = new Array({Operand: "", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 12;

        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[6] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[7] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_2O | CONTROL_RHI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RCIL | CONTROL_PCC;
        this.Microcode[10] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[11] = CONTROL_OUT_RO | CONTROL_RHI;
    }
}
is_LDC_a24 = new IS_LDC_abs24;
Instructions.push(is_LDC_a24);

class IS_LDD_abs24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x068;
        this.Mnemonic = "LDD";
        this.LongName = "LOAD Register D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Absolute;
        this.Operands = new Array({Operand: "", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 12;

        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[6] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[7] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_2O | CONTROL_RHI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RDIL | CONTROL_PCC;
        this.Microcode[10] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[11] = CONTROL_OUT_RO | CONTROL_RHI;
    }
}
is_LDD_a24 = new IS_LDD_abs24;
Instructions.push(is_LDD_a24);


//--------------------------- General Purpose Registers LDx Indirect ---------------------------

class IS_LDA_ind16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x082;
        this.Mnemonic = "LDA";
        this.LongName = "LOAD Register A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Indirect;
        this.Operands = new Array({Operand: "#", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 6;

        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_PCC;
    }
}
is_LDA_in = new IS_LDA_ind16;
Instructions.push(is_LDA_in);

class IS_LDB_ind16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x084;
        this.Mnemonic = "LDB";
        this.LongName = "LOAD Register B";
        this.Aliases = new Array();
        this.Words = 2;
        this.Cycles = 6;

        this.Type = InstructionTypes.Indirect;
        this.Operands = new Array({Operand: "#", Bitwidth: 16});
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_RO | CONTROL_RBIL | CONTROL_PCC;
    }
}
is_LDB_in = new IS_LDB_ind16;
Instructions.push(is_LDB_in);

class IS_LDC_ind16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x086;
        this.Mnemonic = "LDC";
        this.LongName = "LOAD Register C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Indirect;
        this.Operands = new Array({Operand: "#", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 6;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_RO | CONTROL_RCIL | CONTROL_PCC;
    }
}
is_LDC_in = new IS_LDC_ind16;
Instructions.push(is_LDC_in);

class IS_LDD_ind16 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x088;
        this.Mnemonic = "LDD";
        this.LongName = "LOAD Register D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Indirect;
        this.Operands = new Array({Operand: "#", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 6;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_RO | CONTROL_RDIL | CONTROL_PCC;
    }
}
is_LDD_in = new IS_LDD_ind16;
Instructions.push(is_LDD_in);

class IS_LDA_ind24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x0C2;
        this.Mnemonic = "LDA";
        this.LongName = "LOAD Register A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Indirect;
        this.Operands = new Array({Operand: "#", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 13;

        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[6] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[7] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_2O | CONTROL_RHI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[10] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_PCC;
        this.Microcode[11] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[12] = CONTROL_OUT_RO | CONTROL_RHI;
    }
}
is_LDA_in24 = new IS_LDA_ind24;
Instructions.push(is_LDA_in24);

class IS_LDB_ind24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x0C4;
        this.Mnemonic = "LDB";
        this.LongName = "LOAD Register B";
        this.Aliases = new Array();
        this.Type = InstructionTypes.Indirect;
        this.Operands = new Array({Operand: "#", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 13;

        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[6] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[7] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_2O | CONTROL_RHI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[10] = CONTROL_OUT_RO | CONTROL_RBIL | CONTROL_PCC;
        this.Microcode[11] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[12] = CONTROL_OUT_RO | CONTROL_RHI;
    }
}
is_LDB_in24 = new IS_LDB_ind24;
Instructions.push(is_LDB_in24);

class IS_LDC_ind24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x0C6;
        this.Mnemonic = "LDC";
        this.LongName = "LOAD Register C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Indirect;
        this.Operands = new Array({Operand: "#", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 13;

        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[6] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[7] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_2O | CONTROL_RHI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[10] = CONTROL_OUT_RO | CONTROL_RCIL | CONTROL_PCC;
        this.Microcode[11] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[12] = CONTROL_OUT_RO | CONTROL_RHI;
    }
}
is_LDC_in24 = new IS_LDC_ind24;
Instructions.push(is_LDC_in24);

class IS_LDD_ind24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x0C8;
        this.Mnemonic = "LDD";
        this.LongName = "LOAD Register D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Indirect;
        this.Operands = new Array({Operand: "#", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 13;

        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[6] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[7] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_2O | CONTROL_RHI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[10] = CONTROL_OUT_RO | CONTROL_RDIL | CONTROL_PCC;
        this.Microcode[11] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[12] = CONTROL_OUT_RO | CONTROL_RHI;
    }
}
is_LDD_in24 = new IS_LDD_ind24;
Instructions.push(is_LDD_in24);


class IS_LDAB_GPCD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x020;
        this.Mnemonic = "LDAB";
        this.LongName = "LOAD Register A and B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "CD", Bitwidth: 16});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_CD | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_RBIH;
    }
}
is_LDAB_GPCD = new IS_LDAB_GPCD;
Instructions.push(is_LDAB_GPCD);


class IS_LDAB_abs extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x022;
        this.Mnemonic = "LDAB";
        this.LongName = "LOAD Register A and B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Absolute;
        this.Operands = new Array({Operand: "", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_RBIH | CONTROL_PCC;
    }
}
is_LDAB_a = new IS_LDAB_abs;
Instructions.push(is_LDAB_a);


class IS_STAL_imm24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x030;
        this.Mnemonic = "STAL";
        this.LongName = "STORE Register A to LOW Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 11;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[6] = CONTROL_OUT_2O | CONTROL_RHI | CONTROL_PCC;
        this.Microcode[7] = CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_AL | CONTROL_RI;
        this.Microcode[9] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[10] = CONTROL_OUT_RO | CONTROL_RHI;

    }
}
is_STAL_i = new IS_STAL_imm24;
Instructions.push(is_STAL_i);

class IS_STAH_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x031;
        this.Mnemonic = "STAH";
        this.LongName = "STORE Register A to HIGH Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC;
        this.Microcode[4] = CONTROL_OUT_AH | CONTROL_RI;
    }
}
is_STAH_i = new IS_STAH_imm;
Instructions.push(is_STAH_i);

class IS_STBL_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x032;
        this.Mnemonic = "STBL";
        this.LongName = "STORE Register B to LOW Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC;
        this.Microcode[4] = CONTROL_OUT_BL | CONTROL_RI;
    }
}
is_STBL_i = new IS_STBL_imm;
Instructions.push(is_STBL_i);

class IS_STBH_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x033;
        this.Mnemonic = "STBH";
        this.LongName = "STORE Register B to HIGH Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC;
        this.Microcode[4] = CONTROL_OUT_BH | CONTROL_RI;
    }
}
is_STBH_i = new IS_STBH_imm;
Instructions.push(is_STBH_i);

class IS_STCL_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x034;
        this.Mnemonic = "STCL";
        this.LongName = "STORE Register C to LOW Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC;
        this.Microcode[4] = CONTROL_OUT_CL | CONTROL_RI;
    }
}
is_STCL_i = new IS_STCL_imm;
Instructions.push(is_STCL_i);

class IS_STCH_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x035;
        this.Mnemonic = "STCH";
        this.LongName = "STORE Register C to HIGH Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC;
        this.Microcode[4] = CONTROL_OUT_CH | CONTROL_RI;
    }
}
is_STCH_i = new IS_STCH_imm;
Instructions.push(is_STCH_i);

class IS_STDL_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x036;
        this.Mnemonic = "STDL";
        this.LongName = "STORE Register D to LOW Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC;
        this.Microcode[4] = CONTROL_OUT_DL | CONTROL_RI;
    }
}
is_STDL_i = new IS_STDL_imm;
Instructions.push(is_STDL_i);

class IS_STDH_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x037;
        this.Mnemonic = "STDH";
        this.LongName = "STORE Register D to HIGH Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC;
        this.Microcode[4] = CONTROL_OUT_DH | CONTROL_RI;
    }
}
is_STDH_i = new IS_STDH_imm;
Instructions.push(is_STDH_i);

class IS_STAB_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x038;
        this.Mnemonic = "STAB";
        this.LongName = "STORE Register A and B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC;
        this.Microcode[4] = CONTROL_OUT_AB | CONTROL_RI;
    }
}
is_STAB_i = new IS_STAB_imm;
Instructions.push(is_STAB_i);

class IS_STAB_sp extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x039;
        this.Mnemonic = "STAB";
        this.LongName = "STORE Register A and B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.RegisterAbsolute;
        this.Operands = new Array({Operand: "SP", Bitwidth: 16});
        this.Words = 1;
        this.Cycles = 6;
        this.Microcode[2] = CONTROL_SPC;
        this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[5] = CONTROL_OUT_AB | CONTROL_RI;
    }
}
is_STAB_sp = new IS_STAB_sp;
Instructions.push(is_STAB_sp);

class IS_PSTAL_sp_ind extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x03A;
        this.Mnemonic = "PSTAL";
        this.LongName = "Page STORE Register A to LOW Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Indirect;
        this.Operands = new Array({Operand: "[SP]", Bitwidth: 16});
        this.Words = 1;
        this.Cycles = 6;
        this.Microcode[2] = CONTROL_SPC;
        this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[5] = CONTROL_OUT_AL | CONTROL_RI;
    }
}
is_PSTAL_spin = new IS_PSTAL_sp_ind;
Instructions.push(is_PSTAL_spin);

class IS_PSTAL_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x03B;
        this.Mnemonic = "PSTAL";
        this.LongName = "Page STORE Register A to LOW Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC;
        this.Microcode[4] = CONTROL_OUT_AL | CONTROL_RI;
    }
}
is_PSTAL_i = new IS_PSTAL_imm;
Instructions.push(is_PSTAL_i);

class IS_STAL_sp_ind24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x03C;
        this.Mnemonic = "STAL";
        this.LongName = "STORE Register A to LOW Byte";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Indirect;
        this.Operands = new Array({Operand: "[SP]", Bitwidth: 16});
        this.Words = 1;
        this.Cycles = 12;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI | CONTROL_SPC;
        this.Microcode[4] = CONTROL_SPC;
        this.Microcode[5] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[6] = CONTROL_OUT_RO | CONTROL_RHI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[7] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[9] = CONTROL_OUT_AL | CONTROL_RI;
        this.Microcode[10] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[11] = CONTROL_OUT_RO | CONTROL_RHI;
        //this.Microcode[12] = 0;
    }
}
is_STAL_spin = new IS_STAL_sp_ind24;
Instructions.push(is_STAL_spin);


class IS_TAB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x040;
        this.Mnemonic = "TAB";
        this.LongName = "TRANSFER Register A to B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_AL | CONTROL_RBIL;
    }
}

is_TAB = new IS_TAB;
Instructions.push(is_TAB);

class IS_TAC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x041;
        this.Mnemonic = "TAC";
        this.LongName = "TRANSFER Register A to C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_AL | CONTROL_RCIL;
    }
}

is_TAC = new IS_TAC;
Instructions.push(is_TAC);

class IS_TAD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x042;
        this.Mnemonic = "TAD";
        this.LongName = "TRANSFER Register A to D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_AL | CONTROL_RDIL;
    }
}

is_TAD = new IS_TAD;
Instructions.push(is_TAD);

class IS_TBA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x043;
        this.Mnemonic = "TBA";
        this.LongName = "TRANSFER Register B to A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_BL | CONTROL_RAIL;
    }
}

is_TBA = new IS_TBA;
Instructions.push(is_TBA);

class IS_TBC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x044;
        this.Mnemonic = "TBC";
        this.LongName = "TRANSFER Register B to C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_BL | CONTROL_RCIL;
    }
}

is_TBC = new IS_TBC;
Instructions.push(is_TBC);

class IS_TBD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x045;
        this.Mnemonic = "TBD";
        this.LongName = "TRANSFER Register B to D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_BL | CONTROL_RDIL;
    }
}

is_TBD = new IS_TBD;
Instructions.push(is_TBD);

class IS_TCA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x046;
        this.Mnemonic = "TCA";
        this.LongName = "TRANSFER Register C to A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_CL | CONTROL_RAIL;
    }
}

is_TCA = new IS_TCA;
Instructions.push(is_TCA);

class IS_TCB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x047;
        this.Mnemonic = "TCB";
        this.LongName = "TRANSFER Register C to B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_CL | CONTROL_RBIL;
    }
}

is_TCB = new IS_TCB;
Instructions.push(is_TCB);

class IS_TCD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x048;
        this.Mnemonic = "TCD";
        this.LongName = "TRANSFER Register C to D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_CL | CONTROL_RDIL;
    }
}

is_TCD = new IS_TCD;
Instructions.push(is_TCD);

class IS_TDA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x049;
        this.Mnemonic = "TDA";
        this.LongName = "TRANSFER Register D to A";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_DL | CONTROL_RAIL;
    }
}

is_TDA = new IS_TDA;
Instructions.push(is_TDA);

class IS_TDB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x04A;
        this.Mnemonic = "TDB";
        this.LongName = "TRANSFER Register D to B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_DL | CONTROL_RBIL;
    }
}

is_TDB = new IS_TDB;
Instructions.push(is_TDB);

class IS_TDC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x04B;
        this.Mnemonic = "TDC";
        this.LongName = "TRANSFER Register D to C";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_DL | CONTROL_RCIL;
    }
}

is_TDC = new IS_TDC;
Instructions.push(is_TDC);

// This is a simple ADD command which will ADD GPA and GPB putting the sum in GPA
class IS_ADD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x100;
        this.Mnemonic = "ADD";
        this.LongName = "Addition";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "A", Bitwidth: 8},{Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_ALU_ADD | CONTROL_OUT_AB;
        this.Microcode[3] = CONTROL_RAIL | CONTROL_OUT_AO;
    }
}
is_ADD = new IS_ADD;
Instructions.push(is_ADD);

class IS_SUB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x101;
        this.Mnemonic = "SUB";
        this.LongName = "Subtraction";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "A", Bitwidth: 8},{Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_ALU_SUB;
        this.Microcode[3] = CONTROL_RAIL | CONTROL_OUT_AO;
    }
}
is_SUB = new IS_SUB;
Instructions.push(is_SUB);

class IS_NOT extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x102;
        this.Mnemonic = "NOT";
        this.LongName = "Logical NOT";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 9;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_AL | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[4] = CONTROL_RAIL;
        this.Microcode[5] = CONTROL_ALU_NOT;
        this.Microcode[6] = CONTROL_OUT_AO | CONTROL_RBIL | CONTROL_SPC;
        this.Microcode[7] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[8] = CONTROL_OUT_RO | CONTROL_RAIL;
    }
}
is_NOT = new IS_NOT;
Instructions.push(is_NOT);

class IS_FNOT extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x103;
        this.Mnemonic = "FNOT";
        this.LongName = "Logical FAST NOT";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_ALU_NOT;
        this.Microcode[3] = CONTROL_RBIL | CONTROL_OUT_AO | CONTROL_SPC;
    }
}
is_FNOT = new IS_FNOT;
Instructions.push(is_FNOT);

class IS_AND extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x104;
        this.Mnemonic = "AND";
        this.LongName = "Logical AND";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "A", Bitwidth: 8},{Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_ALU_AND;
        this.Microcode[3] = CONTROL_RAIL | CONTROL_OUT_AO | CONTROL_SPC;
    }
}
is_AND = new IS_AND;
Instructions.push(is_AND);

class IS_NAND extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x105;
        this.Mnemonic = "NAND";
        this.LongName = "Logical NAND";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "A", Bitwidth: 8},{Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_ALU_NAND;
        this.Microcode[3] = CONTROL_RAIL | CONTROL_OUT_AO | CONTROL_SPC;
    }
}
is_NAND = new IS_NAND;
Instructions.push(is_NAND);

class IS_OR extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x106;
        this.Mnemonic = "OR";
        this.LongName = "Logical OR";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "A", Bitwidth: 8},{Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_ALU_OR;
        this.Microcode[3] = CONTROL_RAIL | CONTROL_OUT_AO | CONTROL_SPC;
    }
}
is_OR = new IS_OR;
Instructions.push(is_OR);

class IS_NOR extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x107;
        this.Mnemonic = "NOR";
        this.LongName = "Logical NOR";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "A", Bitwidth: 8},{Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_ALU_NOR;
        this.Microcode[3] = CONTROL_RAIL | CONTROL_OUT_AO | CONTROL_SPC;
    }
}
is_NOR = new IS_NOR;
Instructions.push(is_NOR);

class IS_XOR extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x108;
        this.Mnemonic = "XOR";
        this.LongName = "Logical XOR";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "A", Bitwidth: 8},{Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_ALU_XOR;
        this.Microcode[3] = CONTROL_RAIL | CONTROL_OUT_AO | CONTROL_SPC;
    }
}
is_XOR = new IS_XOR;
Instructions.push(is_XOR);

class IS_XNOR extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x109;
        this.Mnemonic = "XNOR";
        this.LongName = "Logical XNOR";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "A", Bitwidth: 8},{Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_ALU_XNOR;
        this.Microcode[3] = CONTROL_RAIL | CONTROL_OUT_AO | CONTROL_SPC;
    }
}
is_XNOR = new IS_XNOR;
Instructions.push(is_XNOR);

class IS_CMP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x10A;
        this.Mnemonic = "CMP";
        this.LongName = "Logical COMPARE";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "A", Bitwidth: 8},{Operand: "B", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_AB | CONTROL_ALU_ADD;
    }
}
is_CMP = new IS_CMP;
Instructions.push(is_CMP);

class IS_CMP_gpcd_abs extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x10B;
        this.Mnemonic = "CMP";
        this.LongName = "Logical COMPARE";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Absolute;
        this.Operands = new Array({Operand: "CD", Bitwidth: 16});
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_CD | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_ALU_ADD;
    }
}
is_CMP_cda = new IS_CMP_gpcd_abs();
Instructions.push(is_CMP_cda);

class IS_CMP_gpc_gpd extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x10C;
        this.Mnemonic = "CMP";
        this.LongName = "Logical COMPARE";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "C", Bitwidth: 8},{Operand: "D", Bitwidth: 8});
        this.Words = 1;
        this.Cycles = 3;
        this.Microcode[2] = CONTROL_OUT_CD | CONTROL_ALU_ADD;
    }
}
is_CMP_c_d = new IS_CMP_gpc_gpd();
Instructions.push(is_CMP_c_d);

class IS_ADD_gpa_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x10D;
        this.Mnemonic = "ADD";
        this.LongName = "Addition";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "A", Bitwidth: 8},{Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 10;
        this.Microcode[2]  = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3]  = CONTROL_OUT_BL | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[4]  = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5]  = CONTROL_OUT_RO | CONTROL_RBIL | CONTROL_PCC;
        this.Microcode[6]  = CONTROL_OUT_AB | CONTROL_ALU_ADD;
        this.Microcode[7]  = CONTROL_OUT_AO | CONTROL_RAIL | CONTROL_SPC;
        this.Microcode[8]  = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RBIL;
    }
}
is_ADD_gpai = new IS_ADD_gpa_imm;
Instructions.push(is_ADD_gpai);

class IS_ADD_gpb_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x10E;
        this.Mnemonic = "ADD";
        this.LongName = "Addition";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "B", Bitwidth: 8},{Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 10;
        this.Microcode[2]  = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3]  = CONTROL_OUT_AL | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[4]  = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5]  = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_PCC;
        this.Microcode[6]  = CONTROL_OUT_AB | CONTROL_ALU_ADD;
        this.Microcode[7]  = CONTROL_OUT_AO | CONTROL_RBIL | CONTROL_SPC;
        this.Microcode[8]  = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RAIL;
    }
}
is_ADD_gpbi = new IS_ADD_gpb_imm;
Instructions.push(is_ADD_gpbi);

class IS_ADD_gpc_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x10F;
        this.Mnemonic = "ADD";
        this.LongName = "Addition";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "C", Bitwidth: 8},{Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 10;
        this.Microcode[2]  = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3]  = CONTROL_OUT_AL | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[4]  = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5]  = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_PCC;
        this.Microcode[6]  = CONTROL_OUT_CA | CONTROL_ALU_ADD;
        this.Microcode[7]  = CONTROL_OUT_AO | CONTROL_RCIL | CONTROL_SPC;
        this.Microcode[8]  = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RAIL;
    }
}
is_ADD_gpci = new IS_ADD_gpc_imm;
Instructions.push(is_ADD_gpci);


class IS_ADD_gpd_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x110;
        this.Mnemonic = "ADD";
        this.LongName = "Addition";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "D", Bitwidth: 8},{Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 10;
        this.Microcode[2]  = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3]  = CONTROL_OUT_AL | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[4]  = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5]  = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_PCC;
        this.Microcode[6]  = CONTROL_OUT_DA | CONTROL_ALU_ADD;
        this.Microcode[7]  = CONTROL_OUT_AO | CONTROL_RDIL | CONTROL_SPC;
        this.Microcode[8]  = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_RAIL;
    }
}
is_ADD_gpdi = new IS_ADD_gpd_imm;
Instructions.push(is_ADD_gpdi);


class IS_PHA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x180;
        this.Mnemonic = "PHA";
        this.LongName = "PUSH Register A to the STACK";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_AL | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
    }
}
is_PHA = new IS_PHA;
Instructions.push(is_PHA);

class IS_PHB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x181;
        this.Mnemonic = "PHB";
        this.LongName = "PUSH Register B to the STACK";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_BL | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
    }
}
is_PHB = new IS_PHB;
Instructions.push(is_PHB);

class IS_PHC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x182;
        this.Mnemonic = "PHC";
        this.LongName = "PUSH Register C to the STACK";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_CL | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
    }
}
is_PHC = new IS_PHC;
Instructions.push(is_PHC);

class IS_PHD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x183;
        this.Mnemonic = "PHD";
        this.LongName = "PUSH Register D to the STACK";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_DL | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
    }
}
is_PHD = new IS_PHD;
Instructions.push(is_PHD);

class IS_PHAB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x184;
        this.Mnemonic = "PHAB";
        this.LongName = "PUSH Register A and B to the STACK";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_AB | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
    }
}
is_PHAB = new IS_PHAB;
Instructions.push(is_PHAB);

class IS_PHCD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x185;
        this.Mnemonic = "PHCD";
        this.LongName = "PUSH Register C and D to the STACK";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_CD | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
    }
}
is_PHCD = new IS_PHCD;
Instructions.push(is_PHCD);


class IS_PLA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x1A0;
        this.Mnemonic = "PLA";
        this.LongName = "PULL Stack and place in Register A (Low BYTE)";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_SPC;
        this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RAIL;
    }
}
is_PLA = new IS_PLA;
Instructions.push(is_PLA);

class IS_PLB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x1A1;
        this.Mnemonic = "PLB";
        this.LongName = "PULL Stack and place in Register B (Low BYTE)";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Words = 1;
        this.Cycles = 5;
        this.Operands = new Array();
        this.Microcode[2] = CONTROL_SPC;
        this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RBIL;
    }
}
is_PLB = new IS_PLB;
Instructions.push(is_PLB);

class IS_PLC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x1A2;
        this.Mnemonic = "PLC";
        this.LongName = "PULL Stack and place in Register C (Low BYTE)";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_SPC;
        this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RCIL;
    }
}
is_PLC = new IS_PLC;
Instructions.push(is_PLC);

class IS_PLD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x1A3;
        this.Mnemonic = "PLD";
        this.LongName = "PULL Stack and place in Register D (Low BYTE)";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_SPC;
        this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RDIL;
    }
}
is_PLD = new IS_PLD;
Instructions.push(is_PLD);

class IS_PLAB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x1A4;
        this.Mnemonic = "PLAB";
        this.LongName = "PULL Stack and place in Register A and B";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_SPC;
        this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RAIL | CONTROL_RBIH;
    }
}
is_PLAB = new IS_PLAB;
Instructions.push(is_PLAB);

class IS_PLCD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x1A5;
        this.Mnemonic = "PLCD";
        this.LongName = "PULL Stack and place in Register C and D";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 5;
        this.Microcode[2] = CONTROL_SPC;
        this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RCIL | CONTROL_RDIH;
    }
}
is_PLCD = new IS_PLCD;
Instructions.push(is_PLCD);


class IS_JMP_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x200;
        this.Mnemonic = "JMP";
        this.LongName = "JUMP to address";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_PCI;
    }
}
is_JMP_i = new IS_JMP_imm;
Instructions.push(is_JMP_i);

class IS_BCC_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.UsesCarry = true;
        this.Bytecode = 0x201;
        this.Mnemonic = "BCC";
        this.LongName = "Branch if Carry Clear";
        this.Aliases = new Array("JNC");

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.CarryWords = 2;
        this.CarryCycles = 3;
        this.MicrocodeCarry = new Array(16);
        for (let a = 0; a < 16; a++) {
            this.MicrocodeCarry[a] = this.Microcode[a];
        }
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_PCI;
        this.MicrocodeCarry[2] = CONTROL_PCC; // Step over the immediate value
    }
}
is_BCC_i = new IS_BCC_imm;
Instructions.push(is_BCC_i);

class IS_BCS_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.UsesCarry = true;
        this.Bytecode = 0x202;
        this.Mnemonic = "BCS";
        this.LongName = "Branch if Carry Set";
        this.Aliases = new Array("JC");

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 3;
        this.CarryWords = 2;
        this.CarryCycles = 4;
        this.MicrocodeCarry = new Array(16);
        for (let a = 0; a < 16; a++) {
            this.MicrocodeCarry[a] = this.Microcode[a];
        }
        this.Microcode[2] = CONTROL_PCC; // Step over the immediate value
        this.MicrocodeCarry[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.MicrocodeCarry[3] = CONTROL_OUT_RO | CONTROL_PCI;
    }
}

is_BCS_i = new IS_BCS_imm;
Instructions.push(is_BCS_i);

class IS_BEQ_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.UsesZero = true;
        this.Bytecode = 0x203;
        this.Mnemonic = "BEQ";
        this.LongName = "Branch if Equal";
        this.Aliases = new Array("JE","JZ");

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 3;
        this.ZeroWords = 2;
        this.ZeroCycles = 4;
        this.MicrocodeZero = new Array(16);
        for (let a = 0; a < 16; a++) {
            this.MicrocodeZero[a] = this.Microcode[a];
        }
        this.Microcode[2] = CONTROL_PCC; // Step over the immediate value
        this.MicrocodeZero[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.MicrocodeZero[3] = CONTROL_OUT_RO | CONTROL_PCI;
    }
}

is_BEQ_i = new IS_BEQ_imm;
Instructions.push(is_BEQ_i);

class IS_BNE_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.UsesZero = true;
        this.Bytecode = 0x204;
        this.Mnemonic = "BNE";
        this.LongName = "Branch if NOT Equal";
        this.Aliases = new Array("JNE","JNZ");

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 4;
        this.ZeroWords = 2;
        this.ZeroCycles = 3;
        this.MicrocodeZero = new Array(16);
        for (let a = 0; a < 16; a++) {
            this.MicrocodeZero[a] = this.Microcode[a];
        }
        this.MicrocodeZero[2] = CONTROL_PCC; // Step over the immediate value
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_RO | CONTROL_PCI;
    }
}

is_BNE_i = new IS_BNE_imm;
Instructions.push(is_BNE_i);

class IS_JSR extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x205;
        this.Mnemonic = "JSR";
        this.LongName = "JUMP to Subroutine";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 11;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_PC | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[4] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_HO | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[6] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[7] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[8] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[9] = CONTROL_OUT_RO | CONTROL_PCI;
        this.Microcode[10] = CONTROL_OUT_2O | CONTROL_RHI;
    }
}
is_JSR = new IS_JSR;
Instructions.push(is_JSR);

class IS_PJSR extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x206;
        this.Mnemonic = "PJSR";
        this.LongName = "Page JUMP to Subroutine";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 16});
        this.Words = 2;
        this.Cycles = 6;
        this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_PC | CONTROL_RI | CONTROL_SPD | CONTROL_SPC;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_RO | CONTROL_PCI;

    }
}
is_PJSR = new IS_PJSR;
Instructions.push(is_PJSR);

class IS_RTS extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x207;
        this.Mnemonic = "RTS";
        this.LongName = "RETURN from Subroutine";
        this.Aliases = new Array();

        this.Type = InstructionTypes.SingleWord;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 9;
        this.Microcode[2] = CONTROL_SPC;
        this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_I2 | CONTROL_SPC;
        this.Microcode[5] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[6] = CONTROL_OUT_RO | CONTROL_PCI;
        this.Microcode[7] = CONTROL_OUT_2O | CONTROL_RHI | CONTROL_PCC;
        this.Microcode[8] = CONTROL_PCC;
    }
}
is_RTS = new IS_RTS;
Instructions.push(is_RTS);

class IS_PRTS extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x208;
        this.Mnemonic = "PRTS";
        this.LongName = "Page RETURN from Subroutine";
        this.Aliases = new Array();

        this.Type = InstructionTypes.SingleWord;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 6;
        this.Microcode[2] = CONTROL_SPC;
        this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI;
        this.Microcode[4] = CONTROL_OUT_RO | CONTROL_PCI;
        this.Microcode[5] = CONTROL_PCC;
    }
}
is_PRTS = new IS_PRTS;
Instructions.push(is_PRTS);

class IS_JMP_imm24 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x209;
        this.Mnemonic = "JMP";
        this.LongName = "JUMP to address";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Immediate;
        this.Operands = new Array({Operand: "$", Bitwidth: 24});
        this.Words = 3;
        this.Cycles = 7;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_I2 | CONTROL_PCC;
        this.Microcode[4] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[5] = CONTROL_OUT_RO | CONTROL_PCI;
        this.Microcode[6] = CONTROL_OUT_2O | CONTROL_RHI;
    }
}
is_JMP_i24 = new IS_JMP_imm24;
Instructions.push(is_JMP_i24);

class IS_LDSPP_imm extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x20A;
        this.Mnemonic = "LDSPP";
        this.LongName = "LOAD Stack Pointer Page";
        this.Aliases = new Array();

        this.Type = InstructionTypes.Register;
        this.Operands = new Array({Operand: "$", Bitwidth: 8});
        this.Words = 2;
        this.Cycles = 4;
        this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI;
        this.Microcode[3] = CONTROL_OUT_HS | CONTROL_PCC;
    }
}
is_LDSPP_i = new IS_LDSPP_imm;
Instructions.push(is_LDSPP_i);



class IS_NOP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x3ff;
        this.Mnemonic = "NOP";
        this.LongName = "NO OPERATION";
        this.Aliases = new Array();

        this.Type = InstructionTypes.SingleWord;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 2;
    }
}
is_NOP = new IS_NOP;
Instructions.push(is_NOP);

class IS_NOP0 extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x0;
        this.Mnemonic = "NOP";
        this.LongName = "NO OPERATION";
        this.Aliases = new Array();

        this.Type = InstructionTypes.SingleWord;
        this.Operands = new Array();
        this.Words = 1;
        this.Cycles = 2;
    }
}
is_NOP0 = new IS_NOP0;
Instructions.push(is_NOP0);