/*
        TRANSFER x Instructions

        OPCODE Range:   0x200:0x23F
*/

class IS_TAB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x200;
        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 = 0x201;
        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 = 0x202;
        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 = 0x203;
        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 = 0x204;
        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 = 0x205;
        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 = 0x206;
        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 = 0x207;
        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 = 0x208;
        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 = 0x209;
        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 = 0x20A;
        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 = 0x20B;
        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);

class IS_TABCD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x20C;
        this.Mnemonic = "TABCD";
        this.LongName = "TRANSFER Registers A and B to C and D";
        this.Aliases = new Array();

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

is_TABCD = new IS_TABCD;
Instructions.push(is_TABCD);

class IS_TABDC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x20D;
        this.Mnemonic = "TABDC";
        this.LongName = "TRANSFER Registers A and B to D and C";
        this.Aliases = new Array();

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

is_TABDC = new IS_TABDC;
Instructions.push(is_TABDC);

class IS_TBACD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x20E;
        this.Mnemonic = "TBACD";
        this.LongName = "TRANSFER Registers B and A to C and D";
        this.Aliases = new Array();

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

is_TBACD = new IS_TBACD;
Instructions.push(is_TBACD);

class IS_TBADC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x20F;
        this.Mnemonic = "TBADC";
        this.LongName = "TRANSFER Registers B and A to D and C";
        this.Aliases = new Array();

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

is_TBADC = new IS_TBADC;
Instructions.push(is_TBADC);

class IS_TCABD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x210;
        this.Mnemonic = "TCABD";
        this.LongName = "TRANSFER Registers C and A to B and D";
        this.Aliases = new Array();

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

is_TCABD = new IS_TCABD;
Instructions.push(is_TCABD);

class IS_TCADB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x211;
        this.Mnemonic = "TCADB";
        this.LongName = "TRANSFER Registers C and A to D and B";
        this.Aliases = new Array();

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

is_TCADB = new IS_TCADB;
Instructions.push(is_TCADB);

class IS_TCBAD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x212;
        this.Mnemonic = "TCBAD";
        this.LongName = "TRANSFER Registers C and B to A and D";
        this.Aliases = new Array();

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

is_TCBAD = new IS_TCBAD;
Instructions.push(is_TCBAD);

class IS_TCBDA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x213;
        this.Mnemonic = "TCBDA";
        this.LongName = "TRANSFER Registers C and B to D and A";
        this.Aliases = new Array();

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

is_TCBDA = new IS_TCBDA;
Instructions.push(is_TCBDA);

class IS_TCDAB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x214;
        this.Mnemonic = "TCDAB";
        this.LongName = "TRANSFER Registers C and D to A and B";
        this.Aliases = new Array();

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

is_TCDAB = new IS_TCDAB;
Instructions.push(is_TCDAB);

class IS_TCDBA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x215;
        this.Mnemonic = "TCDBA";
        this.LongName = "TRANSFER Registers C and D to B and A";
        this.Aliases = new Array();

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

is_TCDBA = new IS_TCDBA;
Instructions.push(is_TCDBA);

class IS_TDABC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x216;
        this.Mnemonic = "TDABC";
        this.LongName = "TRANSFER Registers D and A to B and C";
        this.Aliases = new Array();

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

is_TDABC = new IS_TDABC;
Instructions.push(is_TDABC);

class IS_TDACB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x217;
        this.Mnemonic = "TDACB";
        this.LongName = "TRANSFER Registers D and A to C and B";
        this.Aliases = new Array();

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

is_TDACB = new IS_TDACB;
Instructions.push(is_TDACB);

class IS_TDBAC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x218;
        this.Mnemonic = "TDBAC";
        this.LongName = "TRANSFER Registers D and B to A and C";
        this.Aliases = new Array();

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

is_TDBAC = new IS_TDBAC;
Instructions.push(is_TDBAC);

class IS_TDBCA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x219;
        this.Mnemonic = "TDBCA";
        this.LongName = "TRANSFER Registers D and B to C and A";
        this.Aliases = new Array();

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

is_TDBCA = new IS_TDBCA;
Instructions.push(is_TDBCA);

class IS_TDCAB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x21A;
        this.Mnemonic = "TDCAB";
        this.LongName = "TRANSFER Registers D and C to A and B";
        this.Aliases = new Array();

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

is_TDCAB = new IS_TDCAB;
Instructions.push(is_TDCAB);

class IS_TDCBA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x21B;
        this.Mnemonic = "TDCBA";
        this.LongName = "TRANSFER Registers D and C to B and A";
        this.Aliases = new Array();

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

