From 91c53ef07452fdbc94a3fdf7452db036f47a1331 Mon Sep 17 00:00:00 2001 From: MatCat Date: Sun, 11 Apr 2021 16:22:48 -0700 Subject: [PATCH] WIP STx --- js/defines.js | 8 + js/isa/stx.js | 1085 ++++++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 993 insertions(+), 100 deletions(-) diff --git a/js/defines.js b/js/defines.js index d70a501..b3605c9 100644 --- a/js/defines.js +++ b/js/defines.js @@ -84,9 +84,17 @@ const CONTROL_OUT_CH = CONTROL_OEME | CONTROL_OEM2 | CONTROL_OEM1 | CONTROL_OEM0 const CONTROL_OUT_DL = CONTROL_OEME | CONTROL_OEM3; const CONTROL_OUT_DH = CONTROL_OEME | CONTROL_OEM3 | CONTROL_OEM0; const CONTROL_OUT_AB = CONTROL_OEME | CONTROL_OEM3 | CONTROL_OEM1; +const CONTROL_OUT_AC = CONTROL_OEME | CONTROL_OEM3 | CONTROL_OEM1 | CONTROL_OEM0; +const CONTROL_OUT_AD = CONTROL_OEME | CONTROL_OEM3 | CONTROL_OEM2; +const CONTROL_OUT_BA = CONTROL_OEME | CONTROL_OEM3 | CONTROL_OEM2 | CONTROL_OEM0; +const CONTROL_OUT_BC = CONTROL_OEME | CONTROL_OEM3 | CONTROL_OEM2 | CONTROL_OEM1; +const CONTROL_OUT_BD = CONTROL_OEME | CONTROL_OEM3 | CONTROL_OEM2 | CONTROL_OEM1 | CONTROL_OEM0; const CONTROL_OUT_CA = CONTROL_OEME | CONTROL_OEM4; +const CONTROL_OUT_CB = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM0; const CONTROL_OUT_CD = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM1; const CONTROL_OUT_DA = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM1 | CONTROL_OEM0; +const CONTROL_OUT_DB = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM2; +const CONTROL_OUT_DC = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM2 | CONTROL_OEM0; const CONTROL_OUT_I2 = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM3; const CONTROL_OUT_2O = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM3 | CONTROL_OEM0; const CONTROL_OUT_HO = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM3 | CONTROL_OEM1; diff --git a/js/isa/stx.js b/js/isa/stx.js index 4aca19e..92c482e 100644 --- a/js/isa/stx.js +++ b/js/isa/stx.js @@ -1,183 +1,1087 @@ -class IS_STAL_imm16 extends Microcode_Instruction { +/* + SAVE x Instructions + + OPCODE Range: 0x100:0x1FF + + Addressing follows the following bit table: + + 0b000XXXXX Immediate store (8 bit for A-D, 16 bit for paired registers) + 0b001XXXXX 16 bit Absolute + 16 bit Immediate Offset (signed) + 0b010XXXXX 16 bit Absolute + 0b011XXXXX 24 bit Absolute + 0b100XXXXX 16 bit Indirect + 0b101XXXXX 24 bit Indirect + 0b110XXXXX 24 bit Indirect + 16 bit immediate offset (signed) + 0b111XXXXX 24 bit Absolute + 16 bit Absolute offset (signed) + + Register FROM follows the following bit table: + + 0bXXX00000 [0x00] ABCD // ONLY for absolutes and indirects + 0bXXX00001 [0x01] CDAB // ONLY for absolutes and indirects + 0bXXX00010 [0x02] AL + 0bXXX00011 [0x03] AH + 0bXXX00100 [0x04] BL + 0bXXX00101 [0x05] BH + 0bXXX00110 [0x06] CL + 0bXXX00111 [0x07] CH + 0bXXX01000 [0x08] DL + 0bXXX01001 [0x09] DH + 0bXXX01010 [0x0A] AB + 0bXXX01011 [0x0B] AC + 0bXXX01100 [0x0C] AD + 0bXXX01101 [0x0D] BA + 0bXXX01110 [0x0E] BC + 0bXXX01111 [0x0F] BD + 0bXXX10000 [0x10] CA + 0bXXX10001 [0x11] CB + 0bXXX10010 [0x12] CD + 0bXXX10011 [0x13] DA + 0bXXX10100 [0x14] DB + 0bXXX10101 [0x15] DC + 0bXXX10110 [0x16] ABSP + 0bXXX10111 [0x17] CDSP + 0bXXX11000 [0x18] ALSP + 0bXXX11001 [0x19] AHSP + 0bXXX11010 [0x1A] BLSP + 0bXXX11011 [0x1B] BHSP + 0bXXX11100 [0x1C] + 0bXXX11101 [0x1D] + 0bXXX11110 [0x1E] SP + 0bXXX11111 [0x1F] SPP + + + Examples: + 24 bit indirect STAB [SP] -> 0x1D6 [0b10110110] (Stack is pushed with LSW of address first, followed by MSW of address.) + 16 bit absolute STAL 0x0420 -> 0x142 [0b01000010] + */ +//--------------------------- General Purpose Registers STx Absolutes --------------------------- +class IS_STAB_CDabs16 extends Microcode_Instruction { constructor(props) { super(props); - this.Bytecode = 0x102; + this.Bytecode = 0x140; + this.Mnemonic = "STAB"; + this.LongName = "STORE Registers A and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "CD", Bitwidth: 16}); + this.Words = 2; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_CD | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_AB | CONTROL_RI; + } +} +is_STAB_cda = new IS_STAB_CDabs16; +Instructions.push(is_STAB_cda); + +class IS_STCD_ABabs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x141; + this.Mnemonic = "STCD"; + this.LongName = "STORE Registers C and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "AB", Bitwidth: 16}); + this.Words = 2; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_AB | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_CD | CONTROL_RI; + } +} +is_STCD_aba = new IS_STCD_ABabs16; +Instructions.push(is_STCD_aba); + + +class IS_STAL_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x142; this.Mnemonic = "STAL"; this.LongName = "STORE Register A to LOW Byte"; this.Aliases = new Array(); - this.Type = InstructionTypes.Immediate16; - this.Operands = new Array({Operand: "$", Bitwidth: 16}); + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); this.Words = 2; - this.Cycles = 5; + this.Cycles = 4; 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; - + this.Microcode[3] = CONTROL_OUT_AL | CONTROL_RI | CONTROL_PCC; } } -is_STAL_i = new IS_STAL_imm16; -Instructions.push(is_STAL_i); +is_STAL_a = new IS_STAL_abs16; +Instructions.push(is_STAL_a); -class IS_STAH_imm16 extends Microcode_Instruction { +class IS_STAH_abs16 extends Microcode_Instruction { constructor(props) { super(props); - this.Bytecode = 0x103; + this.Bytecode = 0x143; this.Mnemonic = "STAH"; this.LongName = "STORE Register A to HIGH Byte"; this.Aliases = new Array(); - this.Type = InstructionTypes.Immediate16; - this.Operands = new Array({Operand: "$", Bitwidth: 16}); + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); this.Words = 2; - this.Cycles = 5; + this.Cycles = 4; 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; + this.Microcode[3] = CONTROL_OUT_AH | CONTROL_RI | CONTROL_PCC; } } -is_STAH_i = new IS_STAH_imm16; -Instructions.push(is_STAH_i); +is_STAH_a = new IS_STAH_abs16; +Instructions.push(is_STAH_a); -class IS_STBL_imm16 extends Microcode_Instruction { +class IS_STBL_abs16 extends Microcode_Instruction { constructor(props) { super(props); - this.Bytecode = 0x104; + this.Bytecode = 0x144; this.Mnemonic = "STBL"; this.LongName = "STORE Register B to LOW Byte"; this.Aliases = new Array(); - this.Type = InstructionTypes.Immediate16; - this.Operands = new Array({Operand: "$", Bitwidth: 16}); + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); this.Words = 2; - this.Cycles = 5; + this.Cycles = 4; 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; + this.Microcode[3] = CONTROL_OUT_BL | CONTROL_RI | CONTROL_PCC; } } -is_STBL_i = new IS_STBL_imm16; -Instructions.push(is_STBL_i); +is_STBL_a = new IS_STBL_abs16; +Instructions.push(is_STBL_a); -class IS_STBH_imm16 extends Microcode_Instruction { +class IS_STBH_abs16 extends Microcode_Instruction { constructor(props) { super(props); - this.Bytecode = 0x105; + this.Bytecode = 0x145; this.Mnemonic = "STBH"; this.LongName = "STORE Register B to HIGH Byte"; this.Aliases = new Array(); - this.Type = InstructionTypes.Immediate16; - this.Operands = new Array({Operand: "$", Bitwidth: 16}); + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); this.Words = 2; - this.Cycles = 5; + this.Cycles = 4; 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; + this.Microcode[3] = CONTROL_OUT_BH | CONTROL_RI | CONTROL_PCC; } } -is_STBH_i = new IS_STBH_imm16; -Instructions.push(is_STBH_i); +is_STBH_a = new IS_STBH_abs16; +Instructions.push(is_STBH_a); -class IS_STCL_imm16 extends Microcode_Instruction { +class IS_STCL_abs16 extends Microcode_Instruction { constructor(props) { super(props); - this.Bytecode = 0x106; + this.Bytecode = 0x146; this.Mnemonic = "STCL"; this.LongName = "STORE Register C to LOW Byte"; this.Aliases = new Array(); - this.Type = InstructionTypes.Immediate16; - this.Operands = new Array({Operand: "$", Bitwidth: 16}); + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); this.Words = 2; - this.Cycles = 5; + this.Cycles = 4; 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; + this.Microcode[3] = CONTROL_OUT_CL | CONTROL_RI | CONTROL_PCC; } } -is_STCL_i = new IS_STCL_imm16; -Instructions.push(is_STCL_i); +is_STCL_a = new IS_STCL_abs16; +Instructions.push(is_STCL_a); -class IS_STCH_imm16 extends Microcode_Instruction { +class IS_STCH_abs16 extends Microcode_Instruction { constructor(props) { super(props); - this.Bytecode = 0x107; + this.Bytecode = 0x147; this.Mnemonic = "STCH"; this.LongName = "STORE Register C to HIGH Byte"; this.Aliases = new Array(); - this.Type = InstructionTypes.Immediate16; - this.Operands = new Array({Operand: "$", Bitwidth: 16}); + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); this.Words = 2; - this.Cycles = 5; + this.Cycles = 4; 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; + this.Microcode[3] = CONTROL_OUT_CH | CONTROL_RI | CONTROL_PCC; } } -is_STCH_i = new IS_STCH_imm16; -Instructions.push(is_STCH_i); +is_STCH_a = new IS_STCH_abs16; +Instructions.push(is_STCH_a); -class IS_STDL_imm16 extends Microcode_Instruction { +class IS_STDL_abs16 extends Microcode_Instruction { constructor(props) { super(props); - this.Bytecode = 0x108; + this.Bytecode = 0x148; this.Mnemonic = "STDL"; this.LongName = "STORE Register D to LOW Byte"; this.Aliases = new Array(); - this.Type = InstructionTypes.Immediate16; - this.Operands = new Array({Operand: "$", Bitwidth: 16}); + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); this.Words = 2; - this.Cycles = 5; + this.Cycles = 4; 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; + this.Microcode[3] = CONTROL_OUT_DL | CONTROL_RI | CONTROL_PCC; } } -is_STDL_i = new IS_STDL_imm16; -Instructions.push(is_STDL_i); +is_STDL_a = new IS_STDL_abs16; +Instructions.push(is_STDL_a); -class IS_STDH_imm16 extends Microcode_Instruction { +class IS_STDH_abs16 extends Microcode_Instruction { constructor(props) { super(props); - this.Bytecode = 0x109; + this.Bytecode = 0x149; this.Mnemonic = "STDH"; this.LongName = "STORE Register D to HIGH Byte"; this.Aliases = new Array(); - this.Type = InstructionTypes.Immediate16; - this.Operands = new Array({Operand: "$", Bitwidth: 16}); + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); this.Words = 2; - this.Cycles = 5; + this.Cycles = 4; 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; + this.Microcode[3] = CONTROL_OUT_DH | CONTROL_RI | CONTROL_PCC; } } -is_STDH_i = new IS_STDH_imm16; -Instructions.push(is_STDH_i); +is_STDH_a = new IS_STDH_abs16; +Instructions.push(is_STDH_a); -class IS_STAB_imm16 extends Microcode_Instruction { +class IS_STAB_abs16 extends Microcode_Instruction { constructor(props) { super(props); - this.Bytecode = 0x10A; + this.Bytecode = 0x14A; this.Mnemonic = "STAB"; this.LongName = "STORE Register A and B"; this.Aliases = new Array(); - this.Type = InstructionTypes.Immediate16; - this.Operands = new Array({Operand: "$", Bitwidth: 16}); + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); this.Words = 2; - this.Cycles = 5; + this.Cycles = 4; this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI; - this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC; + this.Microcode[3] = CONTROL_OUT_AB | CONTROL_RI | CONTROL_PCC; + } +} +is_STAB_a = new IS_STAB_abs16; +Instructions.push(is_STAB_a); + +class IS_STAC_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x14B; + this.Mnemonic = "STAC"; + this.LongName = "STORE Register A and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_AC | CONTROL_RI | CONTROL_PCC; + } +} +is_STAC_a = new IS_STAC_abs16; +Instructions.push(is_STAC_a); + +class IS_STAD_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x14C; + this.Mnemonic = "STAD"; + this.LongName = "STORE Register A and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_AD | CONTROL_RI | CONTROL_PCC; + } +} +is_STAD_a = new IS_STAD_abs16; +Instructions.push(is_STAD_a); + +class IS_STBA_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x14D; + this.Mnemonic = "STBA"; + this.LongName = "STORE Register B and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_BA | CONTROL_RI | CONTROL_PCC; + } +} +is_STBA_a = new IS_STBA_abs16; +Instructions.push(is_STBA_a); + +class IS_STBC_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x14E; + this.Mnemonic = "STBC"; + this.LongName = "STORE Register B and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_BC | CONTROL_RI | CONTROL_PCC; + } +} +is_STBC_a = new IS_STBC_abs16; +Instructions.push(is_STBC_a); + +class IS_STBD_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x14F; + this.Mnemonic = "STBD"; + this.LongName = "STORE Register B and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_BD | CONTROL_RI | CONTROL_PCC; + } +} +is_STBD_a = new IS_STBD_abs16; +Instructions.push(is_STBD_a); + +class IS_STCA_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x150; + this.Mnemonic = "STCA"; + this.LongName = "STORE Register C and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_CA | CONTROL_RI | CONTROL_PCC; + } +} +is_STCA_a = new IS_STCA_abs16; +Instructions.push(is_STCA_a); + +class IS_STCB_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x151; + this.Mnemonic = "STCB"; + this.LongName = "STORE Register C and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_CB | CONTROL_RI | CONTROL_PCC; + } +} +is_STCB_a = new IS_STCB_abs16; +Instructions.push(is_STCB_a); + +class IS_STCD_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x152; + this.Mnemonic = "STCD"; + this.LongName = "STORE Register C and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_CD | CONTROL_RI | CONTROL_PCC; + } +} +is_STCD_a = new IS_STCD_abs16; +Instructions.push(is_STCD_a); + +class IS_STDA_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x153; + this.Mnemonic = "STDA"; + this.LongName = "STORE Register D and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_DA | CONTROL_RI | CONTROL_PCC; + } +} +is_STDA_a = new IS_STDA_abs16; +Instructions.push(is_STDA_a); + +class IS_STDB_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x154; + this.Mnemonic = "STDB"; + this.LongName = "STORE Register D and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_DB | CONTROL_RI | CONTROL_PCC; + } +} +is_STDB_a = new IS_STDB_abs16; +Instructions.push(is_STDB_a); + +class IS_STDC_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x155; + this.Mnemonic = "STDC"; + this.LongName = "STORE Register D and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + 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_DC | CONTROL_RI | CONTROL_PCC; + } +} +is_STDC_a = new IS_STDC_abs16; +Instructions.push(is_STDC_a); + +class IS_STSP_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x15E; + this.Mnemonic = "STSP"; + this.LongName = "STORE Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); + this.Words = 1; + this.Cycles = 5; + this.Microcode[2] = CONTROL_SPC; + this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[4] = CONTROL_OUT_SP | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_STSP_a = new IS_STSP_abs16; +Instructions.push(is_STSP_a); + +//--------------------------- General Purpose Registers STx Indirect --------------------------- + + +class IS_STAB_CDind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x180; + this.Mnemonic = "STAB"; + this.LongName = "STORE Register A and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + this.Operands = new Array({Operand: "[CD]", Bitwidth: 16}); + this.Words = 1; + this.Cycles = 5; + this.Microcode[2] = CONTROL_OUT_CD | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI; this.Microcode[4] = CONTROL_OUT_AB | CONTROL_RI; } } -is_STAB_i = new IS_STAB_imm16; -Instructions.push(is_STAB_i); +is_STAB_cdin = new IS_STAB_CDind16; +Instructions.push(is_STAB_cdin); + +class IS_STCD_ABind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x181; + this.Mnemonic = "STCD"; + this.LongName = "STORE Register C and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + this.Operands = new Array({Operand: "[AB]", Bitwidth: 16}); + this.Words = 1; + this.Cycles = 5; + this.Microcode[2] = CONTROL_OUT_AB | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI; + this.Microcode[4] = CONTROL_OUT_CD | CONTROL_RI; + } +} +is_STCD_abin = new IS_STCD_ABind16; +Instructions.push(is_STCD_abin); + +class IS_STAL_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x182; + this.Mnemonic = "STAL"; + this.LongName = "STORE Register A to LOW Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_AL | CONTROL_RI; + } +} +is_STAL_in = new IS_STAL_ind16; +Instructions.push(is_STAL_in); + +class IS_STAH_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x183; + this.Mnemonic = "STAH"; + this.LongName = "STORE Register A to HIGH Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_AH | CONTROL_RI; + } +} +is_STAH_in = new IS_STAH_ind16; +Instructions.push(is_STAH_in); + +class IS_STBL_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x184; + this.Mnemonic = "STBL"; + this.LongName = "STORE Register B to LOW Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_BL | CONTROL_RI; + } +} +is_STBL_in = new IS_STBL_ind16; +Instructions.push(is_STBL_in); + +class IS_STBH_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x185; + this.Mnemonic = "STBH"; + this.LongName = "STORE Register B to HIGH Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_BH | CONTROL_RI; + } +} +is_STBH_in = new IS_STBH_ind16; +Instructions.push(is_STBH_in); + +class IS_STCL_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x186; + this.Mnemonic = "STCL"; + this.LongName = "STORE Register C to LOW Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_CL | CONTROL_RI; + } +} +is_STCL_in = new IS_STCL_ind16; +Instructions.push(is_STCL_in); + +class IS_STCH_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x187; + this.Mnemonic = "STCH"; + this.LongName = "STORE Register C to HIGH Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_CH | CONTROL_RI; + } +} +is_STCH_in = new IS_STCH_ind16; +Instructions.push(is_STCH_in); + +class IS_STDL_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x188; + this.Mnemonic = "STDL"; + this.LongName = "STORE Register D to LOW Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_DL | CONTROL_RI; + } +} +is_STDL_in = new IS_STDL_ind16; +Instructions.push(is_STDL_in); + +class IS_STDH_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x189; + this.Mnemonic = "STDH"; + this.LongName = "STORE Register D to HIGH Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_DH | CONTROL_RI; + } +} +is_STDH_in = new IS_STDH_ind16; +Instructions.push(is_STDH_in); + +class IS_STAB_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x18A; + this.Mnemonic = "STAB"; + this.LongName = "STORE Registers A and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_AB | CONTROL_RI; + } +} +is_STAB_in = new IS_STAB_ind16; +Instructions.push(is_STAB_in); + +class IS_STAC_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x18B; + this.Mnemonic = "STAC"; + this.LongName = "STORE Registers A and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_AC | CONTROL_RI; + } +} +is_STAC_in = new IS_STAC_ind16; +Instructions.push(is_STAC_in); + +class IS_STAD_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x18C; + this.Mnemonic = "STAD"; + this.LongName = "STORE Registers A and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_AD | CONTROL_RI; + } +} +is_STAD_in = new IS_STAD_ind16; +Instructions.push(is_STAD_in); + +class IS_STBA_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x18D; + this.Mnemonic = "STBA"; + this.LongName = "STORE Registers B and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_BA | CONTROL_RI; + } +} +is_STBA_in = new IS_STBA_ind16; +Instructions.push(is_STBA_in); + +class IS_STBC_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x18E; + this.Mnemonic = "STBC"; + this.LongName = "STORE Registers B and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_BC | CONTROL_RI; + } +} +is_STBC_in = new IS_STBC_ind16; +Instructions.push(is_STBC_in); + +class IS_STBD_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x18F; + this.Mnemonic = "STBD"; + this.LongName = "STORE Registers B and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_BD | CONTROL_RI; + } +} +is_STBD_in = new IS_STBD_ind16; +Instructions.push(is_STBD_in); + +class IS_STCA_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x190; + this.Mnemonic = "STCA"; + this.LongName = "STORE Registers C and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_CA | CONTROL_RI; + } +} +is_STCA_in = new IS_STCA_ind16; +Instructions.push(is_STCA_in); + +class IS_STCB_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x191; + this.Mnemonic = "STCB"; + this.LongName = "STORE Registers C and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_CB | CONTROL_RI; + } +} +is_STCB_in = new IS_STCB_ind16; +Instructions.push(is_STCB_in); + +class IS_STCD_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x192; + this.Mnemonic = "STCD"; + this.LongName = "STORE Registers C and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_CD | CONTROL_RI; + } +} +is_STCD_in = new IS_STCD_ind16; +Instructions.push(is_STCD_in); + +class IS_STDA_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x193; + this.Mnemonic = "STDA"; + this.LongName = "STORE Registers D and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_DA | CONTROL_RI; + } +} +is_STDA_in = new IS_STDA_ind16; +Instructions.push(is_STDA_in); + +class IS_STDB_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x194; + this.Mnemonic = "STDB"; + this.LongName = "STORE Registers D and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_DB | CONTROL_RI; + } +} +is_STDB_in = new IS_STDB_ind16; +Instructions.push(is_STDB_in); + +class IS_STDC_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x195; + this.Mnemonic = "STDC"; + this.LongName = "STORE Registers D and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_DC | CONTROL_RI; + } +} +is_STDC_in = new IS_STDC_ind16; +Instructions.push(is_STDC_in); + +class IS_STAB_SPind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x196; + this.Mnemonic = "STAB"; + this.LongName = "STORE Registers A and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + this.Operands = new Array({Operand: "[SP]", Bitwidth: 16}); + this.Words = 1; + this.Cycles = 5; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI; + this.Microcode[4] = CONTROL_OUT_AB | CONTROL_RI; + } +} +is_STAB_spin = new IS_STAB_SPind16; +Instructions.push(is_STAB_spin); + +class IS_STCD_SPind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x197; + this.Mnemonic = "STCD"; + this.LongName = "STORE Registers C and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + this.Operands = new Array({Operand: "[SP]", Bitwidth: 16}); + this.Words = 1; + this.Cycles = 5; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI; + this.Microcode[4] = CONTROL_OUT_CD | CONTROL_RI; + } +} +is_STCD_spin = new IS_STCD_SPind16; +Instructions.push(is_STCD_spin); + +class IS_STAL_SPind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x198; + this.Mnemonic = "STAL"; + this.LongName = "STORE Register A to LOW Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + this.Operands = new Array({Operand: "[SP]", Bitwidth: 16}); + this.Words = 1; + this.Cycles = 5; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI; + this.Microcode[4] = CONTROL_OUT_AL | CONTROL_RI; + } +} +is_STAL_spin = new IS_STAL_SPind16; +Instructions.push(is_STAL_spin); + +class IS_STAH_SPind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x199; + this.Mnemonic = "STAH"; + this.LongName = "STORE Register A to HIGH Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + this.Operands = new Array({Operand: "[SP]", Bitwidth: 16}); + this.Words = 1; + this.Cycles = 5; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI; + this.Microcode[4] = CONTROL_OUT_AH | CONTROL_RI; + } +} +is_STAH_spin = new IS_STAH_SPind16; +Instructions.push(is_STAH_spin); + +class IS_STBL_SPind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x19A; + this.Mnemonic = "STBL"; + this.LongName = "STORE Register B to LOW Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + this.Operands = new Array({Operand: "[SP]", Bitwidth: 16}); + this.Words = 1; + this.Cycles = 5; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI; + this.Microcode[4] = CONTROL_OUT_BL | CONTROL_RI; + } +} +is_STBL_spin = new IS_STBL_SPind16; +Instructions.push(is_STBL_spin); + +class IS_STBH_SPind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x19B; + this.Mnemonic = "STBH"; + this.LongName = "STORE Register B to HIGH Byte"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + this.Operands = new Array({Operand: "[SP]", Bitwidth: 16}); + this.Words = 1; + this.Cycles = 5; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI; + this.Microcode[4] = CONTROL_OUT_BH | CONTROL_RI; + } +} +is_STBH_spin = new IS_STBH_SPind16; +Instructions.push(is_STBH_spin); + +class IS_STSP_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x19E; + this.Mnemonic = "STSP"; + this.LongName = "STORE Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + 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_SP | CONTROL_RI; + } +} +is_STSP_in = new IS_STSP_ind16; +Instructions.push(is_STSP_in); + + + + + class IS_STAB_sp extends Microcode_Instruction { constructor(props) { @@ -221,25 +1125,6 @@ class IS_PSTAL_sp_ind extends Microcode_Instruction { is_PSTAL_spin = new IS_PSTAL_sp_ind; Instructions.push(is_PSTAL_spin); -class IS_PSTAL_imm16 extends Microcode_Instruction { - constructor(props) { - super(props); - this.Bytecode = 0x102; - this.Mnemonic = "PSTAL"; - this.LongName = "Page STORE Register A to LOW Byte"; - this.Aliases = new Array(); - - this.Type = InstructionTypes.Immediate16; - 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_AL | CONTROL_RI; - } -} -is_PSTAL_i = new IS_PSTAL_imm16; -Instructions.push(is_PSTAL_i); class IS_STAL_sp_ind24 extends Microcode_Instruction { constructor(props) {