Switche
unknown
c_cpp
a month ago
35 kB
7
Indexable
Never
for(;;)
{
switch(rom_data[PC++]) {
default:
case (0x00):
printf("NOP");
break;
case (0x06):
printf("LDBn"); // load B into n (n = 8 bit immediate value)
PC+=1;
break;
case (0x0E):
printf("LDCn"); // load C into n (n = 8 bit immediate value)
PC+=1;
break;
case (0x16):
printf("LDDn");
PC+=1;
break;
case (0x1E):
printf("LDEn");
PC+=1;
break;
case (0x26):
printf("LDHn");
PC+=1;
break;
case (0x2E):
printf("LDLn");
PC+=1;
break;
case (0x7F):
printf("LDAa"); // Load A into A
break;
case (0x78):
printf("LDAb"); // Load B into A
PC+=1;
break;
case (0x79):
printf("LDAc"); // Load C into A
break;
case (0x7A):
printf("LDAd"); // Load D into A
break;
case (0x7B):
printf("LDAe"); // Load E into A
break;
case (0x7C):
printf("LDAh"); // load H into A
break;
case (0x7D):
printf("LDAl"); // load L into A
break;
case (0x7E):
printf("LDAhl"); // load HL into A, 8 cycles
PC+=1;
break;
case (0x40):
printf("LDBb"); // load B into B
break;
case (0x41):
printf("LDBc"); // load C into B
break;
case (0x42):
printf("LDBd"); // load D into B
break;
case (0x43):
printf("LDBe"); // load E into B
break;
case (0x44):
printf("LDBh"); // load H into B
break;
case (0x45):
printf("LDBl"); // load L into B
break;
case (0x46):
printf("LDBhl"); // load HL into B, 8 cycles
PC+=1;
break;
case (0x48):
printf("LDCb"); // load B into C
break;
case (0x49):
printf("LDCc"); // load C into C
break;
case (0x4A):
printf("LDCd"); // load D into C
break;
case (0x4B):
printf("LDCe"); // load E into C
break;
case (0x4C):
printf("LDCh"); // load H into C
break;
case (0x4D):
printf("LDCl"); // load L into C
break;
case (0x4E):
printf("LDChl"); // load HL into C, 8 cycles
PC+=1;
break;
case (0x50):
printf("LDDb"); // load B into D
break;
case (0x51):
printf("LDDc"); // load C into D
break;
case (0x52):
printf("LDDd"); // load D into D
break;
case (0x53):
printf("LDDe"); // load E into D
break;
case (0x54):
printf("LDDh"); // load H into D
break;
case (0x55):
printf("LDDl"); // load L into D
break;
case (0x56):
printf("LDDhl"); // load HL into D
PC+=1;
break;
case (0x58):
printf("LDEb"); // load B into E
break;
case (0x59):
printf("LDEc"); // load C into E
break;
case (0x5A):
printf("LDEd"); // load D into E
break;
case (0x5B):
printf("LDEe"); // load E into E
break;
case (0x5C):
printf("LDEh"); // load H into E
break;
case (0x5D):
printf("LDEl"); // load L into E
break;
case (0x5E):
printf("LDEhl"); // load HL into E
PC+=1;
break;
case (0x60):
printf("LDHb"); // load B into H
break;
case (0x61):
printf("LDHc"); // load C into H
break;
case (0x62):
printf("LDHd"); // load D into H
break;
case (0x63):
printf("LDHe"); // load E into H
break;
case (0x64):
printf("LDHh"); // load H into H
break;
case (0x65):
printf("LDHl"); // load L into H
PC+=1;
break;
case (0x66):
printf("LDHhl"); // load HL into H
PC+=1;
break;
case (0x68):
printf("LDLb"); // load B into L
break;
case (0x69):
printf("LDLc"); // load C into L
break;
case (0x6A):
printf("LDLd"); // load D into L
break;
case (0x6B):
printf("LDLe"); // load E into L
break;
case (0x6C):
printf("LDLh"); // load H into L
break;
case (0x6D):
printf("LDLl"); // load L into L
break;
case (0x6E):
printf("LDLlh"); // load HL into L
PC+=1;
break;
case (0x70):
printf("LDHLb"); // load B into HL
PC+=1;
break;
case (0x71):
printf("LDHLc"); // load C into HL
PC+=1;
break;
case (0x72):
printf("LDHLd"); // load D into HL
PC+=1;
break;
case (0x73):
printf("LDHLe"); // load E into HL
PC+=1;
break;
case (0x74):
printf("LDHLh"); // load H into HL
PC+=1;
break;
case (0x75):
printf("LDHLl"); // load L into HL
PC+=1;
break;
case (0x36):
printf("LDHLn"); // load n into HL
PC+=1;
break;
case (0x0A):
printf("LDAbc"); // load BC into A
break;
case (0x1A):
printf("LDAde"); // load DE into A
break;
case (0xFA):
printf("LDAnn"); // load two byte immediate value into A, LS byte first
PC+=2;
break;
case (0x3E):
printf("LDA#"); // load 1 byte immediate value into A (To confirm)
PC+=1;
break;
case (0x47):
printf("LDBa"); // load A into B
break;
case (0x4F):
printf("LDCa"); // load A into C
break;
case (0x57):
printf("LDDa"); // load A into D
break;
case (0x5F):
printf("LDEa"); // load A into E
break;
case (0x67):
printf("LDHa"); // load A into H
break;
case (0x6F):
printf("LDLa"); // load A into L
break;
case (0x02):
printf("LDBCa"); // load A into BC
break;
case (0x12):
printf("LDDEa"); // load A into DE
break;
case (0x77):
printf("LDHLa"); // load A into HL
break;
case (0xEA):
printf("LDnnA"); // load A into nn (16 bits address)
PC+=2;
break;
case (0xF2):
printf("LDA[C]"); // Put value at address $FF00 + register C into A.
break;
case (0xE2):
printf("LDC[A]"); // Put A into address $FF00 + register C
break;
case (0x3A):
printf("LDAhl-"); // Put value at address HL into A. Decrement HL.
break;
case (0x32):
printf("LDHL-a"); //Put A into memory address HL. Decrement HL
break;
case (0x2A):
printf("LDAhl+"); //Put value at address HL into A. Increment HL
break;
case (0x22):
printf("LDHL+a"); //Put A into memory address HL. Increment HL
break;
case (0xE0):
printf("LDAn"); //Put memory address $FF00+n into A. n = one byte immediate value
PC+=1;
break;
case (0x01):
printf("LDBCnn"); // Put nn in BC, 16 bits nn
PC+=2;
break;
case (0x11):
printf("LDDEnn"); // put nn in DE, 16 bits nn
PC+=2;
break;
case (0x21):
printf("LDHLnn"); // put nn in HL, 16 bits nn
PC+=2;
break;
case (0x31):
printf("LDSPnn"); // put nn into SP, 16 bits nn
PC=+2;
break;
case (0xF9):
printf("LDSPhl"); // Put HL into Stack Pointer (SP)
break;
case (0xF8):
printf("LDHLsp+n"); //Put SP + n effective address into HL, n 1 byte signed immediate value
PC+=1;
break;
case (0x08):
printf("LDNNsp"); // put stack pointer (SP) at address nn, nn two byte immediate address
PC+=2;
break;
case (0xF5):
printf("PUSHaf"); // Push register pair AF onto stack. Decrement Stack Pointer (SP) twice.
break;
case (0xC5):
printf("PUSHbc"); //Push register pair BC onto stack. Decrement Stack Pointer (SP) twice.
break;
case (0xD5):
printf("PUSHde"); //Push register pair DE onto stack. Decrement Stack Pointer (SP) twice.
break;
case (0xE5):
printf("PUSHhl"); //Push register pair HL onto stack. Decrement Stack Pointer (SP) twice.
break;
case (0xF1):
printf("POPaf"); //Pop two bytes off stack into register pair AF.Increment Stack Pointer (SP) twice.
break;
case (0xC1):
printf("POPbc"); //Pop two bytes off stack into register pair BC.Increment Stack Pointer (SP) twice.
break;
case (0xD1):
printf("POPde"); //Pop two bytes off stack into register pair DE.Increment Stack Pointer (SP) twice.
break;
case (0xE1):
printf("POPhl"); //Pop two bytes off stack into register pair HL.Increment Stack Pointer (SP) twice.
break;
case (0x87):
printf("ADDAb"); // Add A to A
break;
case (0x80):
printf("AddAb"); //
break;
case (0x81):
printf("AddAc"); //
break;
case (0x82):
printf("AddAd"); //
break;
case (0x83):
printf("AddAe"); //
break;
case (0x84):
printf("AddAh"); //
break;
case (0x85):
printf("AddAl"); //
break;
case (0x86):
printf("AddAhl"); //
break;
case (0xC6):
printf("AddA#"); // Add value to A
PC+=1;
break;
case (0x8F):
printf("ADCAa"); // Add A + Carry flag to A
break;
case (0x88):
printf("ACDAb"); // Add B + Carry flag to A
break;
case (0x89):
printf("ACDAc"); //
break;
case (0x8A):
printf("ACDAd"); //
break;
case (0x8B):
printf("ACDAe"); //
break;
case (0x8C):
printf("ACDAh"); //
break;
case (0x8D):
printf("ACDAl"); //
break;
case (0x8E):
printf("ACDAhl"); //
break;
case (0xCE):
printf("ACDA#"); // Add value + carry flag to A
PC+=1;
break;
case (0x97):
printf("SUBAa"); // substract A from A
break;
case (0x90):
printf("SUBAb"); //
break;
case (0x91):
printf("SUBAc"); //
break;
case (0x92):
printf("SUBAd"); //
break;
case (0x93):
printf("SUBAe"); //
break;
case (0x94):
printf("SUBAh"); //
break;
case (0x95):
printf("SUBAl"); //
break;
case (0x96):
printf("SUBAhl"); //
break;
case (0xD6):
printf("SUBA#"); // sub value from A
PC+=1;
break;
case (0x9F):
printf("SBCAa"); // Subtract A + Carry flag from A
break;
case (0x98):
printf("SBCAb"); //
break;
case (0x99):
printf("SBCAc"); //
break;
case (0x9A):
printf("SBCAd"); //
break;
case (0x9B):
printf("SBCAe"); //
break;
case (0x9C):
printf("SBCAh"); //
break;
case (0x9D):
printf("SBCAl"); //
break;
case (0x9E):
printf("SBCAhl"); //
break;
case (0xA7):
printf("ANDA"); // Logically AND A with A, result in A
break;
case (0xA0):
printf("ANDB"); // Logically AND A with B, result in A
break;
case (0xA1):
printf("ANDC"); //
break;
case (0xA2):
printf("ANDD"); //
break;
case (0xA3):
printf("ANDE"); //
break;
case (0xA4):
printf("ANDH"); //
break;
case (0xA5):
printf("ANDL"); //
break;
case (0xA6):
printf("ANDHL"); //
break;
case (0xE6):
printf("AND#"); // Logically AND A with 1 byte value, result in A
PC+=1;
break;
case (0xB7):
printf("ORA"); // Logical OR A with register A, result in A.
break;
case (0xB0):
printf("ORB"); // Logical OR B with register A, result in A.
break;
case (0xB1):
printf("ORC"); //
break;
case (0xB2):
printf("ORD"); //
break;
case (0xB3):
printf("ORE"); //
break;
case (0xB4):
printf("ORH"); //
break;
case (0xB5):
printf("ORL"); //
break;
case (0xB6):
printf("ORHL"); //
break;
case (0xF6):
printf("OR#"); // Logical OR value with register A, result in A.
PC+=1;
break;
case (0xAF):
printf("XORA"); //Logical exclusive OR A with register A, result in A
break;
case (0xA8):
printf("XORB"); //
break;
case (0xA9):
printf("XORC"); //
break;
case (0xAA):
printf("XORD"); //
break;
case (0xAB):
printf("XORE"); //
break;
case (0xAC):
printf("XORH"); //
break;
case (0xAD):
printf("XORL"); //
break;
case (0xAE):
printf("XORHL"); //
break;
case (0xEE):
printf("XOR#"); //
PC+=1;
break;
case (0xBF):
printf("CPA"); //Compare A with n. This is basically an A - A subtraction instruction but the results are thrown away.
break;
case (0xB8):
printf("CPB"); //
break;
case (0xB9):
printf("CPC"); //
break;
case (0xBA):
printf("CPD"); //
break;
case (0xBB):
printf("CPE"); //
break;
case (0xBC):
printf("CPH"); //
break;
case (0xBD):
printf("CPL"); //
break;
case (0xBE):
printf("CPHL"); //
break;
case (0xFE):
printf("CP#"); //
PC+=1;
break;
case (0x3C):
printf("INCA"); // increment register A
break;
case (0x04):
printf("INCB"); //
break;
case (0x0C):
printf("INCC"); //
break;
case (0x14):
printf("INCD"); //
break;
case (0x1C):
printf("INCE"); //
break;
case (0x24):
printf("INCH"); //
break;
case (0x2C):
printf("INCL"); //
break;
case (0x34):
printf("INCHL"); //
break;
case (0x3D):
printf("DECA"); // Decrement register A
break;
case (0x05):
printf("DECB"); //
break;
case (0x0D):
printf("DECC"); //
break;
case (0x15):
printf("DECD"); //
break;
case (0x1D):
printf("DECE"); //
break;
case (0x25):
printf("DECH"); //
break;
case (0x2D):
printf("DECL"); //
break;
case (0x35):
printf("DECHL"); //
break;
case (0x09):
printf("ADDHLbc"); // Add BC to HL
break;
case (0x19):
printf("ADDHLde"); //
break;
case (0x29):
printf("ADDHLhl"); //
break;
case (0x39):
printf("ADDHlsp"); //
break;
case (0xE8):
printf("ADDSPn"); //Add n to Stack Pointer (SP). n = one byte signed immediate value (#).
PC+=1;
break;
case (0x03):
printf("INCBC"); // Increment register BC
break;
case (0x13):
printf("INCDE"); //
break;
case (0x23):
printf("INCHL"); //
break;
case (0x33):
printf("INCSP"); //
break;
case (0x0B):
printf("DECBC"); // Increment register BC
break;
case (0x1B):
printf("DECDE"); //
break;
case (0x2B):
printf("DECHL"); //
break;
case (0x3B):
printf("DECSP"); //
break;
case (0xCB37):
printf("SWAPA"); // Swap upper & lower nibles of A
break;
case (0xCB30):
printf("SWAPB"); //
break;
case (0xCB31):
printf("SWAPC"); //
break;
case (0xCB32):
printf("SWAPD"); //
break;
case (0xCB33):
printf("SWAPE"); //
break;
case (0xCB34):
printf("SWAPH"); //
break;
case (0xCB35):
printf("SWAPL"); //
break;
case (0xCB36):
printf("SWAPHL"); //
break;
case (0x27):
printf("DAA"); //Decimal adjust register A. This instruction adjusts register A so that the correct representation of Binary Coded Decimal (BCD) is obtained.
break;
case (0x2F):
printf("CPL"); // Complement A register. (Flip all bits.)
break;
case (0x3F):
printf("CCF"); //Complement carry flag. If C flag is set, then reset it. If C flag is reset, then set it.
break;
case (0x37):
printf("SCF"); // Set Carry flag.
break;
case (0x76):
printf("HALT"); //power down CPU until an interrupt occurs. Use this whenever possible to reduce energy consumption.
break;
case (0x10):
printf("STOP"); // Halt CPU & LCD display until button pressed.
break;
case (0xF3):
printf("DI"); //This instruction disables interrupts but not immediately. Interrupts are disabled after instruction after DI is executed.
break;
case (0xFB):
printf(""); //Enable interrupts. This intruction enables interrupts but not immediately. Interrupts are enabled after instruction after EI is executed.
break;
case (0x07):
printf("RLCA"); // Rotate A left. Old bit 7 to Carry flag.
break;
case (0x17):
printf("RLA"); // Rotate A left through Carry flag
break;
case (0x0F):
printf("RRCA"); // Rotates A right. Old bit 0 to Carry flag
break;
case (0x1F):
printf("RRA"); // Rotate A right through carry flag
break;
case (0xCB07):
printf("RLCA"); // Rotate A left. Old bit 7 to Carry flag.
PC+=1;
break;
case (0xCB00):
printf("RLCB"); //
PC+=1;
break;
case (0xCB01):
printf("RLCC"); //
PC+=1;
break;
case (0xCB02):
printf("RLCD"); //
PC+=1;
break;
case (0xCB03):
printf("RLCE"); //
PC+=1;
break;
case (0xCB04):
printf("RLCH"); //
PC+=1;
break;
case (0xCB05):
printf("RLCL"); //
PC+=1;
break;
case (0xCB06):
printf("RLCHL"); //
PC+=1;
break;
case (0xCB17):
printf("RLA"); // Rotate A left through Carry flag.
PC+=1;
break;
case (0xCB10):
printf("RLB"); //
PC+=1;
break;
case (0xCB11):
printf("RLC"); //
PC+=1;
break;
case (0xCB12):
printf("RLD"); //
PC+=1;
break;
case (0xCB13):
printf("RLE"); //
PC+=1;
break;
case (0xCB14):
printf("RLH"); //
PC+=1;
break;
case (0xCB15):
printf("RLL"); //
PC+=1;
break;
case (0xCB16):
printf("RLHL"); //
PC+=1;
break;
case (0xCB0F):
printf("RRCA"); // Rotate A right. Old bit 0 to Carry flag.
PC+=1;
break;
case (0xCB08):
printf("RRCB"); //
PC+=1;
break;
case (0xCB09):
printf("RRCC"); //
PC+=1;
break;
case (0xCB0A):
printf("RRCD"); //
PC+=1;
break;
case (0xCB0B):
printf("RRCE"); //
PC+=1;
break;
case (0xCB0C):
printf("RRCH"); //
PC+=1;
break;
case (0xCB0D):
printf("RRCL"); //
PC+=1;
break;
case (0xCB0E):
printf("RRCHL"); //
PC+=1;
break;
case (0xCB1F):
printf("RRA"); //Rotate A right through Carry flag.
PC+=1;
break;
case (0xCB18):
printf("RRB"); //
PC+=1;
break;
case (0xCB19):
printf("RRC"); //
PC+=1;
break;
case (0xCB1A):
printf("RRD"); //
PC+=1;
break;
case (0xCB1B):
printf("RRE"); //
PC+=1;
break;
case (0xCB1C):
printf("RRH"); //
PC+=1;
break;
case (0xCB1D):
printf("RRL"); //
PC+=1;
break;
case (0xCB1E):
printf("RRHL"); //
PC+=1;
break;
case (0xCB27):
printf("SLAA"); //Shift A left into Carry. LSB of n set to 0.
PC+=1;
break;
case (0xCB20):
printf("SLAB"); //
PC+=1;
break;
case (0xCB21):
printf("SLAC"); //
PC+=1;
break;
case (0xCB22):
printf("SLAD"); //
PC+=1;
break;
case (0xCB23):
printf("SLAE"); //
PC+=1;
break;
case (0xCB24):
printf("SLAH"); //
PC+=1;
break;
case (0xCB25):
printf("SLAL"); //
PC+=1;
break;
case (0xCB26):
printf("SLAHL"); //
PC+=1;
break;
case (0xCB2F):
printf("SRAA"); // Shift A right into Carry. MSB doesn't change
PC+=1;
break;
case (0xCB28):
printf("SRAB"); //
PC+=1;
break;
case (0xCB29):
printf("SRAC"); //
PC+=1;
break;
case (0xCB2A):
printf("SRAD"); //
PC+=1;
break;
case (0xCB2B):
printf("SRAE"); //
PC+=1;
break;
case (0xCB2C):
printf("SRAH"); //
PC+=1;
break;
case (0xCB2D):
printf("SRAL"); //
PC+=1;
break;
case (0xCB2E):
printf("SRAHL"); //
PC+=1;
break;
case (0xCB3F):
printf("SRLA"); // Shift A right into Carry. MSB set to 0
PC+=1;
break;
case (0xCB38):
printf("SRLB"); //
PC+=1;
break;
case (0xCB39):
printf("SRLC"); //
PC+=1;
break;
case (0xCB3A):
printf("SRLD"); //
PC+=1;
break;
case (0xCB3B):
printf("SRLE"); //
PC+=1;
break;
case (0xCB3C):
printf("SRLH"); //
PC+=1;
break;
case (0xCB3D):
printf("SRLL"); //
PC+=1;
break;
case (0xCB3E):
printf("SRLHL"); //
PC+=1;
break;
case (0xCB47):
printf("BITbA"); // Test bit b in register A. b = [0;7]
PC+=1;
break;
case (0xCB40):
printf("BitbB"); //
PC+=1;
break;
case (0xCB41):
printf("BitbC"); //
PC+=1;
break;
case (0xCB42):
printf("BitbD"); //
PC+=1;
break;
case (0xCB43):
printf("bitbE"); //
PC+=1;
break;
case (0xCB44):
printf("bitbH"); //
PC+=1;
break;
case (0xCB45):
printf("bitbL"); //
PC+=1;
break;
case (0xCB46):
printf("bitbHL"); //
PC+=1;
break;
case (0xCBC7):
printf("SETAb"); // Set bit b in register A. B = [0-7]
PC+=1;
break;
case (0xCBC0):
printf("SETBb"); //
PC+=1;
break;
case (0xCBC1):
printf("SETCb"); //
PC+=1;
break;
case (0xCBC2):
printf("SETDb"); //
PC+=1;
break;
case (0xCBC3):
printf("SETEb"); //
PC+=1;
break;
case (0xCBC4):
printf("SETHb"); //
PC+=1;
break;
case (0xCBC5):
printf("SETLb"); //
PC+=1;
break;
case (0xCBC6):
printf("SETHLb"); //
PC+=1;
break;
case (0xCB87):
printf("RESAb"); // Reset bit b in register r. B =[0-7]
PC+=1;
break;
case (0xCB80):
printf("RESBb"); //
PC+=1;
break;
case (0xCB81):
printf("RESCb"); //
PC+=1;
break;
case (0xCB82):
printf("RESDb"); //
PC+=1;
break;
case (0xCB83):
printf("RESEb"); //
PC+=1;
break;
case (0xCB84):
printf("RESHb"); //
PC+=1;
break;
case (0xCB85):
printf("RESLb"); //
PC+=1;
break;
case (0xCB86):
printf("RESHLb"); //
PC+=1;
break;
case (0xC3):
printf("JPnn"); // Jump to address nn, nn = two byte immediate value. (LS byte first.)
PC+=2;
break;
case (0xC2):
printf("JPNZ");
/* Jump to address n if following condition is true:
cc = NZ, Jump if Z flag is reset.
cc = Z, Jump if Z flag is set.
cc = NC, Jump if C flag is reset.
cc = C, Jump if C flag is set. */
PC+=2;
break;
case (0xCA):
printf("JPZ"); //
PC+=2;
break;
case (0xD2):
printf("JPNC"); //
PC+=2;
break;
case (0xDA):
printf("JPC"); //
PC+=2;
break;
case (0xE9):
printf("JPHL"); // Jump to address contained in HL.
break;
case (0x18):
printf("JRn"); // Add n to current address and jump to it. n = one byte signed immediate value
PC+=1;
break;
case (0x20):
printf("JRNZn"); /* If following condition is true then add n to current
address and jump to it:
n = one byte signed immediate value
cc = NZ, Jump if Z flag is reset.
cc = Z, Jump if Z flag is set.
cc = NC, Jump if C flag is reset.
cc = C, Jump if C flag is set. */
PC+=1;
break;
case (0x28):
printf("JRZn"); //
PC+=1;
break;
case (0x30):
printf("JRNCn"); //
PC+=1;
break;
case (0x38):
printf("JRCn"); //
PC+=1;
break;
case (0xCD):
printf("CALLnn"); //Push address of next instruction onto stack and then jump to address nn. nn = two byte immediate value. (LS byte first.)
PC+=2;
break;
case (0xC4):
printf("CALLNZnn");
/*Call address n if following condition is true:
cc = NZ, Call if Z flag is reset.
cc = Z, Call if Z flag is set.
cc = NC, Call if C flag is reset.
cc = C, Call if C flag is set.*/
PC+=2;
break;
case (0xCC):
printf("CALLZnn"); //
PC+=2;
break;
case (0xD4):
printf("CALLNCnn"); //
PC+=2;
break;
case (0xDC):
printf("CALLCnn"); //
PC+=2;
break;
case (0xC7):
printf("RST00H"); /* Description:
Push present address onto stack.
Jump to address $0000 + n.
Use with:
n = $00,$08,$10,$18,$20,$28,$30,$38*/
break;
case (0xCF):
printf("RST08H"); //
break;
case (0xD7):
printf("RST10H"); //
break;
case (0xDF):
printf("RST18H"); //
break;
case (0xE7):
printf("RST20H"); //
break;
case (0xEF):
printf("RST28H"); //
break;
case (0xF7):
printf("RST30H"); //
break;
case (0xFF):
printf("RST38H"); //
break;
case (0xC9):
printf("RET"); // Pop two bytes from stack & jump to that address
break;
case (0xC0):
printf("RETNZ"); // Return if Z flag is reset
break;
case (0xC8):
printf("RETZ"); // Return if Z flag is set.
break;
case (0xD0):
printf("RETNC"); // Return if C flag is reset.
break;
case (0xD8):
printf("RETC"); // Return if C flag is set.
break;
case (0xD9):
printf("RETI"); //Pop two bytes from stack & jump to that address then enable interrupts.
break;
}