Switche

mail@pastecode.io avatar
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;
            }