is_TDCBA = new IS_TDCBA;
Instructions.push(is_TDCBA);

class IS_TSPAB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x21C;
        this.Mnemonic = "TSPAB";
        this.LongName = "TRANSFER Registers Stack Pointer to A and B";
        this.Aliases = new Array();

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

is_TSPAB = new IS_TSPAB;
Instructions.push(is_TSPAB);

class IS_TSPAC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x21D;
        this.Mnemonic = "TSPAC";
        this.LongName = "TRANSFER Registers Stack Pointer to A and C";
        this.Aliases = new Array();

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

is_TSPAC = new IS_TSPAC;
Instructions.push(is_TSPAC);

class IS_TSPAD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x21E;
        this.Mnemonic = "TSPAD";
        this.LongName = "TRANSFER Registers Stack Pointer to A and D";
        this.Aliases = new Array();

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

is_TSPAD = new IS_TSPAD;
Instructions.push(is_TSPAD);

class IS_TSPBA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x21F;
        this.Mnemonic = "TSPBA";
        this.LongName = "TRANSFER Registers Stack Pointer to B and A";
        this.Aliases = new Array();

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

is_TSPBA = new IS_TSPBA;
Instructions.push(is_TSPBA);


class IS_TSPBC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x220;
        this.Mnemonic = "TSPBC";
        this.LongName = "TRANSFER Registers Stack Pointer to B and C";
        this.Aliases = new Array();

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

is_TSPBC = new IS_TSPBC;
Instructions.push(is_TSPBC);

class IS_TSPBD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x221;
        this.Mnemonic = "TSPBD";
        this.LongName = "TRANSFER Registers Stack Pointer to B and D";
        this.Aliases = new Array();

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

is_TSPBD = new IS_TSPBD;
Instructions.push(is_TSPBD);

class IS_TSPCA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x222;
        this.Mnemonic = "TSPCA";
        this.LongName = "TRANSFER Registers Stack Pointer to C and A";
        this.Aliases = new Array();

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

is_TSPCA = new IS_TSPCA;
Instructions.push(is_TSPCA);

class IS_TSPCB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x223;
        this.Mnemonic = "TSPCB";
        this.LongName = "TRANSFER Registers Stack Pointer to C and B";
        this.Aliases = new Array();

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

is_TSPCB = new IS_TSPCB;
Instructions.push(is_TSPCB);

class IS_TSPCD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x224;
        this.Mnemonic = "TSPCD";
        this.LongName = "TRANSFER Registers Stack Pointer to C and D";
        this.Aliases = new Array();

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

is_TSPCD = new IS_TSPCD;
Instructions.push(is_TSPCD);

class IS_TSPDA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x225;
        this.Mnemonic = "TSPDA";
        this.LongName = "TRANSFER Registers Stack Pointer to D and A";
        this.Aliases = new Array();

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

is_TSPDA = new IS_TSPDA;
Instructions.push(is_TSPDA);

class IS_TSPDB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x226;
        this.Mnemonic = "TSPDB";
        this.LongName = "TRANSFER Registers Stack Pointer to D and B";
        this.Aliases = new Array();

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

is_TSPDB = new IS_TSPDB;
Instructions.push(is_TSPDB);

class IS_TSPDC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x227;
        this.Mnemonic = "TSPDC";
        this.LongName = "TRANSFER Registers Stack Pointer to D and C";
        this.Aliases = new Array();

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

is_TSPDC = new IS_TSPDC;
Instructions.push(is_TSPDC);

class IS_TSRA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x228;
        this.Mnemonic = "TSRA";
        this.LongName = "TRANSFER Registers Status Register 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_SR | CONTROL_RAIL;
    }
}

is_TSRA = new IS_TSRA;
Instructions.push(is_TSRA);

class IS_TSRB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x229;
        this.Mnemonic = "TSRB";
        this.LongName = "TRANSFER Registers Status Register 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_SR | CONTROL_RBIL;
    }
}

is_TSRB = new IS_TSRB;
Instructions.push(is_TSRB);

class IS_TSRC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x22A;
        this.Mnemonic = "TSRC";
        this.LongName = "TRANSFER Registers Status Register 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_SR | CONTROL_RCIL;
    }
}

is_TSRC = new IS_TSRC;
Instructions.push(is_TSRC);

class IS_TSRD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x22B;
        this.Mnemonic = "TSRD";
        this.LongName = "TRANSFER Registers Status Register 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_SR | CONTROL_RDIL;
    }
}

is_TSRD = new IS_TSRD;
Instructions.push(is_TSRD);

class IS_TABSP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x22C;
        this.Mnemonic = "TABSP";
        this.LongName = "TRANSFER Registers A and B to Stack Pointer";
        this.Aliases = new Array();

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

is_TABSP = new IS_TABSP;
Instructions.push(is_TABSP);

class IS_TACSP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x22D;
        this.Mnemonic = "TACSP";
        this.LongName = "TRANSFER Registers A and C to Stack Pointer";
        this.Aliases = new Array();

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

is_TACSP = new IS_TACSP;
Instructions.push(is_TACSP);

class IS_TADSP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x22E;
        this.Mnemonic = "TADSP";
        this.LongName = "TRANSFER Registers A and D to Stack Pointer";
        this.Aliases = new Array();

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

is_TADSP = new IS_TADSP;
Instructions.push(is_TADSP);

class IS_TBASP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x22F;
        this.Mnemonic = "TBASP";
        this.LongName = "TRANSFER Registers B and A to Stack Pointer";
        this.Aliases = new Array();

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

is_TBASP = new IS_TBASP;
Instructions.push(is_TBASP);

class IS_TBCSP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x230;
        this.Mnemonic = "TBCSP";
        this.LongName = "TRANSFER Registers B and C to Stack Pointer";
        this.Aliases = new Array();

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

is_TBCSP = new IS_TBCSP;
Instructions.push(is_TBCSP);

class IS_TBDSP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x231;
        this.Mnemonic = "TBDSP";
        this.LongName = "TRANSFER Registers B and D to Stack Pointer";
        this.Aliases = new Array();

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

is_TBDSP = new IS_TBDSP;
Instructions.push(is_TBDSP);

class IS_TCASP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x232;
        this.Mnemonic = "TCASP";
        this.LongName = "TRANSFER Registers C and A to Stack Pointer";
        this.Aliases = new Array();

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

is_TCASP = new IS_TCASP;
Instructions.push(is_TCASP);

class IS_TCBSP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x233;
        this.Mnemonic = "TCBSP";
        this.LongName = "TRANSFER Registers C and B to Stack Pointer";
        this.Aliases = new Array();

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

is_TCBSP = new IS_TCBSP;
Instructions.push(is_TCBSP);

class IS_TCDSP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x234;
        this.Mnemonic = "TCDSP";
        this.LongName = "TRANSFER Registers C and D to Stack Pointer";
        this.Aliases = new Array();

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

is_TCDSP = new IS_TCDSP;
Instructions.push(is_TCDSP);

class IS_TDASP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x235;
        this.Mnemonic = "TDASP";
        this.LongName = "TRANSFER Registers D and A to Stack Pointer";
        this.Aliases = new Array();

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

is_TDASP = new IS_TDASP;
Instructions.push(is_TDASP);

class IS_TDBSP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x236;
        this.Mnemonic = "TDBSP";
        this.LongName = "TRANSFER Registers D and B to Stack Pointer";
        this.Aliases = new Array();

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

is_TDBSP = new IS_TDBSP;
Instructions.push(is_TDBSP);

class IS_TDCSP extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x237;
        this.Mnemonic = "TDCSP";
        this.LongName = "TRANSFER Registers D and C to Stack Pointer";
        this.Aliases = new Array();

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

is_TDCSP = new IS_TDCSP;
Instructions.push(is_TDCSP);

class IS_THRA extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x238;
        this.Mnemonic = "THRA";
        this.LongName = "TRANSFER High RAM Page Register 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_HO | CONTROL_RAIL;
    }
}

is_THRA = new IS_THRA;
Instructions.push(is_THRA);

class IS_THRB extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x239;
        this.Mnemonic = "THRB";
        this.LongName = "TRANSFER High RAM Page Register 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_HO | CONTROL_RBIL;
    }
}

is_THRB = new IS_THRB;
Instructions.push(is_THRB);

class IS_THRC extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x23A;
        this.Mnemonic = "THRC";
        this.LongName = "TRANSFER High RAM Page Register 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_HO | CONTROL_RCIL;
    }
}

is_THRC = new IS_THRC;
Instructions.push(is_THRC);

class IS_THRD extends Microcode_Instruction {
    constructor(props) {
        super(props);
        this.Bytecode = 0x23B;
        this.Mnemonic = "THRD";
        this.LongName = "TRANSFER High RAM Page Register 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_HO | CONTROL_RDIL;
    }
}

is_THRD = new IS_THRD;
Instructions.push(is_THRD);