             instruction = LD(dest: self.HL, src: Immediate16(val: val))
             instructionLength = 3
             
-        case 0x12:
-            // LD (DE), A
-            instruction = LD(dest: Register16Indirect8(register: self.DE, memory: self.memory), src: self.A)
-            instructionLength = 1
-            
-        // Jumps
+        case 0x3E:
+            // LD A, n
+            let val = memory.read8(PC.read()+1)
+            instruction = LD(dest: self.A, src: Immediate8(val: val))
+            instructionLength = 1
+            
+        case 0x3F:
+            // CCF
+            instruction = CCF()
+            instructionLength = 1
+            
+        case 0x66:
+            // LD H, (HL)
+            instruction = LD(dest: self.H, src: Register16Indirect8(register: self.HL, memory: self.memory))
+            instructionLength = 1
+            
         case 0xC3:
             // JP nn
             let addr = memory.read16(PC.read()+1)
             instruction = JP(condition: nil, dest: Immediate16(val: addr))
             instructionLength = 3
             
-        case 0x18:
-            // JR n
-            let displacement = Int8(memory.read8(PC.read()+1))
-            instruction = JP(condition: nil, dest: ImmediateDisplaced16(base: PC.read()+2, displacement: displacement))
-            instructionLength = 2
+        /*
+         case 0xCE:
+         let num = memory.read8(PC.read()+1)
+         instruction = ADC(operand: Immediate8(val: num))
+         instructionLength = 2
+         */
             
         case 0xDF:
             // RST 0x18

            instruction = RET(condition: Condition(flag: self.PVF, target: false))
            instructionLength = 1
            break
            
        case 0x10:
            // DJNZ
            let displacement = Int8(bitPattern: memory.read8(PC.read()+1))
            instruction = DJNZ(displacement: displacement)
            instructionLength = 2
            
        // Math
        case 0x0D:
            // DEC C
            instruction = DEC(operand: self.C)
            instructionLength = 1
            
            /*
        case 0xCE:
            let num = memory.read8(PC.read()+1)
            instruction = ADC(operand: Immediate8(val: num))
            instructionLength = 2
            */
            
        case 0xF3:
            let num = memory.read8(PC.read()+1)

        var instructionLength: UInt16 = 1
        
        switch firstByte {
        case 0x00:
            // NOP
            instruction = NOP()
            instructionLength = 1
            
        case 0x0D:
            // DEC C
            instruction = DEC(operand: self.C)
            instructionLength = 1
            
        case 0x0F:
