diff --git a/z80.cpp b/z80.cpp
index c0d97c4..bddfd88 100644
--- a/z80.cpp
+++ b/z80.cpp
@@ -151,10 +151,11 @@ namespace z80
         return READ_MEM_8(addr) + READ_MEM_8(addr+1) << 8;
     }
 
-    void WRITE_MEM_8(const uint16_t addr, const uint8_t value)
+    const uint8_t WRITE_MEM_8(const uint16_t addr, const uint8_t value)
     {
         t+=3;
         memory[addr] = value;
+        return value;
     }
 
     void WRITE_MEM_16(const uint16_t addr, const uint16_t value)
@@ -569,16 +570,6 @@ namespace z80
         im = mode;
     }
 
-    void IN(uint8_t *reg, uint8_t dir)
-    {
-        // [TODO]
-    }
-
-    void OUT(uint8_t dir, uint8_t val)
-    {
-        // [TODO]
-    }
-
     void EX_MEM(uint16_t *reg, uint16_t addr)
     {
         auto temp = *reg;
@@ -703,22 +694,150 @@ namespace z80
         return v & ~(1<<pos);
     }
 
-    void LDI()   { /* [TODO] */ }
-    void CPI()   { /* [TODO] */ }
-    void INI()   { /* [TODO] */ }
+    void LDI()
+    {
+        WRITE_MEM_8(rDE, READ_MEM_8(rHL));
+        rDE++;
+        rHL++;
+        rBC--;
+        t+=2;
+        KEEP_FLAGS(fS | fZ | fC);
+        if (rBC!=0) SET_FLAGS(fP);
+    }
+
+    void LDIR()
+    {
+        LDI();
+        if (rBC!=0)
+        {
+            rPC-=2;
+            t+=5;
+        }
+    }
+
+    void LDD()
+    {
+        WRITE_MEM_8(rDE, READ_MEM_8(rHL));
+        rDE--;
+        rHL--;
+        rBC--;
+        t+=2;
+        KEEP_FLAGS(fS | fZ | fC);
+        if (rBC!=0) SET_FLAGS(fP);
+    }
+
+    void LDDR()
+    {
+        LDD();
+        if (rBC!=0)
+        {
+            rPC-=2;
+            t+=5;
+        }
+    }
+
+    void CPI()
+    {
+        uint8_t old_fC = rF & fC;
+        CP(READ_MEM_8(rHL));
+        rHL++;
+        rBC--;
+        t+=2;
+        rF = (rF & 0xFD) | old_fC;
+        if (rBC!=0) SET_FLAGS(fP);
+        if (READ_MEM_8(rHL)==rA) SET_FLAGS(fZ);
+    }
+
+    void CPIR()
+    {
+        CPI();
+        if (rBC!=0 && READ_MEM_8(rHL)!=rA)
+        {
+            rPC-=2;
+            t+=2;
+        }
+    }
+
+    void CPD()
+    {
+        uint8_t old_fC = rF & fC;
+        CP(READ_MEM_8(rHL));
+        rHL--;
+        rBC--;
+        t+=2;
+        rF = (rF & 0xFD) | old_fC;
+        if (rBC!=0) SET_FLAGS(fP);
+        if (READ_MEM_8(rHL)==rA) SET_FLAGS(fZ);
+    }
+    
+    void CPDR()
+    {
+        CPD();
+        if (rBC!=0 && READ_MEM_8(rHL)!=rA)
+        {
+            rPC-=2;
+            t+=2;
+        }
+    }
+
+    const uint8_t IN(int port = 256)
+    {
+        t+=4;
+        if (port == 256) {
+            port = rC;
+            // [TODO] set flags acordingly
+        } else {
+            // don't touch flags
+        }
+        // [TODO] Do the actual "inputting"
+    }
+
+    void OUT(uint8_t port, uint8_t val)
+    {
+        // [TODO]
+    }
+
+    void INI()
+    {
+        WRITE_MEM_8(rHL, IN());
+        rHL++;
+        DEC8(_rB);
+        t+=5;
+    }
+
+    void INIR()
+    {
+        INI();
+        if (rB!=0)
+        {
+            rPC-=2;
+            t+=5;
+        }
+    }
+
+    void IND()
+    {
+        WRITE_MEM_8(rHL, IN());
+        rHL--;
+        DEC8(_rB);
+        t+=5;
+    }
+
+    void INDR()
+    {
+        IND();
+        if (rB!=0)
+        {
+            rPC-=2;
+            t+=5;
+        }
+    }
+
     void OUTI()  { /* [TODO] */ }
-    void LDD()   { /* [TODO] */ }
-    void CPD()   { /* [TODO] */ }
-    void IND()   { /* [TODO] */ }
-    void OUTD()  { /* [TODO] */ }
-    void LDIR()  { /* [TODO] */ }
-    void CPIR()  { /* [TODO] */ }
-    void INIR()  { /* [TODO] */ }
     void OUTIR() { /* [TODO] */ }
-    void LDDR()  { /* [TODO] */ }
-    void CPDR()  { /* [TODO] */ }
-    void INDR()  { /* [TODO] */ }
+
     void OUTDR() { /* [TODO] */ }
+    void OUTD()  { /* [TODO] */ }
 
     void INVALID()
     {
@@ -978,7 +1097,7 @@ namespace z80
             case 0xD8: RET(cC);                         break;
             case 0xD9: SWAP(rBC, rBC2);SWAP(rDE, rDE2);SWAP(rHL, rHL2); break;
             case 0xDA: JP(cC, READ_MEM_16());           break;
-            case 0xDB: IN(_rA, READ_MEM_8());           break;
+            case 0xDB: rA = IN(READ_MEM_8());           break;
             case 0xDC: CALL(cC, READ_MEM_16());         break;
             case 0xDD: IX_INSTRUCTIONS();               break;
             case 0xDE: SBC8(READ_MEM_8());              break;
@@ -1524,279 +1643,280 @@ namespace z80
     {
         const uint8_t d = READ_MEM_8();
         const uint8_t opcode = READ_MEM_8();
+        t+=3;
         switch (opcode)
         {
-            case 0x00: RLC(&memory[rIX+LD8()],_rB);     break;
-            case 0x01: RLC(&memory[rIX+LD8()],_rC);     break;
-            case 0x02: RLC(&memory[rIX+LD8()],_rD);     break;
-            case 0x03: RLC(&memory[rIX+LD8()],_rE);     break;
-            case 0x04: RLC(&memory[rIX+LD8()],_rH);     break;
-            case 0x05: RLC(&memory[rIX+LD8()],_rL);     break;
-            case 0x06: RLC(&memory[rIX+LD8()]);         break;
-            case 0x07: RLC(&memory[rIX+LD8()],_rA);     break;
-            case 0x08: RRC(&memory[rIX+LD8()],_rB);     break;
-            case 0x09: RRC(&memory[rIX+LD8()],_rC);     break;
-            case 0x0A: RRC(&memory[rIX+LD8()],_rD);     break;
-            case 0x0B: RRC(&memory[rIX+LD8()],_rE);     break;
-            case 0x0C: RRC(&memory[rIX+LD8()],_rH);     break;
-            case 0x0D: RRC(&memory[rIX+LD8()],_rL);     break;
-            case 0x0E: RRC(&memory[rIX+LD8()]);         break;
-            case 0x0F: RRC(&memory[rIX+LD8()],_rA);     break;
+            case 0x00: rB = WRITE_MEM_8(rIX+d, RLC(READ_MEM_8(rIX+d))); break;
+            case 0x01: rC = WRITE_MEM_8(rIX+d, RLC(READ_MEM_8(rIX+d))); break;
+            case 0x02: rD = WRITE_MEM_8(rIX+d, RLC(READ_MEM_8(rIX+d))); break;
+            case 0x03: rE = WRITE_MEM_8(rIX+d, RLC(READ_MEM_8(rIX+d))); break;
+            case 0x04: rH = WRITE_MEM_8(rIX+d, RLC(READ_MEM_8(rIX+d))); break;
+            case 0x05: rL = WRITE_MEM_8(rIX+d, RLC(READ_MEM_8(rIX+d))); break;
+            case 0x06:      WRITE_MEM_8(rIX+d, RLC(READ_MEM_8(rIX+d))); break;
+            case 0x07: rA = WRITE_MEM_8(rIX+d, RLC(READ_MEM_8(rIX+d))); break;
+            case 0x08: rB = WRITE_MEM_8(rIX+d, RRC(READ_MEM_8(rIX+d))); break;
+            case 0x09: rC = WRITE_MEM_8(rIX+d, RRC(READ_MEM_8(rIX+d))); break;
+            case 0x0A: rD = WRITE_MEM_8(rIX+d, RRC(READ_MEM_8(rIX+d))); break;
+            case 0x0B: rE = WRITE_MEM_8(rIX+d, RRC(READ_MEM_8(rIX+d))); break;
+            case 0x0C: rH = WRITE_MEM_8(rIX+d, RRC(READ_MEM_8(rIX+d))); break;
+            case 0x0D: rL = WRITE_MEM_8(rIX+d, RRC(READ_MEM_8(rIX+d))); break;
+            case 0x0E:      WRITE_MEM_8(rIX+d, RRC(READ_MEM_8(rIX+d))); break;
+            case 0x0F: rA = WRITE_MEM_8(rIX+d, RRC(READ_MEM_8(rIX+d))); break;
 
-            case 0x10: RL(&memory[rIX+LD8()],_rB);      break;
-            case 0x11: RL(&memory[rIX+LD8()],_rC);      break;
-            case 0x12: RL(&memory[rIX+LD8()],_rD);      break;
-            case 0x13: RL(&memory[rIX+LD8()],_rE);      break;
-            case 0x14: RL(&memory[rIX+LD8()],_rH);      break;
-            case 0x15: RL(&memory[rIX+LD8()],_rL);      break;
-            case 0x16: RL(&memory[rIX+LD8()]);          break;
-            case 0x17: RL(&memory[rIX+LD8()],_rA);      break;
-            case 0x18: RR(&memory[rIX+LD8()],_rB);      break;
-            case 0x19: RR(&memory[rIX+LD8()],_rC);      break;
-            case 0x1A: RR(&memory[rIX+LD8()],_rD);      break;
-            case 0x1B: RR(&memory[rIX+LD8()],_rE);      break;
-            case 0x1C: RR(&memory[rIX+LD8()],_rH);      break;
-            case 0x1D: RR(&memory[rIX+LD8()],_rL);      break;
-            case 0x1E: RR(&memory[rIX+LD8()]);          break;
-            case 0x1F: RR(&memory[rIX+LD8()],_rA);      break;
+            case 0x10: rB = WRITE_MEM_8(rIX+d, RL(READ_MEM_8(rIX+d))); break;
+            case 0x11: rC = WRITE_MEM_8(rIX+d, RL(READ_MEM_8(rIX+d))); break;
+            case 0x12: rD = WRITE_MEM_8(rIX+d, RL(READ_MEM_8(rIX+d))); break;
+            case 0x13: rE = WRITE_MEM_8(rIX+d, RL(READ_MEM_8(rIX+d))); break;
+            case 0x14: rH = WRITE_MEM_8(rIX+d, RL(READ_MEM_8(rIX+d))); break;
+            case 0x15: rL = WRITE_MEM_8(rIX+d, RL(READ_MEM_8(rIX+d))); break;
+            case 0x16:      WRITE_MEM_8(rIX+d, RL(READ_MEM_8(rIX+d))); break;
+            case 0x17: rA = WRITE_MEM_8(rIX+d, RL(READ_MEM_8(rIX+d))); break;
+            case 0x18: rB = WRITE_MEM_8(rIX+d, RR(READ_MEM_8(rIX+d))); break;
+            case 0x19: rC = WRITE_MEM_8(rIX+d, RR(READ_MEM_8(rIX+d))); break;
+            case 0x1A: rD = WRITE_MEM_8(rIX+d, RR(READ_MEM_8(rIX+d))); break;
+            case 0x1B: rE = WRITE_MEM_8(rIX+d, RR(READ_MEM_8(rIX+d))); break;
+            case 0x1C: rH = WRITE_MEM_8(rIX+d, RR(READ_MEM_8(rIX+d))); break;
+            case 0x1D: rL = WRITE_MEM_8(rIX+d, RR(READ_MEM_8(rIX+d))); break;
+            case 0x1E:      WRITE_MEM_8(rIX+d, RR(READ_MEM_8(rIX+d))); break;
+            case 0x1F: rA = WRITE_MEM_8(rIX+d, RR(READ_MEM_8(rIX+d))); break;
 
-            case 0x20: SLA(&memory[rIX+LD8()],_rB);     break;
-            case 0x21: SLA(&memory[rIX+LD8()],_rC);     break;
-            case 0x22: SLA(&memory[rIX+LD8()],_rD);     break;
-            case 0x23: SLA(&memory[rIX+LD8()],_rE);     break;
-            case 0x24: SLA(&memory[rIX+LD8()],_rH);     break;
-            case 0x25: SLA(&memory[rIX+LD8()],_rL);     break;
-            case 0x26: SLA(&memory[rIX+LD8()]);         break;
-            case 0x27: SLA(&memory[rIX+LD8()],_rA);     break;
-            case 0x28: SRA(&memory[rIX+LD8()],_rB);     break;
-            case 0x29: SRA(&memory[rIX+LD8()],_rC);     break;
-            case 0x2A: SRA(&memory[rIX+LD8()],_rD);     break;
-            case 0x2B: SRA(&memory[rIX+LD8()],_rE);     break;
-            case 0x2C: SRA(&memory[rIX+LD8()],_rH);     break;
-            case 0x2D: SRA(&memory[rIX+LD8()],_rL);     break;
-            case 0x2E: SRA(&memory[rIX+LD8()]);         break;
-            case 0x2F: SRA(&memory[rIX+LD8()],_rA);     break;
+            case 0x20: rB = WRITE_MEM_8(rIX+d, SLA(READ_MEM_8(rIX+d))); break;
+            case 0x21: rC = WRITE_MEM_8(rIX+d, SLA(READ_MEM_8(rIX+d))); break;
+            case 0x22: rD = WRITE_MEM_8(rIX+d, SLA(READ_MEM_8(rIX+d))); break;
+            case 0x23: rE = WRITE_MEM_8(rIX+d, SLA(READ_MEM_8(rIX+d))); break;
+            case 0x24: rH = WRITE_MEM_8(rIX+d, SLA(READ_MEM_8(rIX+d))); break;
+            case 0x25: rL = WRITE_MEM_8(rIX+d, SLA(READ_MEM_8(rIX+d))); break;
+            case 0x26:      WRITE_MEM_8(rIX+d, SLA(READ_MEM_8(rIX+d))); break;
+            case 0x27: rA = WRITE_MEM_8(rIX+d, SLA(READ_MEM_8(rIX+d))); break;
+            case 0x28: rB = WRITE_MEM_8(rIX+d, SRA(READ_MEM_8(rIX+d))); break;
+            case 0x29: rC = WRITE_MEM_8(rIX+d, SRA(READ_MEM_8(rIX+d))); break;
+            case 0x2A: rD = WRITE_MEM_8(rIX+d, SRA(READ_MEM_8(rIX+d))); break;
+            case 0x2B: rE = WRITE_MEM_8(rIX+d, SRA(READ_MEM_8(rIX+d))); break;
+            case 0x2C: rH = WRITE_MEM_8(rIX+d, SRA(READ_MEM_8(rIX+d))); break;
+            case 0x2D: rL = WRITE_MEM_8(rIX+d, SRA(READ_MEM_8(rIX+d))); break;
+            case 0x2E:      WRITE_MEM_8(rIX+d, SRA(READ_MEM_8(rIX+d))); break;
+            case 0x2F: rA = WRITE_MEM_8(rIX+d, SRA(READ_MEM_8(rIX+d))); break;
 
-            case 0x30: SLL(&memory[rIX+LD8()],_rB);     break;
-            case 0x31: SLL(&memory[rIX+LD8()],_rC);     break;
-            case 0x32: SLL(&memory[rIX+LD8()],_rD);     break;
-            case 0x33: SLL(&memory[rIX+LD8()],_rE);     break;
-            case 0x34: SLL(&memory[rIX+LD8()],_rH);     break;
-            case 0x35: SLL(&memory[rIX+LD8()],_rL);     break;
-            case 0x36: SLL(&memory[rIX+LD8()]);         break;
-            case 0x37: SLL(&memory[rIX+LD8()],_rA);     break;
-            case 0x38: SRL(&memory[rIX+LD8()],_rB);     break;
-            case 0x39: SRL(&memory[rIX+LD8()],_rC);     break;
-            case 0x3A: SRL(&memory[rIX+LD8()],_rD);     break;
-            case 0x3B: SRL(&memory[rIX+LD8()],_rE);     break;
-            case 0x3C: SRL(&memory[rIX+LD8()],_rH);     break;
-            case 0x3D: SRL(&memory[rIX+LD8()],_rL);     break;
-            case 0x3E: SRL(&memory[rIX+LD8()]);         break;
-            case 0x3F: SRL(&memory[rIX+LD8()],_rA);     break;
+            case 0x30: rB = WRITE_MEM_8(rIX+d, SLL(READ_MEM_8(rIX+d))); break;
+            case 0x31: rC = WRITE_MEM_8(rIX+d, SLL(READ_MEM_8(rIX+d))); break;
+            case 0x32: rD = WRITE_MEM_8(rIX+d, SLL(READ_MEM_8(rIX+d))); break;
+            case 0x33: rE = WRITE_MEM_8(rIX+d, SLL(READ_MEM_8(rIX+d))); break;
+            case 0x34: rH = WRITE_MEM_8(rIX+d, SLL(READ_MEM_8(rIX+d))); break;
+            case 0x35: rL = WRITE_MEM_8(rIX+d, SLL(READ_MEM_8(rIX+d))); break;
+            case 0x36:      WRITE_MEM_8(rIX+d, SLL(READ_MEM_8(rIX+d))); break;
+            case 0x37: rA = WRITE_MEM_8(rIX+d, SLL(READ_MEM_8(rIX+d))); break;
+            case 0x38: rB = WRITE_MEM_8(rIX+d, SRL(READ_MEM_8(rIX+d))); break;
+            case 0x39: rC = WRITE_MEM_8(rIX+d, SRL(READ_MEM_8(rIX+d))); break;
+            case 0x3A: rD = WRITE_MEM_8(rIX+d, SRL(READ_MEM_8(rIX+d))); break;
+            case 0x3B: rE = WRITE_MEM_8(rIX+d, SRL(READ_MEM_8(rIX+d))); break;
+            case 0x3C: rH = WRITE_MEM_8(rIX+d, SRL(READ_MEM_8(rIX+d))); break;
+            case 0x3D: rL = WRITE_MEM_8(rIX+d, SRL(READ_MEM_8(rIX+d))); break;
+            case 0x3E:      WRITE_MEM_8(rIX+d, SRL(READ_MEM_8(rIX+d))); break;
+            case 0x3F: rA = WRITE_MEM_8(rIX+d, SRL(READ_MEM_8(rIX+d))); break;
 
-            case 0x40: BIT(0, memory[rIX+LD8()]);       break;
-            case 0x41: BIT(0, memory[rIX+LD8()]);       break;
-            case 0x42: BIT(0, memory[rIX+LD8()]);       break;
-            case 0x43: BIT(0, memory[rIX+LD8()]);       break;
-            case 0x44: BIT(0, memory[rIX+LD8()]);       break;
-            case 0x45: BIT(0, memory[rIX+LD8()]);       break;
-            case 0x46: BIT(0, memory[rIX+LD8()]);       break;
-            case 0x47: BIT(0, memory[rIX+LD8()]);       break;
-            case 0x48: BIT(1, memory[rIX+LD8()]);       break;
-            case 0x49: BIT(1, memory[rIX+LD8()]);       break;
-            case 0x4A: BIT(1, memory[rIX+LD8()]);       break;
-            case 0x4B: BIT(1, memory[rIX+LD8()]);       break;
-            case 0x4C: BIT(1, memory[rIX+LD8()]);       break;
-            case 0x4D: BIT(1, memory[rIX+LD8()]);       break;
-            case 0x4E: BIT(1, memory[rIX+LD8()]);       break;
-            case 0x4F: BIT(1, memory[rIX+LD8()]);       break;
+            case 0x40: BIT(0, READ_MEM_8(rIX+d));                       break;
+            case 0x41: BIT(0, READ_MEM_8(rIX+d));                       break;
+            case 0x42: BIT(0, READ_MEM_8(rIX+d));                       break;
+            case 0x43: BIT(0, READ_MEM_8(rIX+d));                       break;
+            case 0x44: BIT(0, READ_MEM_8(rIX+d));                       break;
+            case 0x45: BIT(0, READ_MEM_8(rIX+d));                       break;
+            case 0x46: BIT(0, READ_MEM_8(rIX+d));                       break;
+            case 0x47: BIT(0, READ_MEM_8(rIX+d));                       break;
+            case 0x48: BIT(1, READ_MEM_8(rIX+d));                       break;
+            case 0x49: BIT(1, READ_MEM_8(rIX+d));                       break;
+            case 0x4A: BIT(1, READ_MEM_8(rIX+d));                       break;
+            case 0x4B: BIT(1, READ_MEM_8(rIX+d));                       break;
+            case 0x4C: BIT(1, READ_MEM_8(rIX+d));                       break;
+            case 0x4D: BIT(1, READ_MEM_8(rIX+d));                       break;
+            case 0x4E: BIT(1, READ_MEM_8(rIX+d));                       break;
+            case 0x4F: BIT(1, READ_MEM_8(rIX+d));                       break;
+            
+            case 0x50: BIT(2, READ_MEM_8(rIX+d));                       break;
+            case 0x51: BIT(2, READ_MEM_8(rIX+d));                       break;
+            case 0x52: BIT(2, READ_MEM_8(rIX+d));                       break;
+            case 0x53: BIT(2, READ_MEM_8(rIX+d));                       break;
+            case 0x54: BIT(2, READ_MEM_8(rIX+d));                       break;
+            case 0x55: BIT(2, READ_MEM_8(rIX+d));                       break;
+            case 0x56: BIT(2, READ_MEM_8(rIX+d));                       break;
+            case 0x57: BIT(2, READ_MEM_8(rIX+d));                       break;
+            case 0x58: BIT(3, READ_MEM_8(rIX+d));                       break;
+            case 0x59: BIT(3, READ_MEM_8(rIX+d));                       break;
+            case 0x5A: BIT(3, READ_MEM_8(rIX+d));                       break;
+            case 0x5B: BIT(3, READ_MEM_8(rIX+d));                       break;
+            case 0x5C: BIT(3, READ_MEM_8(rIX+d));                       break;
+            case 0x5D: BIT(3, READ_MEM_8(rIX+d));                       break;
+            case 0x5E: BIT(3, READ_MEM_8(rIX+d));                       break;
+            case 0x5F: BIT(3, READ_MEM_8(rIX+d));                       break;
+            
+            case 0x60: BIT(4, READ_MEM_8(rIX+d));                       break;
+            case 0x61: BIT(4, READ_MEM_8(rIX+d));                       break;
+            case 0x62: BIT(4, READ_MEM_8(rIX+d));                       break;
+            case 0x63: BIT(4, READ_MEM_8(rIX+d));                       break;
+            case 0x64: BIT(4, READ_MEM_8(rIX+d));                       break;
+            case 0x65: BIT(4, READ_MEM_8(rIX+d));                       break;
+            case 0x66: BIT(4, READ_MEM_8(rIX+d));                       break;
+            case 0x67: BIT(4, READ_MEM_8(rIX+d));                       break;
+            case 0x68: BIT(5, READ_MEM_8(rIX+d));                       break;
+            case 0x69: BIT(5, READ_MEM_8(rIX+d));                       break;
+            case 0x6A: BIT(5, READ_MEM_8(rIX+d));                       break;
+            case 0x6B: BIT(5, READ_MEM_8(rIX+d));                       break;
+            case 0x6C: BIT(5, READ_MEM_8(rIX+d));                       break;
+            case 0x6D: BIT(5, READ_MEM_8(rIX+d));                       break;
+            case 0x6E: BIT(5, READ_MEM_8(rIX+d));                       break;
+            case 0x6F: BIT(5, READ_MEM_8(rIX+d));                       break;
+            
+            case 0x70: BIT(6, READ_MEM_8(rIX+d));                       break;
+            case 0x71: BIT(6, READ_MEM_8(rIX+d));                       break;
+            case 0x72: BIT(6, READ_MEM_8(rIX+d));                       break;
+            case 0x73: BIT(6, READ_MEM_8(rIX+d));                       break;
+            case 0x74: BIT(6, READ_MEM_8(rIX+d));                       break;
+            case 0x75: BIT(6, READ_MEM_8(rIX+d));                       break;
+            case 0x76: BIT(6, READ_MEM_8(rIX+d));                       break;
+            case 0x77: BIT(6, READ_MEM_8(rIX+d));                       break;
+            case 0x78: BIT(7, READ_MEM_8(rIX+d));                       break;
+            case 0x79: BIT(7, READ_MEM_8(rIX+d));                       break;
+            case 0x7A: BIT(7, READ_MEM_8(rIX+d));                       break;
+            case 0x7B: BIT(7, READ_MEM_8(rIX+d));                       break;
+            case 0x7C: BIT(7, READ_MEM_8(rIX+d));                       break;
+            case 0x7D: BIT(7, READ_MEM_8(rIX+d));                       break;
+            case 0x7E: BIT(7, READ_MEM_8(rIX+d));                       break;
+            case 0x7F: BIT(7, READ_MEM_8(rIX+d));                       break;
 
-            case 0x50: BIT(2, memory[rIX+LD8()]);       break;
-            case 0x51: BIT(2, memory[rIX+LD8()]);       break;
-            case 0x52: BIT(2, memory[rIX+LD8()]);       break;
-            case 0x53: BIT(2, memory[rIX+LD8()]);       break;
-            case 0x54: BIT(2, memory[rIX+LD8()]);       break;
-            case 0x55: BIT(2, memory[rIX+LD8()]);       break;
-            case 0x56: BIT(2, memory[rIX+LD8()]);       break;
-            case 0x57: BIT(2, memory[rIX+LD8()]);       break;
-            case 0x58: BIT(3, memory[rIX+LD8()]);       break;
-            case 0x59: BIT(3, memory[rIX+LD8()]);       break;
-            case 0x5A: BIT(3, memory[rIX+LD8()]);       break;
-            case 0x5B: BIT(3, memory[rIX+LD8()]);       break;
-            case 0x5C: BIT(3, memory[rIX+LD8()]);       break;
-            case 0x5D: BIT(3, memory[rIX+LD8()]);       break;
-            case 0x5E: BIT(3, memory[rIX+LD8()]);       break;
-            case 0x5F: BIT(3, memory[rIX+LD8()]);       break;
+            case 0x80: rB = WRITE_MEM_8(rIX+d, RES(0, READ_MEM_8(rIX+d))); break;
+            case 0x81: rC = WRITE_MEM_8(rIX+d, RES(0, READ_MEM_8(rIX+d))); break;
+            case 0x82: rD = WRITE_MEM_8(rIX+d, RES(0, READ_MEM_8(rIX+d))); break;
+            case 0x83: rE = WRITE_MEM_8(rIX+d, RES(0, READ_MEM_8(rIX+d))); break;
+            case 0x84: rH = WRITE_MEM_8(rIX+d, RES(0, READ_MEM_8(rIX+d))); break;
+            case 0x85: rL = WRITE_MEM_8(rIX+d, RES(0, READ_MEM_8(rIX+d))); break;
+            case 0x86:      WRITE_MEM_8(rIX+d, RES(0, READ_MEM_8(rIX+d))); break;
+            case 0x87: rA = WRITE_MEM_8(rIX+d, RES(0, READ_MEM_8(rIX+d))); break;
+            case 0x88: rB = WRITE_MEM_8(rIX+d, RES(1, READ_MEM_8(rIX+d))); break;
+            case 0x89: rC = WRITE_MEM_8(rIX+d, RES(1, READ_MEM_8(rIX+d))); break;
+            case 0x8A: rD = WRITE_MEM_8(rIX+d, RES(1, READ_MEM_8(rIX+d))); break;
+            case 0x8B: rE = WRITE_MEM_8(rIX+d, RES(1, READ_MEM_8(rIX+d))); break;
+            case 0x8C: rH = WRITE_MEM_8(rIX+d, RES(1, READ_MEM_8(rIX+d))); break;
+            case 0x8D: rL = WRITE_MEM_8(rIX+d, RES(1, READ_MEM_8(rIX+d))); break;
+            case 0x8E:      WRITE_MEM_8(rIX+d, RES(1, READ_MEM_8(rIX+d))); break;
+            case 0x8F: rA = WRITE_MEM_8(rIX+d, RES(1, READ_MEM_8(rIX+d))); break;
 
-            case 0x60: BIT(4, memory[rIX+LD8()]);       break;
-            case 0x61: BIT(4, memory[rIX+LD8()]);       break;
-            case 0x62: BIT(4, memory[rIX+LD8()]);       break;
-            case 0x63: BIT(4, memory[rIX+LD8()]);       break;
-            case 0x64: BIT(4, memory[rIX+LD8()]);       break;
-            case 0x65: BIT(4, memory[rIX+LD8()]);       break;
-            case 0x66: BIT(4, memory[rIX+LD8()]);       break;
-            case 0x67: BIT(4, memory[rIX+LD8()]);       break;
-            case 0x68: BIT(5, memory[rIX+LD8()]);       break;
-            case 0x69: BIT(5, memory[rIX+LD8()]);       break;
-            case 0x6A: BIT(5, memory[rIX+LD8()]);       break;
-            case 0x6B: BIT(5, memory[rIX+LD8()]);       break;
-            case 0x6C: BIT(5, memory[rIX+LD8()]);       break;
-            case 0x6D: BIT(5, memory[rIX+LD8()]);       break;
-            case 0x6E: BIT(5, memory[rIX+LD8()]);       break;
-            case 0x6F: BIT(5, memory[rIX+LD8()]);       break;
+            case 0x90: rB = WRITE_MEM_8(rIX+d, RES(2, READ_MEM_8(rIX+d))); break;
+            case 0x91: rC = WRITE_MEM_8(rIX+d, RES(2, READ_MEM_8(rIX+d))); break;
+            case 0x92: rD = WRITE_MEM_8(rIX+d, RES(2, READ_MEM_8(rIX+d))); break;
+            case 0x93: rE = WRITE_MEM_8(rIX+d, RES(2, READ_MEM_8(rIX+d))); break;
+            case 0x94: rH = WRITE_MEM_8(rIX+d, RES(2, READ_MEM_8(rIX+d))); break;
+            case 0x95: rL = WRITE_MEM_8(rIX+d, RES(2, READ_MEM_8(rIX+d))); break;
+            case 0x96:      WRITE_MEM_8(rIX+d, RES(2, READ_MEM_8(rIX+d))); break;
+            case 0x97: rA = WRITE_MEM_8(rIX+d, RES(2, READ_MEM_8(rIX+d))); break;
+            case 0x98: rB = WRITE_MEM_8(rIX+d, RES(3, READ_MEM_8(rIX+d))); break;
+            case 0x99: rC = WRITE_MEM_8(rIX+d, RES(3, READ_MEM_8(rIX+d))); break;
+            case 0x9A: rD = WRITE_MEM_8(rIX+d, RES(3, READ_MEM_8(rIX+d))); break;
+            case 0x9B: rE = WRITE_MEM_8(rIX+d, RES(3, READ_MEM_8(rIX+d))); break;
+            case 0x9C: rH = WRITE_MEM_8(rIX+d, RES(3, READ_MEM_8(rIX+d))); break;
+            case 0x9D: rL = WRITE_MEM_8(rIX+d, RES(3, READ_MEM_8(rIX+d))); break;
+            case 0x9E:      WRITE_MEM_8(rIX+d, RES(3, READ_MEM_8(rIX+d))); break;
+            case 0x9F: rA = WRITE_MEM_8(rIX+d, RES(3, READ_MEM_8(rIX+d))); break;
 
-            case 0x70: BIT(6, memory[rIX+LD8()]);       break;
-            case 0x71: BIT(6, memory[rIX+LD8()]);       break;
-            case 0x72: BIT(6, memory[rIX+LD8()]);       break;
-            case 0x73: BIT(6, memory[rIX+LD8()]);       break;
-            case 0x74: BIT(6, memory[rIX+LD8()]);       break;
-            case 0x75: BIT(6, memory[rIX+LD8()]);       break;
-            case 0x76: BIT(6, memory[rIX+LD8()]);       break;
-            case 0x77: BIT(6, memory[rIX+LD8()]);       break;
-            case 0x78: BIT(7, memory[rIX+LD8()]);       break;
-            case 0x79: BIT(7, memory[rIX+LD8()]);       break;
-            case 0x7A: BIT(7, memory[rIX+LD8()]);       break;
-            case 0x7B: BIT(7, memory[rIX+LD8()]);       break;
-            case 0x7C: BIT(7, memory[rIX+LD8()]);       break;
-            case 0x7D: BIT(7, memory[rIX+LD8()]);       break;
-            case 0x7E: BIT(7, memory[rIX+LD8()]);       break;
-            case 0x7F: BIT(7, memory[rIX+LD8()]);       break;
+            case 0xA0: rB = WRITE_MEM_8(rIX+d, RES(4, READ_MEM_8(rIX+d))); break;
+            case 0xA1: rC = WRITE_MEM_8(rIX+d, RES(4, READ_MEM_8(rIX+d))); break;
+            case 0xA2: rD = WRITE_MEM_8(rIX+d, RES(4, READ_MEM_8(rIX+d))); break;
+            case 0xA3: rE = WRITE_MEM_8(rIX+d, RES(4, READ_MEM_8(rIX+d))); break;
+            case 0xA4: rH = WRITE_MEM_8(rIX+d, RES(4, READ_MEM_8(rIX+d))); break;
+            case 0xA5: rL = WRITE_MEM_8(rIX+d, RES(4, READ_MEM_8(rIX+d))); break;
+            case 0xA6:      WRITE_MEM_8(rIX+d, RES(4, READ_MEM_8(rIX+d))); break;
+            case 0xA7: rA = WRITE_MEM_8(rIX+d, RES(4, READ_MEM_8(rIX+d))); break;
+            case 0xA8: rB = WRITE_MEM_8(rIX+d, RES(5, READ_MEM_8(rIX+d))); break;
+            case 0xA9: rC = WRITE_MEM_8(rIX+d, RES(5, READ_MEM_8(rIX+d))); break;
+            case 0xAA: rD = WRITE_MEM_8(rIX+d, RES(5, READ_MEM_8(rIX+d))); break;
+            case 0xAB: rE = WRITE_MEM_8(rIX+d, RES(5, READ_MEM_8(rIX+d))); break;
+            case 0xAC: rH = WRITE_MEM_8(rIX+d, RES(5, READ_MEM_8(rIX+d))); break;
+            case 0xAD: rL = WRITE_MEM_8(rIX+d, RES(5, READ_MEM_8(rIX+d))); break;
+            case 0xAE:      WRITE_MEM_8(rIX+d, RES(5, READ_MEM_8(rIX+d))); break;
+            case 0xAF: rA = WRITE_MEM_8(rIX+d, RES(5, READ_MEM_8(rIX+d))); break;
 
-            case 0x80: RES(0, &memory[rIX+LD8()], _rB); break;
-            case 0x81: RES(0, &memory[rIX+LD8()], _rC); break;
-            case 0x82: RES(0, &memory[rIX+LD8()], _rD); break;
-            case 0x83: RES(0, &memory[rIX+LD8()], _rE); break;
-            case 0x84: RES(0, &memory[rIX+LD8()], _rH); break;
-            case 0x85: RES(0, &memory[rIX+LD8()], _rL); break;
-            case 0x86: RES(0, &memory[rIX+LD8()]);      break;
-            case 0x87: RES(0, &memory[rIX+LD8()], _rA); break;
-            case 0x88: RES(1, &memory[rIX+LD8()], _rB); break;
-            case 0x89: RES(1, &memory[rIX+LD8()], _rC); break;
-            case 0x8A: RES(1, &memory[rIX+LD8()], _rD); break;
-            case 0x8B: RES(1, &memory[rIX+LD8()], _rE); break;
-            case 0x8C: RES(1, &memory[rIX+LD8()], _rH); break;
-            case 0x8D: RES(1, &memory[rIX+LD8()], _rL); break;
-            case 0x8E: RES(1, &memory[rIX+LD8()]);      break;
-            case 0x8F: RES(1, &memory[rIX+LD8()], _rA); break;
+            case 0xB0: rB = WRITE_MEM_8(rIX+d, RES(6, READ_MEM_8(rIX+d))); break;
+            case 0xB1: rC = WRITE_MEM_8(rIX+d, RES(6, READ_MEM_8(rIX+d))); break;
+            case 0xB2: rD = WRITE_MEM_8(rIX+d, RES(6, READ_MEM_8(rIX+d))); break;
+            case 0xB3: rE = WRITE_MEM_8(rIX+d, RES(6, READ_MEM_8(rIX+d))); break;
+            case 0xB4: rH = WRITE_MEM_8(rIX+d, RES(6, READ_MEM_8(rIX+d))); break;
+            case 0xB5: rL = WRITE_MEM_8(rIX+d, RES(6, READ_MEM_8(rIX+d))); break;
+            case 0xB6:      WRITE_MEM_8(rIX+d, RES(6, READ_MEM_8(rIX+d))); break;
+            case 0xB7: rA = WRITE_MEM_8(rIX+d, RES(6, READ_MEM_8(rIX+d))); break;
+            case 0xB8: rB = WRITE_MEM_8(rIX+d, RES(7, READ_MEM_8(rIX+d))); break;
+            case 0xB9: rC = WRITE_MEM_8(rIX+d, RES(7, READ_MEM_8(rIX+d))); break;
+            case 0xBA: rD = WRITE_MEM_8(rIX+d, RES(7, READ_MEM_8(rIX+d))); break;
+            case 0xBB: rE = WRITE_MEM_8(rIX+d, RES(7, READ_MEM_8(rIX+d))); break;
+            case 0xBC: rH = WRITE_MEM_8(rIX+d, RES(7, READ_MEM_8(rIX+d))); break;
+            case 0xBD: rL = WRITE_MEM_8(rIX+d, RES(7, READ_MEM_8(rIX+d))); break;
+            case 0xBE:      WRITE_MEM_8(rIX+d, RES(7, READ_MEM_8(rIX+d))); break;
+            case 0xBF: rA = WRITE_MEM_8(rIX+d, RES(7, READ_MEM_8(rIX+d))); break;
 
-            case 0x90: RES(2, &memory[rIX+LD8()], _rB); break;
-            case 0x91: RES(2, &memory[rIX+LD8()], _rC); break;
-            case 0x92: RES(2, &memory[rIX+LD8()], _rD); break;
-            case 0x93: RES(2, &memory[rIX+LD8()], _rE); break;
-            case 0x94: RES(2, &memory[rIX+LD8()], _rH); break;
-            case 0x95: RES(2, &memory[rIX+LD8()], _rL); break;
-            case 0x96: RES(2, &memory[rIX+LD8()]);      break;
-            case 0x97: RES(2, &memory[rIX+LD8()], _rA); break;
-            case 0x98: RES(3, &memory[rIX+LD8()], _rB); break;
-            case 0x99: RES(3, &memory[rIX+LD8()], _rC); break;
-            case 0x9A: RES(3, &memory[rIX+LD8()], _rD); break;
-            case 0x9B: RES(3, &memory[rIX+LD8()], _rE); break;
-            case 0x9C: RES(3, &memory[rIX+LD8()], _rH); break;
-            case 0x9D: RES(3, &memory[rIX+LD8()], _rL); break;
-            case 0x9E: RES(3, &memory[rIX+LD8()]);      break;
-            case 0x9F: RES(3, &memory[rIX+LD8()], _rA); break;
+            case 0xC0: rB = WRITE_MEM_8(rIX+d, SET(0, READ_MEM_8(rIX+d))); break;
+            case 0xC1: rC = WRITE_MEM_8(rIX+d, SET(0, READ_MEM_8(rIX+d))); break;
+            case 0xC2: rD = WRITE_MEM_8(rIX+d, SET(0, READ_MEM_8(rIX+d))); break;
+            case 0xC3: rE = WRITE_MEM_8(rIX+d, SET(0, READ_MEM_8(rIX+d))); break;
+            case 0xC4: rH = WRITE_MEM_8(rIX+d, SET(0, READ_MEM_8(rIX+d))); break;
+            case 0xC5: rL = WRITE_MEM_8(rIX+d, SET(0, READ_MEM_8(rIX+d))); break;
+            case 0xC6:      WRITE_MEM_8(rIX+d, SET(0, READ_MEM_8(rIX+d))); break;
+            case 0xC7: rA = WRITE_MEM_8(rIX+d, SET(0, READ_MEM_8(rIX+d))); break;
+            case 0xC8: rB = WRITE_MEM_8(rIX+d, SET(1, READ_MEM_8(rIX+d))); break;
+            case 0xC9: rC = WRITE_MEM_8(rIX+d, SET(1, READ_MEM_8(rIX+d))); break;
+            case 0xCA: rD = WRITE_MEM_8(rIX+d, SET(1, READ_MEM_8(rIX+d))); break;
+            case 0xCB: rE = WRITE_MEM_8(rIX+d, SET(1, READ_MEM_8(rIX+d))); break;
+            case 0xCC: rH = WRITE_MEM_8(rIX+d, SET(1, READ_MEM_8(rIX+d))); break;
+            case 0xCD: rL = WRITE_MEM_8(rIX+d, SET(1, READ_MEM_8(rIX+d))); break;
+            case 0xCE:      WRITE_MEM_8(rIX+d, SET(1, READ_MEM_8(rIX+d))); break;
+            case 0xCF: rA = WRITE_MEM_8(rIX+d, SET(1, READ_MEM_8(rIX+d))); break;
 
-            case 0xA0: RES(4, &memory[rIX+LD8()], _rB); break;
-            case 0xA1: RES(4, &memory[rIX+LD8()], _rC); break;
-            case 0xA2: RES(4, &memory[rIX+LD8()], _rD); break;
-            case 0xA3: RES(4, &memory[rIX+LD8()], _rE); break;
-            case 0xA4: RES(4, &memory[rIX+LD8()], _rH); break;
-            case 0xA5: RES(4, &memory[rIX+LD8()], _rL); break;
-            case 0xA6: RES(4, &memory[rIX+LD8()]);      break;
-            case 0xA7: RES(4, &memory[rIX+LD8()], _rA); break;
-            case 0xA8: RES(5, &memory[rIX+LD8()], _rB); break;
-            case 0xA9: RES(5, &memory[rIX+LD8()], _rC); break;
-            case 0xAA: RES(5, &memory[rIX+LD8()], _rD); break;
-            case 0xAB: RES(5, &memory[rIX+LD8()], _rE); break;
-            case 0xAC: RES(5, &memory[rIX+LD8()], _rH); break;
-            case 0xAD: RES(5, &memory[rIX+LD8()], _rL); break;
-            case 0xAE: RES(5, &memory[rIX+LD8()]);      break;
-            case 0xAF: RES(5, &memory[rIX+LD8()], _rA); break;
+            case 0xD0: rB = WRITE_MEM_8(rIX+d, SET(2, READ_MEM_8(rIX+d))); break;
+            case 0xD1: rC = WRITE_MEM_8(rIX+d, SET(2, READ_MEM_8(rIX+d))); break;
+            case 0xD2: rD = WRITE_MEM_8(rIX+d, SET(2, READ_MEM_8(rIX+d))); break;
+            case 0xD3: rE = WRITE_MEM_8(rIX+d, SET(2, READ_MEM_8(rIX+d))); break;
+            case 0xD4: rH = WRITE_MEM_8(rIX+d, SET(2, READ_MEM_8(rIX+d))); break;
+            case 0xD5: rL = WRITE_MEM_8(rIX+d, SET(2, READ_MEM_8(rIX+d))); break;
+            case 0xD6:      WRITE_MEM_8(rIX+d, SET(2, READ_MEM_8(rIX+d))); break;
+            case 0xD7: rA = WRITE_MEM_8(rIX+d, SET(2, READ_MEM_8(rIX+d))); break;
+            case 0xD8: rB = WRITE_MEM_8(rIX+d, SET(3, READ_MEM_8(rIX+d))); break;
+            case 0xD9: rC = WRITE_MEM_8(rIX+d, SET(3, READ_MEM_8(rIX+d))); break;
+            case 0xDA: rD = WRITE_MEM_8(rIX+d, SET(3, READ_MEM_8(rIX+d))); break;
+            case 0xDB: rE = WRITE_MEM_8(rIX+d, SET(3, READ_MEM_8(rIX+d))); break;
+            case 0xDC: rH = WRITE_MEM_8(rIX+d, SET(3, READ_MEM_8(rIX+d))); break;
+            case 0xDD: rL = WRITE_MEM_8(rIX+d, SET(3, READ_MEM_8(rIX+d))); break;
+            case 0xDE:      WRITE_MEM_8(rIX+d, SET(3, READ_MEM_8(rIX+d))); break;
+            case 0xDF: rA = WRITE_MEM_8(rIX+d, SET(3, READ_MEM_8(rIX+d))); break;
 
-            case 0xB0: RES(6, &memory[rIX+LD8()], _rB); break;
-            case 0xB1: RES(6, &memory[rIX+LD8()], _rC); break;
-            case 0xB2: RES(6, &memory[rIX+LD8()], _rD); break;
-            case 0xB3: RES(6, &memory[rIX+LD8()], _rE); break;
-            case 0xB4: RES(6, &memory[rIX+LD8()], _rH); break;
-            case 0xB5: RES(6, &memory[rIX+LD8()], _rL); break;
-            case 0xB6: RES(6, &memory[rIX+LD8()]);      break;
-            case 0xB7: RES(6, &memory[rIX+LD8()], _rA); break;
-            case 0xB8: RES(7, &memory[rIX+LD8()], _rB); break;
-            case 0xB9: RES(7, &memory[rIX+LD8()], _rC); break;
-            case 0xBA: RES(7, &memory[rIX+LD8()], _rD); break;
-            case 0xBB: RES(7, &memory[rIX+LD8()], _rE); break;
-            case 0xBC: RES(7, &memory[rIX+LD8()], _rH); break;
-            case 0xBD: RES(7, &memory[rIX+LD8()], _rL); break;
-            case 0xBE: RES(7, &memory[rIX+LD8()]);      break;
-            case 0xBF: RES(7, &memory[rIX+LD8()], _rA); break;
+            case 0xE0: rB = WRITE_MEM_8(rIX+d, SET(4, READ_MEM_8(rIX+d))); break;
+            case 0xE1: rC = WRITE_MEM_8(rIX+d, SET(4, READ_MEM_8(rIX+d))); break;
+            case 0xE2: rD = WRITE_MEM_8(rIX+d, SET(4, READ_MEM_8(rIX+d))); break;
+            case 0xE3: rE = WRITE_MEM_8(rIX+d, SET(4, READ_MEM_8(rIX+d))); break;
+            case 0xE4: rH = WRITE_MEM_8(rIX+d, SET(4, READ_MEM_8(rIX+d))); break;
+            case 0xE5: rL = WRITE_MEM_8(rIX+d, SET(4, READ_MEM_8(rIX+d))); break;
+            case 0xE6:      WRITE_MEM_8(rIX+d, SET(4, READ_MEM_8(rIX+d))); break;
+            case 0xE7: rA = WRITE_MEM_8(rIX+d, SET(4, READ_MEM_8(rIX+d))); break;
+            case 0xE8: rB = WRITE_MEM_8(rIX+d, SET(5, READ_MEM_8(rIX+d))); break;
+            case 0xE9: rC = WRITE_MEM_8(rIX+d, SET(5, READ_MEM_8(rIX+d))); break;
+            case 0xEA: rD = WRITE_MEM_8(rIX+d, SET(5, READ_MEM_8(rIX+d))); break;
+            case 0xEB: rE = WRITE_MEM_8(rIX+d, SET(5, READ_MEM_8(rIX+d))); break;
+            case 0xEC: rH = WRITE_MEM_8(rIX+d, SET(5, READ_MEM_8(rIX+d))); break;
+            case 0xED: rL = WRITE_MEM_8(rIX+d, SET(5, READ_MEM_8(rIX+d))); break;
+            case 0xEE:      WRITE_MEM_8(rIX+d, SET(5, READ_MEM_8(rIX+d))); break;
+            case 0xEF: rA = WRITE_MEM_8(rIX+d, SET(5, READ_MEM_8(rIX+d))); break;
 
-            case 0xC0: SET(0, &memory[rIX+LD8()], _rB); break;
-            case 0xC1: SET(0, &memory[rIX+LD8()], _rC); break;
-            case 0xC2: SET(0, &memory[rIX+LD8()], _rD); break;
-            case 0xC3: SET(0, &memory[rIX+LD8()], _rE); break;
-            case 0xC4: SET(0, &memory[rIX+LD8()], _rH); break;
-            case 0xC5: SET(0, &memory[rIX+LD8()], _rL); break;
-            case 0xC6: SET(0, &memory[rIX+LD8()]);      break;
-            case 0xC7: SET(0, &memory[rIX+LD8()], _rA); break;
-            case 0xC8: SET(1, &memory[rIX+LD8()], _rB); break;
-            case 0xC9: SET(1, &memory[rIX+LD8()], _rC); break;
-            case 0xCA: SET(1, &memory[rIX+LD8()], _rD); break;
-            case 0xCB: SET(1, &memory[rIX+LD8()], _rE); break;
-            case 0xCC: SET(1, &memory[rIX+LD8()], _rH); break;
-            case 0xCD: SET(1, &memory[rIX+LD8()], _rL); break;
-            case 0xCE: SET(1, &memory[rIX+LD8()]);      break;
-            case 0xCF: SET(1, &memory[rIX+LD8()], _rA); break;
-
-            case 0xD0: SET(2, &memory[rIX+LD8()], _rB); break;
-            case 0xD1: SET(2, &memory[rIX+LD8()], _rC); break;
-            case 0xD2: SET(2, &memory[rIX+LD8()], _rD); break;
-            case 0xD3: SET(2, &memory[rIX+LD8()], _rE); break;
-            case 0xD4: SET(2, &memory[rIX+LD8()], _rH); break;
-            case 0xD5: SET(2, &memory[rIX+LD8()], _rL); break;
-            case 0xD6: SET(2, &memory[rIX+LD8()]);      break;
-            case 0xD7: SET(2, &memory[rIX+LD8()], _rA); break;
-            case 0xD8: SET(3, &memory[rIX+LD8()], _rB); break;
-            case 0xD9: SET(3, &memory[rIX+LD8()], _rC); break;
-            case 0xDA: SET(3, &memory[rIX+LD8()], _rD); break;
-            case 0xDB: SET(3, &memory[rIX+LD8()], _rE); break;
-            case 0xDC: SET(3, &memory[rIX+LD8()], _rH); break;
-            case 0xDD: SET(3, &memory[rIX+LD8()], _rL); break;
-            case 0xDE: SET(3, &memory[rIX+LD8()]);      break;
-            case 0xDF: SET(3, &memory[rIX+LD8()], _rA); break;
-
-            case 0xE0: SET(4, &memory[rIX+LD8()], _rB); break;
-            case 0xE1: SET(4, &memory[rIX+LD8()], _rC); break;
-            case 0xE2: SET(4, &memory[rIX+LD8()], _rD); break;
-            case 0xE3: SET(4, &memory[rIX+LD8()], _rE); break;
-            case 0xE4: SET(4, &memory[rIX+LD8()], _rH); break;
-            case 0xE5: SET(4, &memory[rIX+LD8()], _rL); break;
-            case 0xE6: SET(4, &memory[rIX+LD8()]);      break;
-            case 0xE7: SET(4, &memory[rIX+LD8()], _rA); break;
-            case 0xE8: SET(5, &memory[rIX+LD8()], _rB); break;
-            case 0xE9: SET(5, &memory[rIX+LD8()], _rC); break;
-            case 0xEA: SET(5, &memory[rIX+LD8()], _rD); break;
-            case 0xEB: SET(5, &memory[rIX+LD8()], _rE); break;
-            case 0xEC: SET(5, &memory[rIX+LD8()], _rH); break;
-            case 0xED: SET(5, &memory[rIX+LD8()], _rL); break;
-            case 0xEE: SET(5, &memory[rIX+LD8()]);      break;
-            case 0xEF: SET(5, &memory[rIX+LD8()], _rA); break;
-
-            case 0xF0: SET(6, &memory[rIX+LD8()], _rB); break;
-            case 0xF1: SET(6, &memory[rIX+LD8()], _rC); break;
-            case 0xF2: SET(6, &memory[rIX+LD8()], _rD); break;
-            case 0xF3: SET(6, &memory[rIX+LD8()], _rE); break;
-            case 0xF4: SET(6, &memory[rIX+LD8()], _rH); break;
-            case 0xF5: SET(6, &memory[rIX+LD8()], _rL); break;
-            case 0xF6: SET(6, &memory[rIX+LD8()]);      break;
-            case 0xF7: SET(6, &memory[rIX+LD8()], _rA); break;
-            case 0xF8: SET(7, &memory[rIX+LD8()], _rB); break;
-            case 0xF9: SET(7, &memory[rIX+LD8()], _rC); break;
-            case 0xFA: SET(7, &memory[rIX+LD8()], _rD); break;
-            case 0xFB: SET(7, &memory[rIX+LD8()], _rE); break;
-            case 0xFC: SET(7, &memory[rIX+LD8()], _rH); break;
-            case 0xFD: SET(7, &memory[rIX+LD8()], _rL); break;
-            case 0xFE: SET(7, &memory[rIX+LD8()]);      break;
-            case 0xFF: SET(7, &memory[rIX+LD8()], _rA); break;
+            case 0xF0: rB = WRITE_MEM_8(rIX+d, SET(6, READ_MEM_8(rIX+d))); break;
+            case 0xF1: rC = WRITE_MEM_8(rIX+d, SET(6, READ_MEM_8(rIX+d))); break;
+            case 0xF2: rD = WRITE_MEM_8(rIX+d, SET(6, READ_MEM_8(rIX+d))); break;
+            case 0xF3: rE = WRITE_MEM_8(rIX+d, SET(6, READ_MEM_8(rIX+d))); break;
+            case 0xF4: rH = WRITE_MEM_8(rIX+d, SET(6, READ_MEM_8(rIX+d))); break;
+            case 0xF5: rL = WRITE_MEM_8(rIX+d, SET(6, READ_MEM_8(rIX+d))); break;
+            case 0xF6:      WRITE_MEM_8(rIX+d, SET(6, READ_MEM_8(rIX+d))); break;
+            case 0xF7: rA = WRITE_MEM_8(rIX+d, SET(6, READ_MEM_8(rIX+d))); break;
+            case 0xF8: rB = WRITE_MEM_8(rIX+d, SET(7, READ_MEM_8(rIX+d))); break;
+            case 0xF9: rC = WRITE_MEM_8(rIX+d, SET(7, READ_MEM_8(rIX+d))); break;
+            case 0xFA: rD = WRITE_MEM_8(rIX+d, SET(7, READ_MEM_8(rIX+d))); break;
+            case 0xFB: rE = WRITE_MEM_8(rIX+d, SET(7, READ_MEM_8(rIX+d))); break;
+            case 0xFC: rH = WRITE_MEM_8(rIX+d, SET(7, READ_MEM_8(rIX+d))); break;
+            case 0xFD: rL = WRITE_MEM_8(rIX+d, SET(7, READ_MEM_8(rIX+d))); break;
+            case 0xFE:      WRITE_MEM_8(rIX+d, SET(7, READ_MEM_8(rIX+d))); break;
+            case 0xFF: rA = WRITE_MEM_8(rIX+d, SET(7, READ_MEM_8(rIX+d))); break;
         }
     }
 
@@ -1807,7 +1927,7 @@ namespace z80
 
         switch (opcode)
         {
-            case 0x40: IN(_rB, rC);                     break;
+            case 0x40: rB = IN();                       break;
             case 0x41: OUT(rC, rB);                     break;
             case 0x42: SBC16(_rHL, rBC);                break;
             case 0x43: WRITE_MEM_16(READ_MEM_16(), rBC);break;
@@ -1815,42 +1935,42 @@ namespace z80
             case 0x45: RETN();                          break;
             case 0x46: IM(0);                           break;
             case 0x47: rI = rA;                         break;
-            case 0x48: IN(_rC, rC);                     break;
+            case 0x48: rC = IN();                       break;
             case 0x49: OUT(rC, rC);                     break;
             case 0x4A: ADC16(_rHL, rBC);                break;
             case 0x4B: rBC = READ_MEM_16(READ_MEM_16());break;
             case 0x4D: RETI();                          break;
             case 0x4F: rR = rA;                         break;
 
-            case 0x50: IN(_rD, rC);                     break;
+            case 0x50: rD = IN();                       break;
             case 0x51: OUT(rC, rD);                     break;
             case 0x52: SBC16(_rHL, rDE);                break;
             case 0x53: WRITE_MEM_16(READ_MEM_16(), rDE);break;
             case 0x56: IM(1);                           break;
             case 0x57: rA = rI;                         break;
-            case 0x58: IN(_rE, rC);                     break;
+            case 0x58: rE = IN();                       break;
             case 0x59: OUT(rC, rE);                     break;
             case 0x5A: ADC16(_rHL, rDE);                break;
             case 0x5B: rDE = READ_MEM_16(READ_MEM_16());break;
             case 0x5E: IM(2);                           break;
             case 0x5F: rA = rR;                         break;
 
-            case 0x60: IN(_rH, rC);                     break;
+            case 0x60: rH = IN();                       break;
             case 0x61: OUT(rC, rH);                     break;
             case 0x62: SBC16(_rHL, rHL);                break;
             case 0x63: WRITE_MEM_16(READ_MEM_16(), rHL);break;
             case 0x67: RRD();                           break;
-            case 0x68: IN(_rL, rC);                     break;
+            case 0x68: rL = IN();                       break;
             case 0x69: OUT(rC, rL);                     break;
             case 0x6A: ADC16(_rHL, rHL);                break;
             case 0x6B: rHL = READ_MEM_16(READ_MEM_16());break;
             case 0x6F: RLD();                           break;
 
-            case 0x70: IN(_rF, rC);                     break;
+            case 0x70: IN();                            break;
             case 0x71: OUT(rC, 0);                      break;
             case 0x72: SBC16(_rHL, rSP);                break;
             case 0x73: WRITE_MEM_16(READ_MEM_16(), rSP);break;
-            case 0x78: IN(_rA, rC);                     break;
+            case 0x78: rA = IN();                       break;
             case 0x79: OUT(rC, rA);                     break;
             case 0x7A: ADC16(_rHL, rSP);                break;
             case 0x7B: rSP = READ_MEM_16(READ_MEM_16());break;
@@ -1891,7 +2011,7 @@ namespace z80
             case 0x03: INVALID();                       break;
             case 0x04: INC8(_rB);                       break;
             case 0x05: DEC8(_rB);                       break;
-            case 0x06: rB = LD8();                      break;
+            case 0x06: rB = READ_MEM_8();               break;
             case 0x07: INVALID();                       break;
             case 0x08: INVALID();                       break;
             case 0x09: ADD16(_rIY, rBC);                break;
@@ -1899,7 +2019,7 @@ namespace z80
             case 0x0B: INVALID();                       break;
             case 0x0C: INC8(_rC);                       break;
             case 0x0D: DEC8(_rC);                       break;
-            case 0x0E: rC = LD8();                      break;
+            case 0x0E: rC = READ_MEM_8();               break;
             case 0x0F: INVALID();                       break;
 
             case 0x10: INVALID();                       break;
@@ -1908,7 +2028,7 @@ namespace z80
             case 0x13: INVALID();                       break;
             case 0x14: INC8(_rD);                       break;
             case 0x15: DEC8(_rD);                       break;
-            case 0x16: rD = LD8();                      break;
+            case 0x16: rD = READ_MEM_8();               break;
             case 0x17: INVALID();                       break;
             case 0x18: INVALID();                       break;
             case 0x19: ADD16(_rIY, rDE);                break;
@@ -1916,33 +2036,33 @@ namespace z80
             case 0x1B: INVALID();                       break;
             case 0x1C: INC8(_rE);                       break;
             case 0x1D: DEC8(_rE);                       break;
-            case 0x1E: rE = LD8();                      break;
+            case 0x1E: rE = READ_MEM_8();               break;
             case 0x1F: INVALID();                       break;
 
             case 0x20: INVALID();                       break;
-            case 0x21: rIY = LD16();                    break;
-            case 0x22: rM16(LD16()) = rIY;              break;
+            case 0x21: rIY = READ_MEM_16();             break;
+            case 0x22: WRITE_MEM_16(READ_MEM_16(),rIY); break;
             case 0x23: INC16(_rIY);                     break;
             case 0x24: INC8(_rIYH);                     break;
             case 0x25: DEC8(_rIYH);                     break;
-            case 0x26: rIYH = LD8();                    break;
+            case 0x26: rIYH = READ_MEM_8();             break;
             case 0x27: INVALID();                       break;
             case 0x28: INVALID();                       break;
             case 0x29: ADD16(_rIY, rIY);                break;
-            case 0x2A: rIY = rM16(LD16());              break;
+            case 0x2A: rIY = READ_MEM_16(READ_MEM_16());break;
             case 0x2B: DEC16(_rIY);                     break;
             case 0x2C: INC8(_rIYL);                     break;
             case 0x2D: DEC8(_rIYL);                     break;
-            case 0x2E: rIYL = LD8();                    break;
+            case 0x2E: rIYL = READ_MEM_8();             break;
             case 0x2F: INVALID();                       break;
 
             case 0x30: INVALID();                       break;
             case 0x31: INVALID();                       break;
             case 0x32: INVALID();                       break;
             case 0x33: INVALID();                       break;
-            case 0x34: INC8(&memory[rIY+LD8()]);        break;
-            case 0x35: DEC8(&memory[rIY+LD8()]);        break;
-            case 0x36: d=LD8(); memory[rIY+d]=LD8();    break;
+            case 0x34: INCMEM8(rIY+READ_MEM_8());t+=2;  break;
+            case 0x35: DECMEM8(rIY+READ_MEM_8());t+=2;  break;
+            case 0x36: d=READ_MEM_8(); WRITE_MEM_8(rIY+d, READ_MEM_8()); t+=2; break;
             case 0x37: INVALID();                       break;
             case 0x38: INVALID();                       break;
             case 0x39: ADD16(_rIY, rSP);                break;
@@ -1950,7 +2070,7 @@ namespace z80
             case 0x3B: INVALID();                       break;
             case 0x3C: INC8(_rA);                       break;
             case 0x3D: DEC8(_rA);                       break;
-            case 0x3E: rA = LD8();                      break;
+            case 0x3E: rA = READ_MEM_8();               break;
             case 0x3F: INVALID();                       break;
 
             case 0x40: rB = rB;                         break;
@@ -1959,7 +2079,7 @@ namespace z80
             case 0x43: rB = rE;                         break;
             case 0x44: rB = rIYH;                       break;
             case 0x45: rB = rIYL;                       break;
-            case 0x46: rB = memory[rIY+LD8()];          break;
+            case 0x46: d=READ_MEM_8(); rB = READ_MEM_8(rIY+d);t+=5;break;
             case 0x47: rB = rA;                         break;
             case 0x48: rC = rB;                         break;
             case 0x49: rC = rC;                         break;
@@ -1967,7 +2087,7 @@ namespace z80
             case 0x4B: rC = rE;                         break;
             case 0x4C: rC = rIYH;                       break;
             case 0x4D: rC = rIYL;                       break;
-            case 0x4E: rC = memory[rIY+LD8()];          break;
+            case 0x4E: d=READ_MEM_8(); rC = READ_MEM_8(rIY+d);t+=5;break;
             case 0x4F: rC = rA;                         break;
 
             case 0x50: rD = rB;                         break;
@@ -1976,7 +2096,7 @@ namespace z80
             case 0x53: rD = rE;                         break;
             case 0x54: rD = rIYH;                       break;
             case 0x55: rD = rIYL;                       break;
-            case 0x56: rD = memory[rIY+LD8()];          break;
+            case 0x56: d=READ_MEM_8(); rD = READ_MEM_8(rIY+d);t+=5;break;
             case 0x57: rD = rA;                         break;
             case 0x58: rE = rB;                         break;
             case 0x59: rE = rC;                         break;
@@ -1984,7 +2104,7 @@ namespace z80
             case 0x5B: rE = rE;                         break;
             case 0x5C: rE = rIYH;                       break;
             case 0x5D: rE = rIYL;                       break;
-            case 0x5E: rE = memory[rIY+LD8()];          break;
+            case 0x5E: d=READ_MEM_8(); rE = READ_MEM_8(rIY+d);t+=5;break;
             case 0x5F: rE = rA;                         break;
             
             case 0x60: rIYH = rB;                       break;
@@ -1993,7 +2113,7 @@ namespace z80
             case 0x63: rIYH = rE;                       break;
             case 0x64: rIYH = rIYH;                     break;
             case 0x65: rIYH = rIYL;                     break;
-            case 0x66: rH = memory[rIY+LD8()];          break;
+            case 0x66: d=READ_MEM_8(); rH = READ_MEM_8(rIY+d);t+=5;break;
             case 0x67: rIYH = rA;                       break;
             case 0x68: rIYL = rB;                       break;
             case 0x69: rIYL = rC;                       break;
@@ -2001,42 +2121,42 @@ namespace z80
             case 0x6B: rIYL = rE;                       break;
             case 0x6C: rIYL = rIYH;                     break;
             case 0x6D: rIYL = rIYL;                     break;
-            case 0x6E: rL = memory[rIY+LD8()];          break;
+            case 0x6E: d=READ_MEM_8(); rL = READ_MEM_8(rIY+d);t+=5;break;
             case 0x6F: rIYL = rA;                       break;
 
-            case 0x70: memory[rIY+LD8()] = rB;          break;
-            case 0x71: memory[rIY+LD8()] = rC;          break;
-            case 0x72: memory[rIY+LD8()] = rD;          break;
-            case 0x73: memory[rIY+LD8()] = rE;          break;
-            case 0x74: memory[rIY+LD8()] = rH;          break;
-            case 0x75: memory[rIY+LD8()] = rL;          break;
+            case 0x70: d=READ_MEM_8(); WRITE_MEM_8(rIY+d, rB);t+=5;break;
+            case 0x71: d=READ_MEM_8(); WRITE_MEM_8(rIY+d, rC);t+=5;break;
+            case 0x72: d=READ_MEM_8(); WRITE_MEM_8(rIY+d, rD);t+=5;break;
+            case 0x73: d=READ_MEM_8(); WRITE_MEM_8(rIY+d, rE);t+=5;break;
+            case 0x74: d=READ_MEM_8(); WRITE_MEM_8(rIY+d, rH);t+=5;break;
+            case 0x75: d=READ_MEM_8(); WRITE_MEM_8(rIY+d, rL);t+=5;break;
             case 0x76: INVALID();                       break;
-            case 0x77: memory[rIY+LD8()] = rA;          break;
+            case 0x77: d=READ_MEM_8(); WRITE_MEM_8(rIY+d, rA);t+=5;break;
             case 0x78: rA = rB;                         break;
             case 0x79: rA = rC;                         break;
             case 0x7A: rA = rD;                         break;
             case 0x7B: rA = rE;                         break;
             case 0x7C: rA = rIYH;                       break;
             case 0x7D: rA = rIYL;                       break;
-            case 0x7E: rA = memory[rIY+LD8()];          break;
+            case 0x7E: d=READ_MEM_8(); rA = READ_MEM_8(rIY+d);t+=5;break;
             case 0x7F: rA = rA;                         break;
             
-            case 0x80: ADD8(_rA, rB);                   break;
-            case 0x81: ADD8(_rA, rC);                   break;
-            case 0x82: ADD8(_rA, rD);                   break;
-            case 0x83: ADD8(_rA, rE);                   break;
-            case 0x84: ADD8(_rA, rIYH);                 break;
-            case 0x85: ADD8(_rA, rIYL);                 break;
-            case 0x86: ADD8(_rA, memory[rIY+LD8()]);    break;
-            case 0x87: ADD8(_rA, rA);                   break;
-            case 0x88: ADC8(_rA, rB);                   break;
-            case 0x89: ADC8(_rA, rC);                   break;
-            case 0x8A: ADC8(_rA, rD);                   break;
-            case 0x8B: ADC8(_rA, rE);                   break;
-            case 0x8C: ADC8(_rA, rIYH);                 break;
-            case 0x8D: ADC8(_rA, rIYL);                 break;
-            case 0x8E: ADC8(_rA, memory[rIY+LD8()]);    break;
-            case 0x8F: ADC8(_rA, rA);                   break;
+            case 0x80: ADD8(rB);                   break;
+            case 0x81: ADD8(rC);                   break;
+            case 0x82: ADD8(rD);                   break;
+            case 0x83: ADD8(rE);                   break;
+            case 0x84: ADD8(rIYH);                 break;
+            case 0x85: ADD8(rIYL);                 break;
+            case 0x86: d=READ_MEM_8(); ADD8(READ_MEM_8(rIY+d));t+=5; break;
+            case 0x87: ADD8(rA);                   break;
+            case 0x88: ADC8(rB);                   break;
+            case 0x89: ADC8(rC);                   break;
+            case 0x8A: ADC8(rD);                   break;
+            case 0x8B: ADC8(rE);                   break;
+            case 0x8C: ADC8(rIYH);                 break;
+            case 0x8D: ADC8(rIYL);                 break;
+            case 0x8E: d=READ_MEM_8(); ADC8(READ_MEM_8(rIY+d));t+=5; break;
+            case 0x8F: ADC8(rA);                   break;
 
             case 0x90: SUB8(rB);                        break;
             case 0x91: SUB8(rC);                        break;
@@ -2044,16 +2164,16 @@ namespace z80
             case 0x93: SUB8(rE);                        break;
             case 0x94: SUB8(rIYH);                      break;
             case 0x95: SUB8(rIYL);                      break;
-            case 0x96: SUB8(memory[rIY+LD8()]);         break;
+            case 0x96: d=READ_MEM_8(); SUB8(READ_MEM_8(rIY+d));t+=5; break;
             case 0x97: SUB8(rA);                        break;
-            case 0x98: SBC8(_rA, rB);                   break;
-            case 0x99: SBC8(_rA, rC);                   break;
-            case 0x9A: SBC8(_rA, rD);                   break;
-            case 0x9B: SBC8(_rA, rE);                   break;
-            case 0x9C: SBC8(_rA, rIYH);                 break;
-            case 0x9D: SBC8(_rA, rIYL);                 break;
-            case 0x9E: SBC8(_rA, memory[rIY+LD8()]);    break;
-            case 0x9F: SBC8(_rA, rA);                   break;
+            case 0x98: SBC8(rB);                   break;
+            case 0x99: SBC8(rC);                   break;
+            case 0x9A: SBC8(rD);                   break;
+            case 0x9B: SBC8(rE);                   break;
+            case 0x9C: SBC8(rIYH);                 break;
+            case 0x9D: SBC8(rIYL);                 break;
+            case 0x9E: d=READ_MEM_8(); SBC8(READ_MEM_8(rIY+d));t+=5; break;
+            case 0x9F: SBC8(rA);                   break;
 
             case 0xA0: AND(rB);                         break;
             case 0xA1: AND(rC);                         break;
@@ -2061,7 +2181,7 @@ namespace z80
             case 0xA3: AND(rE);                         break;
             case 0xA4: AND(rIYH);                       break;
             case 0xA5: AND(rIYL);                       break;
-            case 0xA6: AND(memory[rIY+LD8()]);          break;
+            case 0xA6: d=READ_MEM_8(); AND(READ_MEM_8(rIY+d));t+=5; break;
             case 0xA7: AND(rA);                         break;
             case 0xA8: XOR(rB);                         break;
             case 0xA9: XOR(rC);                         break;
@@ -2069,7 +2189,7 @@ namespace z80
             case 0xAB: XOR(rE);                         break;
             case 0xAC: XOR(rIYH);                       break;
             case 0xAD: XOR(rIYL);                       break;
-            case 0xAE: XOR(memory[rIY+LD8()]);          break;
+            case 0xAE: d=READ_MEM_8(); XOR(READ_MEM_8(rIY+d));t+=5; break;
             case 0xAF: XOR(rA);                         break;
 
             case 0xB0: OR(rB);                          break;
@@ -2078,7 +2198,7 @@ namespace z80
             case 0xB3: OR(rE);                          break;
             case 0xB4: OR(rIYH);                        break;
             case 0xB5: OR(rIYL);                        break;
-            case 0xB6: OR(memory[rIY+LD8()]);           break;
+            case 0xB6: d=READ_MEM_8(); OR(READ_MEM_8(rIY+d));t+=5; break;
             case 0xB7: OR(rA);                          break;
             case 0xB8: CP(rB);                          break;
             case 0xB9: CP(rC);                          break;
@@ -2086,296 +2206,297 @@ namespace z80
             case 0xBB: CP(rE);                          break;
             case 0xBC: CP(rIYH);                        break;
             case 0xBD: CP(rIYL);                        break;
-            case 0xBE: CP(memory[rIY+LD8()]);           break;
+            case 0xBE: d=READ_MEM_8(); CP(READ_MEM_8(rIY+d));t+=5; break;
             case 0xBF: CP(rA);                          break;
 
             case 0xCB: IX_BIT_INSTRUCTIONS();           break;
             case 0xE1: POP(_rIY);                       break;
-            case 0xE3: SWAP(rIY, rM16(rSP));            break;
+            case 0xE3: EX_MEM(_rIY, rSP);               break;
             case 0xE5: PUSH(rIY);                       break;
-            case 0xE9: JP(cNO, memory[rHL]);            break;
-            case 0xF9: rIY = rSP;                       break;
+            case 0xE9: JP(cNO, rIY);                    break;
+            case 0xF9: rSP = rIY; t+=2;                 break;
             default: INVALID();                         break;
-        }
+         }
     }
 
     void IY_BIT_INSTRUCTIONS()
     {
         const uint8_t d = READ_MEM_8();
         const uint8_t opcode = READ_MEM_8();
+        t+=3;
         switch (opcode)
         {
-            case 0x00: RLC(&memory[rIY+d],_rB);         break;
-            case 0x01: RLC(&memory[rIY+d],_rC);         break;
-            case 0x02: RLC(&memory[rIY+d],_rD);         break;
-            case 0x03: RLC(&memory[rIY+d],_rE);         break;
-            case 0x04: RLC(&memory[rIY+d],_rH);         break;
-            case 0x05: RLC(&memory[rIY+d],_rL);         break;
-            case 0x06: RLC(&memory[rIY+d]);             break;
-            case 0x07: RLC(&memory[rIY+d],_rA);         break;
-            case 0x08: RRC(&memory[rIY+d],_rB);         break;
-            case 0x09: RRC(&memory[rIY+d],_rC);         break;
-            case 0x0A: RRC(&memory[rIY+d],_rD);         break;
-            case 0x0B: RRC(&memory[rIY+d],_rE);         break;
-            case 0x0C: RRC(&memory[rIY+d],_rH);         break;
-            case 0x0D: RRC(&memory[rIY+d],_rL);         break;
-            case 0x0E: RRC(&memory[rIY+d]);             break;
-            case 0x0F: RRC(&memory[rIY+d],_rA);         break;
+            case 0x00: rB = WRITE_MEM_8(rIY+d, RLC(READ_MEM_8(rIY+d))); break;
+            case 0x01: rC = WRITE_MEM_8(rIY+d, RLC(READ_MEM_8(rIY+d))); break;
+            case 0x02: rD = WRITE_MEM_8(rIY+d, RLC(READ_MEM_8(rIY+d))); break;
+            case 0x03: rE = WRITE_MEM_8(rIY+d, RLC(READ_MEM_8(rIY+d))); break;
+            case 0x04: rH = WRITE_MEM_8(rIY+d, RLC(READ_MEM_8(rIY+d))); break;
+            case 0x05: rL = WRITE_MEM_8(rIY+d, RLC(READ_MEM_8(rIY+d))); break;
+            case 0x06:      WRITE_MEM_8(rIY+d, RLC(READ_MEM_8(rIY+d))); break;
+            case 0x07: rA = WRITE_MEM_8(rIY+d, RLC(READ_MEM_8(rIY+d))); break;
+            case 0x08: rB = WRITE_MEM_8(rIY+d, RRC(READ_MEM_8(rIY+d))); break;
+            case 0x09: rC = WRITE_MEM_8(rIY+d, RRC(READ_MEM_8(rIY+d))); break;
+            case 0x0A: rD = WRITE_MEM_8(rIY+d, RRC(READ_MEM_8(rIY+d))); break;
+            case 0x0B: rE = WRITE_MEM_8(rIY+d, RRC(READ_MEM_8(rIY+d))); break;
+            case 0x0C: rH = WRITE_MEM_8(rIY+d, RRC(READ_MEM_8(rIY+d))); break;
+            case 0x0D: rL = WRITE_MEM_8(rIY+d, RRC(READ_MEM_8(rIY+d))); break;
+            case 0x0E:      WRITE_MEM_8(rIY+d, RRC(READ_MEM_8(rIY+d))); break;
+            case 0x0F: rA = WRITE_MEM_8(rIY+d, RRC(READ_MEM_8(rIY+d))); break;
 
-            case 0x10: RL(&memory[rIY+d],_rB);          break;
-            case 0x11: RL(&memory[rIY+d],_rC);          break;
-            case 0x12: RL(&memory[rIY+d],_rD);          break;
-            case 0x13: RL(&memory[rIY+d],_rE);          break;
-            case 0x14: RL(&memory[rIY+d],_rH);          break;
-            case 0x15: RL(&memory[rIY+d],_rL);          break;
-            case 0x16: RL(&memory[rIY+d]);              break;
-            case 0x17: RL(&memory[rIY+d],_rA);          break;
-            case 0x18: RR(&memory[rIY+d],_rB);          break;
-            case 0x19: RR(&memory[rIY+d],_rC);          break;
-            case 0x1A: RR(&memory[rIY+d],_rD);          break;
-            case 0x1B: RR(&memory[rIY+d],_rE);          break;
-            case 0x1C: RR(&memory[rIY+d],_rH);          break;
-            case 0x1D: RR(&memory[rIY+d],_rL);          break;
-            case 0x1E: RR(&memory[rIY+d]);              break;
-            case 0x1F: RR(&memory[rIY+d],_rA);          break;
+            case 0x10: rB = WRITE_MEM_8(rIY+d, RL(READ_MEM_8(rIY+d))); break;
+            case 0x11: rC = WRITE_MEM_8(rIY+d, RL(READ_MEM_8(rIY+d))); break;
+            case 0x12: rD = WRITE_MEM_8(rIY+d, RL(READ_MEM_8(rIY+d))); break;
+            case 0x13: rE = WRITE_MEM_8(rIY+d, RL(READ_MEM_8(rIY+d))); break;
+            case 0x14: rH = WRITE_MEM_8(rIY+d, RL(READ_MEM_8(rIY+d))); break;
+            case 0x15: rL = WRITE_MEM_8(rIY+d, RL(READ_MEM_8(rIY+d))); break;
+            case 0x16:      WRITE_MEM_8(rIY+d, RL(READ_MEM_8(rIY+d))); break;
+            case 0x17: rA = WRITE_MEM_8(rIY+d, RL(READ_MEM_8(rIY+d))); break;
+            case 0x18: rB = WRITE_MEM_8(rIY+d, RR(READ_MEM_8(rIY+d))); break;
+            case 0x19: rC = WRITE_MEM_8(rIY+d, RR(READ_MEM_8(rIY+d))); break;
+            case 0x1A: rD = WRITE_MEM_8(rIY+d, RR(READ_MEM_8(rIY+d))); break;
+            case 0x1B: rE = WRITE_MEM_8(rIY+d, RR(READ_MEM_8(rIY+d))); break;
+            case 0x1C: rH = WRITE_MEM_8(rIY+d, RR(READ_MEM_8(rIY+d))); break;
+            case 0x1D: rL = WRITE_MEM_8(rIY+d, RR(READ_MEM_8(rIY+d))); break;
+            case 0x1E:      WRITE_MEM_8(rIY+d, RR(READ_MEM_8(rIY+d))); break;
+            case 0x1F: rA = WRITE_MEM_8(rIY+d, RR(READ_MEM_8(rIY+d))); break;
 
-            case 0x20: SLA(&memory[rIY+d],_rB);         break;
-            case 0x21: SLA(&memory[rIY+d],_rC);         break;
-            case 0x22: SLA(&memory[rIY+d],_rD);         break;
-            case 0x23: SLA(&memory[rIY+d],_rE);         break;
-            case 0x24: SLA(&memory[rIY+d],_rH);         break;
-            case 0x25: SLA(&memory[rIY+d],_rL);         break;
-            case 0x26: SLA(&memory[rIY+d]);             break;
-            case 0x27: SLA(&memory[rIY+d],_rA);         break;
-            case 0x28: SRA(&memory[rIY+d],_rB);         break;
-            case 0x29: SRA(&memory[rIY+d],_rC);         break;
-            case 0x2A: SRA(&memory[rIY+d],_rD);         break;
-            case 0x2B: SRA(&memory[rIY+d],_rE);         break;
-            case 0x2C: SRA(&memory[rIY+d],_rH);         break;
-            case 0x2D: SRA(&memory[rIY+d],_rL);         break;
-            case 0x2E: SRA(&memory[rIY+d]);             break;
-            case 0x2F: SRA(&memory[rIY+d],_rA);         break;
+            case 0x20: rB = WRITE_MEM_8(rIY+d, SLA(READ_MEM_8(rIY+d))); break;
+            case 0x21: rC = WRITE_MEM_8(rIY+d, SLA(READ_MEM_8(rIY+d))); break;
+            case 0x22: rD = WRITE_MEM_8(rIY+d, SLA(READ_MEM_8(rIY+d))); break;
+            case 0x23: rE = WRITE_MEM_8(rIY+d, SLA(READ_MEM_8(rIY+d))); break;
+            case 0x24: rH = WRITE_MEM_8(rIY+d, SLA(READ_MEM_8(rIY+d))); break;
+            case 0x25: rL = WRITE_MEM_8(rIY+d, SLA(READ_MEM_8(rIY+d))); break;
+            case 0x26:      WRITE_MEM_8(rIY+d, SLA(READ_MEM_8(rIY+d))); break;
+            case 0x27: rA = WRITE_MEM_8(rIY+d, SLA(READ_MEM_8(rIY+d))); break;
+            case 0x28: rB = WRITE_MEM_8(rIY+d, SRA(READ_MEM_8(rIY+d))); break;
+            case 0x29: rC = WRITE_MEM_8(rIY+d, SRA(READ_MEM_8(rIY+d))); break;
+            case 0x2A: rD = WRITE_MEM_8(rIY+d, SRA(READ_MEM_8(rIY+d))); break;
+            case 0x2B: rE = WRITE_MEM_8(rIY+d, SRA(READ_MEM_8(rIY+d))); break;
+            case 0x2C: rH = WRITE_MEM_8(rIY+d, SRA(READ_MEM_8(rIY+d))); break;
+            case 0x2D: rL = WRITE_MEM_8(rIY+d, SRA(READ_MEM_8(rIY+d))); break;
+            case 0x2E:      WRITE_MEM_8(rIY+d, SRA(READ_MEM_8(rIY+d))); break;
+            case 0x2F: rA = WRITE_MEM_8(rIY+d, SRA(READ_MEM_8(rIY+d))); break;
 
-            case 0x30: SLL(&memory[rIY+d],_rB);         break;
-            case 0x31: SLL(&memory[rIY+d],_rC);         break;
-            case 0x32: SLL(&memory[rIY+d],_rD);         break;
-            case 0x33: SLL(&memory[rIY+d],_rE);         break;
-            case 0x34: SLL(&memory[rIY+d],_rH);         break;
-            case 0x35: SLL(&memory[rIY+d],_rL);         break;
-            case 0x36: SLL(&memory[rIY+d]);             break;
-            case 0x37: SLL(&memory[rIY+d],_rA);         break;
-            case 0x38: SRL(&memory[rIY+d],_rB);         break;
-            case 0x39: SRL(&memory[rIY+d],_rC);         break;
-            case 0x3A: SRL(&memory[rIY+d],_rD);         break;
-            case 0x3B: SRL(&memory[rIY+d],_rE);         break;
-            case 0x3C: SRL(&memory[rIY+d],_rH);         break;
-            case 0x3D: SRL(&memory[rIY+d],_rL);         break;
-            case 0x3E: SRL(&memory[rIY+d]);             break;
-            case 0x3F: SRL(&memory[rIY+d],_rA);         break;
+            case 0x30: rB = WRITE_MEM_8(rIY+d, SLL(READ_MEM_8(rIY+d))); break;
+            case 0x31: rC = WRITE_MEM_8(rIY+d, SLL(READ_MEM_8(rIY+d))); break;
+            case 0x32: rD = WRITE_MEM_8(rIY+d, SLL(READ_MEM_8(rIY+d))); break;
+            case 0x33: rE = WRITE_MEM_8(rIY+d, SLL(READ_MEM_8(rIY+d))); break;
+            case 0x34: rH = WRITE_MEM_8(rIY+d, SLL(READ_MEM_8(rIY+d))); break;
+            case 0x35: rL = WRITE_MEM_8(rIY+d, SLL(READ_MEM_8(rIY+d))); break;
+            case 0x36:      WRITE_MEM_8(rIY+d, SLL(READ_MEM_8(rIY+d))); break;
+            case 0x37: rA = WRITE_MEM_8(rIY+d, SLL(READ_MEM_8(rIY+d))); break;
+            case 0x38: rB = WRITE_MEM_8(rIY+d, SRL(READ_MEM_8(rIY+d))); break;
+            case 0x39: rC = WRITE_MEM_8(rIY+d, SRL(READ_MEM_8(rIY+d))); break;
+            case 0x3A: rD = WRITE_MEM_8(rIY+d, SRL(READ_MEM_8(rIY+d))); break;
+            case 0x3B: rE = WRITE_MEM_8(rIY+d, SRL(READ_MEM_8(rIY+d))); break;
+            case 0x3C: rH = WRITE_MEM_8(rIY+d, SRL(READ_MEM_8(rIY+d))); break;
+            case 0x3D: rL = WRITE_MEM_8(rIY+d, SRL(READ_MEM_8(rIY+d))); break;
+            case 0x3E:      WRITE_MEM_8(rIY+d, SRL(READ_MEM_8(rIY+d))); break;
+            case 0x3F: rA = WRITE_MEM_8(rIY+d, SRL(READ_MEM_8(rIY+d))); break;
 
-            case 0x40: BIT(0, memory[rIY+d]);           break;
-            case 0x41: BIT(0, memory[rIY+d]);           break;
-            case 0x42: BIT(0, memory[rIY+d]);           break;
-            case 0x43: BIT(0, memory[rIY+d]);           break;
-            case 0x44: BIT(0, memory[rIY+d]);           break;
-            case 0x45: BIT(0, memory[rIY+d]);           break;
-            case 0x46: BIT(0, memory[rIY+d]);           break;
-            case 0x47: BIT(0, memory[rIY+d]);           break;
-            case 0x48: BIT(1, memory[rIY+d]);           break;
-            case 0x49: BIT(1, memory[rIY+d]);           break;
-            case 0x4A: BIT(1, memory[rIY+d]);           break;
-            case 0x4B: BIT(1, memory[rIY+d]);           break;
-            case 0x4C: BIT(1, memory[rIY+d]);           break;
-            case 0x4D: BIT(1, memory[rIY+d]);           break;
-            case 0x4E: BIT(1, memory[rIY+d]);           break;
-            case 0x4F: BIT(1, memory[rIY+d]);           break;
+            case 0x40: BIT(0, READ_MEM_8(rIY+d));                       break;
+            case 0x41: BIT(0, READ_MEM_8(rIY+d));                       break;
+            case 0x42: BIT(0, READ_MEM_8(rIY+d));                       break;
+            case 0x43: BIT(0, READ_MEM_8(rIY+d));                       break;
+            case 0x44: BIT(0, READ_MEM_8(rIY+d));                       break;
+            case 0x45: BIT(0, READ_MEM_8(rIY+d));                       break;
+            case 0x46: BIT(0, READ_MEM_8(rIY+d));                       break;
+            case 0x47: BIT(0, READ_MEM_8(rIY+d));                       break;
+            case 0x48: BIT(1, READ_MEM_8(rIY+d));                       break;
+            case 0x49: BIT(1, READ_MEM_8(rIY+d));                       break;
+            case 0x4A: BIT(1, READ_MEM_8(rIY+d));                       break;
+            case 0x4B: BIT(1, READ_MEM_8(rIY+d));                       break;
+            case 0x4C: BIT(1, READ_MEM_8(rIY+d));                       break;
+            case 0x4D: BIT(1, READ_MEM_8(rIY+d));                       break;
+            case 0x4E: BIT(1, READ_MEM_8(rIY+d));                       break;
+            case 0x4F: BIT(1, READ_MEM_8(rIY+d));                       break;
+            
+            case 0x50: BIT(2, READ_MEM_8(rIY+d));                       break;
+            case 0x51: BIT(2, READ_MEM_8(rIY+d));                       break;
+            case 0x52: BIT(2, READ_MEM_8(rIY+d));                       break;
+            case 0x53: BIT(2, READ_MEM_8(rIY+d));                       break;
+            case 0x54: BIT(2, READ_MEM_8(rIY+d));                       break;
+            case 0x55: BIT(2, READ_MEM_8(rIY+d));                       break;
+            case 0x56: BIT(2, READ_MEM_8(rIY+d));                       break;
+            case 0x57: BIT(2, READ_MEM_8(rIY+d));                       break;
+            case 0x58: BIT(3, READ_MEM_8(rIY+d));                       break;
+            case 0x59: BIT(3, READ_MEM_8(rIY+d));                       break;
+            case 0x5A: BIT(3, READ_MEM_8(rIY+d));                       break;
+            case 0x5B: BIT(3, READ_MEM_8(rIY+d));                       break;
+            case 0x5C: BIT(3, READ_MEM_8(rIY+d));                       break;
+            case 0x5D: BIT(3, READ_MEM_8(rIY+d));                       break;
+            case 0x5E: BIT(3, READ_MEM_8(rIY+d));                       break;
+            case 0x5F: BIT(3, READ_MEM_8(rIY+d));                       break;
+            
+            case 0x60: BIT(4, READ_MEM_8(rIY+d));                       break;
+            case 0x61: BIT(4, READ_MEM_8(rIY+d));                       break;
+            case 0x62: BIT(4, READ_MEM_8(rIY+d));                       break;
+            case 0x63: BIT(4, READ_MEM_8(rIY+d));                       break;
+            case 0x64: BIT(4, READ_MEM_8(rIY+d));                       break;
+            case 0x65: BIT(4, READ_MEM_8(rIY+d));                       break;
+            case 0x66: BIT(4, READ_MEM_8(rIY+d));                       break;
+            case 0x67: BIT(4, READ_MEM_8(rIY+d));                       break;
+            case 0x68: BIT(5, READ_MEM_8(rIY+d));                       break;
+            case 0x69: BIT(5, READ_MEM_8(rIY+d));                       break;
+            case 0x6A: BIT(5, READ_MEM_8(rIY+d));                       break;
+            case 0x6B: BIT(5, READ_MEM_8(rIY+d));                       break;
+            case 0x6C: BIT(5, READ_MEM_8(rIY+d));                       break;
+            case 0x6D: BIT(5, READ_MEM_8(rIY+d));                       break;
+            case 0x6E: BIT(5, READ_MEM_8(rIY+d));                       break;
+            case 0x6F: BIT(5, READ_MEM_8(rIY+d));                       break;
+            
+            case 0x70: BIT(6, READ_MEM_8(rIY+d));                       break;
+            case 0x71: BIT(6, READ_MEM_8(rIY+d));                       break;
+            case 0x72: BIT(6, READ_MEM_8(rIY+d));                       break;
+            case 0x73: BIT(6, READ_MEM_8(rIY+d));                       break;
+            case 0x74: BIT(6, READ_MEM_8(rIY+d));                       break;
+            case 0x75: BIT(6, READ_MEM_8(rIY+d));                       break;
+            case 0x76: BIT(6, READ_MEM_8(rIY+d));                       break;
+            case 0x77: BIT(6, READ_MEM_8(rIY+d));                       break;
+            case 0x78: BIT(7, READ_MEM_8(rIY+d));                       break;
+            case 0x79: BIT(7, READ_MEM_8(rIY+d));                       break;
+            case 0x7A: BIT(7, READ_MEM_8(rIY+d));                       break;
+            case 0x7B: BIT(7, READ_MEM_8(rIY+d));                       break;
+            case 0x7C: BIT(7, READ_MEM_8(rIY+d));                       break;
+            case 0x7D: BIT(7, READ_MEM_8(rIY+d));                       break;
+            case 0x7E: BIT(7, READ_MEM_8(rIY+d));                       break;
+            case 0x7F: BIT(7, READ_MEM_8(rIY+d));                       break;
 
-            case 0x50: BIT(2, memory[rIY+d]);           break;
-            case 0x51: BIT(2, memory[rIY+d]);           break;
-            case 0x52: BIT(2, memory[rIY+d]);           break;
-            case 0x53: BIT(2, memory[rIY+d]);           break;
-            case 0x54: BIT(2, memory[rIY+d]);           break;
-            case 0x55: BIT(2, memory[rIY+d]);           break;
-            case 0x56: BIT(2, memory[rIY+d]);           break;
-            case 0x57: BIT(2, memory[rIY+d]);           break;
-            case 0x58: BIT(3, memory[rIY+d]);           break;
-            case 0x59: BIT(3, memory[rIY+d]);           break;
-            case 0x5A: BIT(3, memory[rIY+d]);           break;
-            case 0x5B: BIT(3, memory[rIY+d]);           break;
-            case 0x5C: BIT(3, memory[rIY+d]);           break;
-            case 0x5D: BIT(3, memory[rIY+d]);           break;
-            case 0x5E: BIT(3, memory[rIY+d]);           break;
-            case 0x5F: BIT(3, memory[rIY+d]);           break;
+            case 0x80: rB = WRITE_MEM_8(rIY+d, RES(0, READ_MEM_8(rIY+d))); break;
+            case 0x81: rC = WRITE_MEM_8(rIY+d, RES(0, READ_MEM_8(rIY+d))); break;
+            case 0x82: rD = WRITE_MEM_8(rIY+d, RES(0, READ_MEM_8(rIY+d))); break;
+            case 0x83: rE = WRITE_MEM_8(rIY+d, RES(0, READ_MEM_8(rIY+d))); break;
+            case 0x84: rH = WRITE_MEM_8(rIY+d, RES(0, READ_MEM_8(rIY+d))); break;
+            case 0x85: rL = WRITE_MEM_8(rIY+d, RES(0, READ_MEM_8(rIY+d))); break;
+            case 0x86:      WRITE_MEM_8(rIY+d, RES(0, READ_MEM_8(rIY+d))); break;
+            case 0x87: rA = WRITE_MEM_8(rIY+d, RES(0, READ_MEM_8(rIY+d))); break;
+            case 0x88: rB = WRITE_MEM_8(rIY+d, RES(1, READ_MEM_8(rIY+d))); break;
+            case 0x89: rC = WRITE_MEM_8(rIY+d, RES(1, READ_MEM_8(rIY+d))); break;
+            case 0x8A: rD = WRITE_MEM_8(rIY+d, RES(1, READ_MEM_8(rIY+d))); break;
+            case 0x8B: rE = WRITE_MEM_8(rIY+d, RES(1, READ_MEM_8(rIY+d))); break;
+            case 0x8C: rH = WRITE_MEM_8(rIY+d, RES(1, READ_MEM_8(rIY+d))); break;
+            case 0x8D: rL = WRITE_MEM_8(rIY+d, RES(1, READ_MEM_8(rIY+d))); break;
+            case 0x8E:      WRITE_MEM_8(rIY+d, RES(1, READ_MEM_8(rIY+d))); break;
+            case 0x8F: rA = WRITE_MEM_8(rIY+d, RES(1, READ_MEM_8(rIY+d))); break;
 
-            case 0x60: BIT(4, memory[rIY+d]);           break;
-            case 0x61: BIT(4, memory[rIY+d]);           break;
-            case 0x62: BIT(4, memory[rIY+d]);           break;
-            case 0x63: BIT(4, memory[rIY+d]);           break;
-            case 0x64: BIT(4, memory[rIY+d]);           break;
-            case 0x65: BIT(4, memory[rIY+d]);           break;
-            case 0x66: BIT(4, memory[rIY+d]);           break;
-            case 0x67: BIT(4, memory[rIY+d]);           break;
-            case 0x68: BIT(5, memory[rIY+d]);           break;
-            case 0x69: BIT(5, memory[rIY+d]);           break;
-            case 0x6A: BIT(5, memory[rIY+d]);           break;
-            case 0x6B: BIT(5, memory[rIY+d]);           break;
-            case 0x6C: BIT(5, memory[rIY+d]);           break;
-            case 0x6D: BIT(5, memory[rIY+d]);           break;
-            case 0x6E: BIT(5, memory[rIY+d]);           break;
-            case 0x6F: BIT(5, memory[rIY+d]);           break;
+            case 0x90: rB = WRITE_MEM_8(rIY+d, RES(2, READ_MEM_8(rIY+d))); break;
+            case 0x91: rC = WRITE_MEM_8(rIY+d, RES(2, READ_MEM_8(rIY+d))); break;
+            case 0x92: rD = WRITE_MEM_8(rIY+d, RES(2, READ_MEM_8(rIY+d))); break;
+            case 0x93: rE = WRITE_MEM_8(rIY+d, RES(2, READ_MEM_8(rIY+d))); break;
+            case 0x94: rH = WRITE_MEM_8(rIY+d, RES(2, READ_MEM_8(rIY+d))); break;
+            case 0x95: rL = WRITE_MEM_8(rIY+d, RES(2, READ_MEM_8(rIY+d))); break;
+            case 0x96:      WRITE_MEM_8(rIY+d, RES(2, READ_MEM_8(rIY+d))); break;
+            case 0x97: rA = WRITE_MEM_8(rIY+d, RES(2, READ_MEM_8(rIY+d))); break;
+            case 0x98: rB = WRITE_MEM_8(rIY+d, RES(3, READ_MEM_8(rIY+d))); break;
+            case 0x99: rC = WRITE_MEM_8(rIY+d, RES(3, READ_MEM_8(rIY+d))); break;
+            case 0x9A: rD = WRITE_MEM_8(rIY+d, RES(3, READ_MEM_8(rIY+d))); break;
+            case 0x9B: rE = WRITE_MEM_8(rIY+d, RES(3, READ_MEM_8(rIY+d))); break;
+            case 0x9C: rH = WRITE_MEM_8(rIY+d, RES(3, READ_MEM_8(rIY+d))); break;
+            case 0x9D: rL = WRITE_MEM_8(rIY+d, RES(3, READ_MEM_8(rIY+d))); break;
+            case 0x9E:      WRITE_MEM_8(rIY+d, RES(3, READ_MEM_8(rIY+d))); break;
+            case 0x9F: rA = WRITE_MEM_8(rIY+d, RES(3, READ_MEM_8(rIY+d))); break;
 
-            case 0x70: BIT(6, memory[rIY+d]);           break;
-            case 0x71: BIT(6, memory[rIY+d]);           break;
-            case 0x72: BIT(6, memory[rIY+d]);           break;
-            case 0x73: BIT(6, memory[rIY+d]);           break;
-            case 0x74: BIT(6, memory[rIY+d]);           break;
-            case 0x75: BIT(6, memory[rIY+d]);           break;
-            case 0x76: BIT(6, memory[rIY+d]);           break;
-            case 0x77: BIT(6, memory[rIY+d]);           break;
-            case 0x78: BIT(7, memory[rIY+d]);           break;
-            case 0x79: BIT(7, memory[rIY+d]);           break;
-            case 0x7A: BIT(7, memory[rIY+d]);           break;
-            case 0x7B: BIT(7, memory[rIY+d]);           break;
-            case 0x7C: BIT(7, memory[rIY+d]);           break;
-            case 0x7D: BIT(7, memory[rIY+d]);           break;
-            case 0x7E: BIT(7, memory[rIY+d]);           break;
-            case 0x7F: BIT(7, memory[rIY+d]);           break;
+            case 0xA0: rB = WRITE_MEM_8(rIY+d, RES(4, READ_MEM_8(rIY+d))); break;
+            case 0xA1: rC = WRITE_MEM_8(rIY+d, RES(4, READ_MEM_8(rIY+d))); break;
+            case 0xA2: rD = WRITE_MEM_8(rIY+d, RES(4, READ_MEM_8(rIY+d))); break;
+            case 0xA3: rE = WRITE_MEM_8(rIY+d, RES(4, READ_MEM_8(rIY+d))); break;
+            case 0xA4: rH = WRITE_MEM_8(rIY+d, RES(4, READ_MEM_8(rIY+d))); break;
+            case 0xA5: rL = WRITE_MEM_8(rIY+d, RES(4, READ_MEM_8(rIY+d))); break;
+            case 0xA6:      WRITE_MEM_8(rIY+d, RES(4, READ_MEM_8(rIY+d))); break;
+            case 0xA7: rA = WRITE_MEM_8(rIY+d, RES(4, READ_MEM_8(rIY+d))); break;
+            case 0xA8: rB = WRITE_MEM_8(rIY+d, RES(5, READ_MEM_8(rIY+d))); break;
+            case 0xA9: rC = WRITE_MEM_8(rIY+d, RES(5, READ_MEM_8(rIY+d))); break;
+            case 0xAA: rD = WRITE_MEM_8(rIY+d, RES(5, READ_MEM_8(rIY+d))); break;
+            case 0xAB: rE = WRITE_MEM_8(rIY+d, RES(5, READ_MEM_8(rIY+d))); break;
+            case 0xAC: rH = WRITE_MEM_8(rIY+d, RES(5, READ_MEM_8(rIY+d))); break;
+            case 0xAD: rL = WRITE_MEM_8(rIY+d, RES(5, READ_MEM_8(rIY+d))); break;
+            case 0xAE:      WRITE_MEM_8(rIY+d, RES(5, READ_MEM_8(rIY+d))); break;
+            case 0xAF: rA = WRITE_MEM_8(rIY+d, RES(5, READ_MEM_8(rIY+d))); break;
 
-            case 0x80: RES(0, &memory[rIY+d], _rB);     break;
-            case 0x81: RES(0, &memory[rIY+d], _rC);     break;
-            case 0x82: RES(0, &memory[rIY+d], _rD);     break;
-            case 0x83: RES(0, &memory[rIY+d], _rE);     break;
-            case 0x84: RES(0, &memory[rIY+d], _rH);     break;
-            case 0x85: RES(0, &memory[rIY+d], _rL);     break;
-            case 0x86: RES(0, &memory[rIY+d]);          break;
-            case 0x87: RES(0, &memory[rIY+d], _rA);     break;
-            case 0x88: RES(1, &memory[rIY+d], _rB);     break;
-            case 0x89: RES(1, &memory[rIY+d], _rC);     break;
-            case 0x8A: RES(1, &memory[rIY+d], _rD);     break;
-            case 0x8B: RES(1, &memory[rIY+d], _rE);     break;
-            case 0x8C: RES(1, &memory[rIY+d], _rH);     break;
-            case 0x8D: RES(1, &memory[rIY+d], _rL);     break;
-            case 0x8E: RES(1, &memory[rIY+d]);          break;
-            case 0x8F: RES(1, &memory[rIY+d], _rA);     break;
+            case 0xB0: rB = WRITE_MEM_8(rIY+d, RES(6, READ_MEM_8(rIY+d))); break;
+            case 0xB1: rC = WRITE_MEM_8(rIY+d, RES(6, READ_MEM_8(rIY+d))); break;
+            case 0xB2: rD = WRITE_MEM_8(rIY+d, RES(6, READ_MEM_8(rIY+d))); break;
+            case 0xB3: rE = WRITE_MEM_8(rIY+d, RES(6, READ_MEM_8(rIY+d))); break;
+            case 0xB4: rH = WRITE_MEM_8(rIY+d, RES(6, READ_MEM_8(rIY+d))); break;
+            case 0xB5: rL = WRITE_MEM_8(rIY+d, RES(6, READ_MEM_8(rIY+d))); break;
+            case 0xB6:      WRITE_MEM_8(rIY+d, RES(6, READ_MEM_8(rIY+d))); break;
+            case 0xB7: rA = WRITE_MEM_8(rIY+d, RES(6, READ_MEM_8(rIY+d))); break;
+            case 0xB8: rB = WRITE_MEM_8(rIY+d, RES(7, READ_MEM_8(rIY+d))); break;
+            case 0xB9: rC = WRITE_MEM_8(rIY+d, RES(7, READ_MEM_8(rIY+d))); break;
+            case 0xBA: rD = WRITE_MEM_8(rIY+d, RES(7, READ_MEM_8(rIY+d))); break;
+            case 0xBB: rE = WRITE_MEM_8(rIY+d, RES(7, READ_MEM_8(rIY+d))); break;
+            case 0xBC: rH = WRITE_MEM_8(rIY+d, RES(7, READ_MEM_8(rIY+d))); break;
+            case 0xBD: rL = WRITE_MEM_8(rIY+d, RES(7, READ_MEM_8(rIY+d))); break;
+            case 0xBE:      WRITE_MEM_8(rIY+d, RES(7, READ_MEM_8(rIY+d))); break;
+            case 0xBF: rA = WRITE_MEM_8(rIY+d, RES(7, READ_MEM_8(rIY+d))); break;
 
-            case 0x90: RES(2, &memory[rIY+d], _rB);     break;
-            case 0x91: RES(2, &memory[rIY+d], _rC);     break;
-            case 0x92: RES(2, &memory[rIY+d], _rD);     break;
-            case 0x93: RES(2, &memory[rIY+d], _rE);     break;
-            case 0x94: RES(2, &memory[rIY+d], _rH);     break;
-            case 0x95: RES(2, &memory[rIY+d], _rL);     break;
-            case 0x96: RES(2, &memory[rIY+d]);          break;
-            case 0x97: RES(2, &memory[rIY+d], _rA);     break;
-            case 0x98: RES(3, &memory[rIY+d], _rB);     break;
-            case 0x99: RES(3, &memory[rIY+d], _rC);     break;
-            case 0x9A: RES(3, &memory[rIY+d], _rD);     break;
-            case 0x9B: RES(3, &memory[rIY+d], _rE);     break;
-            case 0x9C: RES(3, &memory[rIY+d], _rH);     break;
-            case 0x9D: RES(3, &memory[rIY+d], _rL);     break;
-            case 0x9E: RES(3, &memory[rIY+d]);          break;
-            case 0x9F: RES(3, &memory[rIY+d], _rA);     break;
+            case 0xC0: rB = WRITE_MEM_8(rIY+d, SET(0, READ_MEM_8(rIY+d))); break;
+            case 0xC1: rC = WRITE_MEM_8(rIY+d, SET(0, READ_MEM_8(rIY+d))); break;
+            case 0xC2: rD = WRITE_MEM_8(rIY+d, SET(0, READ_MEM_8(rIY+d))); break;
+            case 0xC3: rE = WRITE_MEM_8(rIY+d, SET(0, READ_MEM_8(rIY+d))); break;
+            case 0xC4: rH = WRITE_MEM_8(rIY+d, SET(0, READ_MEM_8(rIY+d))); break;
+            case 0xC5: rL = WRITE_MEM_8(rIY+d, SET(0, READ_MEM_8(rIY+d))); break;
+            case 0xC6:      WRITE_MEM_8(rIY+d, SET(0, READ_MEM_8(rIY+d))); break;
+            case 0xC7: rA = WRITE_MEM_8(rIY+d, SET(0, READ_MEM_8(rIY+d))); break;
+            case 0xC8: rB = WRITE_MEM_8(rIY+d, SET(1, READ_MEM_8(rIY+d))); break;
+            case 0xC9: rC = WRITE_MEM_8(rIY+d, SET(1, READ_MEM_8(rIY+d))); break;
+            case 0xCA: rD = WRITE_MEM_8(rIY+d, SET(1, READ_MEM_8(rIY+d))); break;
+            case 0xCB: rE = WRITE_MEM_8(rIY+d, SET(1, READ_MEM_8(rIY+d))); break;
+            case 0xCC: rH = WRITE_MEM_8(rIY+d, SET(1, READ_MEM_8(rIY+d))); break;
+            case 0xCD: rL = WRITE_MEM_8(rIY+d, SET(1, READ_MEM_8(rIY+d))); break;
+            case 0xCE:      WRITE_MEM_8(rIY+d, SET(1, READ_MEM_8(rIY+d))); break;
+            case 0xCF: rA = WRITE_MEM_8(rIY+d, SET(1, READ_MEM_8(rIY+d))); break;
 
-            case 0xA0: RES(4, &memory[rIY+d], _rB);     break;
-            case 0xA1: RES(4, &memory[rIY+d], _rC);     break;
-            case 0xA2: RES(4, &memory[rIY+d], _rD);     break;
-            case 0xA3: RES(4, &memory[rIY+d], _rE);     break;
-            case 0xA4: RES(4, &memory[rIY+d], _rH);     break;
-            case 0xA5: RES(4, &memory[rIY+d], _rL);     break;
-            case 0xA6: RES(4, &memory[rIY+d]);          break;
-            case 0xA7: RES(4, &memory[rIY+d], _rA);     break;
-            case 0xA8: RES(5, &memory[rIY+d], _rB);     break;
-            case 0xA9: RES(5, &memory[rIY+d], _rC);     break;
-            case 0xAA: RES(5, &memory[rIY+d], _rD);     break;
-            case 0xAB: RES(5, &memory[rIY+d], _rE);     break;
-            case 0xAC: RES(5, &memory[rIY+d], _rH);     break;
-            case 0xAD: RES(5, &memory[rIY+d], _rL);     break;
-            case 0xAE: RES(5, &memory[rIY+d]);          break;
-            case 0xAF: RES(5, &memory[rIY+d], _rA);     break;
+            case 0xD0: rB = WRITE_MEM_8(rIY+d, SET(2, READ_MEM_8(rIY+d))); break;
+            case 0xD1: rC = WRITE_MEM_8(rIY+d, SET(2, READ_MEM_8(rIY+d))); break;
+            case 0xD2: rD = WRITE_MEM_8(rIY+d, SET(2, READ_MEM_8(rIY+d))); break;
+            case 0xD3: rE = WRITE_MEM_8(rIY+d, SET(2, READ_MEM_8(rIY+d))); break;
+            case 0xD4: rH = WRITE_MEM_8(rIY+d, SET(2, READ_MEM_8(rIY+d))); break;
+            case 0xD5: rL = WRITE_MEM_8(rIY+d, SET(2, READ_MEM_8(rIY+d))); break;
+            case 0xD6:      WRITE_MEM_8(rIY+d, SET(2, READ_MEM_8(rIY+d))); break;
+            case 0xD7: rA = WRITE_MEM_8(rIY+d, SET(2, READ_MEM_8(rIY+d))); break;
+            case 0xD8: rB = WRITE_MEM_8(rIY+d, SET(3, READ_MEM_8(rIY+d))); break;
+            case 0xD9: rC = WRITE_MEM_8(rIY+d, SET(3, READ_MEM_8(rIY+d))); break;
+            case 0xDA: rD = WRITE_MEM_8(rIY+d, SET(3, READ_MEM_8(rIY+d))); break;
+            case 0xDB: rE = WRITE_MEM_8(rIY+d, SET(3, READ_MEM_8(rIY+d))); break;
+            case 0xDC: rH = WRITE_MEM_8(rIY+d, SET(3, READ_MEM_8(rIY+d))); break;
+            case 0xDD: rL = WRITE_MEM_8(rIY+d, SET(3, READ_MEM_8(rIY+d))); break;
+            case 0xDE:      WRITE_MEM_8(rIY+d, SET(3, READ_MEM_8(rIY+d))); break;
+            case 0xDF: rA = WRITE_MEM_8(rIY+d, SET(3, READ_MEM_8(rIY+d))); break;
 
-            case 0xB0: RES(6, &memory[rIY+d], _rB);     break;
-            case 0xB1: RES(6, &memory[rIY+d], _rC);     break;
-            case 0xB2: RES(6, &memory[rIY+d], _rD);     break;
-            case 0xB3: RES(6, &memory[rIY+d], _rE);     break;
-            case 0xB4: RES(6, &memory[rIY+d], _rH);     break;
-            case 0xB5: RES(6, &memory[rIY+d], _rL);     break;
-            case 0xB6: RES(6, &memory[rIY+d]);          break;
-            case 0xB7: RES(6, &memory[rIY+d], _rA);     break;
-            case 0xB8: RES(7, &memory[rIY+d], _rB);     break;
-            case 0xB9: RES(7, &memory[rIY+d], _rC);     break;
-            case 0xBA: RES(7, &memory[rIY+d], _rD);     break;
-            case 0xBB: RES(7, &memory[rIY+d], _rE);     break;
-            case 0xBC: RES(7, &memory[rIY+d], _rH);     break;
-            case 0xBD: RES(7, &memory[rIY+d], _rL);     break;
-            case 0xBE: RES(7, &memory[rIY+d]);          break;
-            case 0xBF: RES(7, &memory[rIY+d], _rA);     break;
+            case 0xE0: rB = WRITE_MEM_8(rIY+d, SET(4, READ_MEM_8(rIY+d))); break;
+            case 0xE1: rC = WRITE_MEM_8(rIY+d, SET(4, READ_MEM_8(rIY+d))); break;
+            case 0xE2: rD = WRITE_MEM_8(rIY+d, SET(4, READ_MEM_8(rIY+d))); break;
+            case 0xE3: rE = WRITE_MEM_8(rIY+d, SET(4, READ_MEM_8(rIY+d))); break;
+            case 0xE4: rH = WRITE_MEM_8(rIY+d, SET(4, READ_MEM_8(rIY+d))); break;
+            case 0xE5: rL = WRITE_MEM_8(rIY+d, SET(4, READ_MEM_8(rIY+d))); break;
+            case 0xE6:      WRITE_MEM_8(rIY+d, SET(4, READ_MEM_8(rIY+d))); break;
+            case 0xE7: rA = WRITE_MEM_8(rIY+d, SET(4, READ_MEM_8(rIY+d))); break;
+            case 0xE8: rB = WRITE_MEM_8(rIY+d, SET(5, READ_MEM_8(rIY+d))); break;
+            case 0xE9: rC = WRITE_MEM_8(rIY+d, SET(5, READ_MEM_8(rIY+d))); break;
+            case 0xEA: rD = WRITE_MEM_8(rIY+d, SET(5, READ_MEM_8(rIY+d))); break;
+            case 0xEB: rE = WRITE_MEM_8(rIY+d, SET(5, READ_MEM_8(rIY+d))); break;
+            case 0xEC: rH = WRITE_MEM_8(rIY+d, SET(5, READ_MEM_8(rIY+d))); break;
+            case 0xED: rL = WRITE_MEM_8(rIY+d, SET(5, READ_MEM_8(rIY+d))); break;
+            case 0xEE:      WRITE_MEM_8(rIY+d, SET(5, READ_MEM_8(rIY+d))); break;
+            case 0xEF: rA = WRITE_MEM_8(rIY+d, SET(5, READ_MEM_8(rIY+d))); break;
 
-            case 0xC0: SET(0, &memory[rIY+d], _rB);     break;
-            case 0xC1: SET(0, &memory[rIY+d], _rC);     break;
-            case 0xC2: SET(0, &memory[rIY+d], _rD);     break;
-            case 0xC3: SET(0, &memory[rIY+d], _rE);     break;
-            case 0xC4: SET(0, &memory[rIY+d], _rH);     break;
-            case 0xC5: SET(0, &memory[rIY+d], _rL);     break;
-            case 0xC6: SET(0, &memory[rIY+d]);          break;
-            case 0xC7: SET(0, &memory[rIY+d], _rA);     break;
-            case 0xC8: SET(1, &memory[rIY+d], _rB);     break;
-            case 0xC9: SET(1, &memory[rIY+d], _rC);     break;
-            case 0xCA: SET(1, &memory[rIY+d], _rD);     break;
-            case 0xCB: SET(1, &memory[rIY+d], _rE);     break;
-            case 0xCC: SET(1, &memory[rIY+d], _rH);     break;
-            case 0xCD: SET(1, &memory[rIY+d], _rL);     break;
-            case 0xCE: SET(1, &memory[rIY+d]);          break;
-            case 0xCF: SET(1, &memory[rIY+d], _rA);     break;
-
-            case 0xD0: SET(2, &memory[rIY+d], _rB);     break;
-            case 0xD1: SET(2, &memory[rIY+d], _rC);     break;
-            case 0xD2: SET(2, &memory[rIY+d], _rD);     break;
-            case 0xD3: SET(2, &memory[rIY+d], _rE);     break;
-            case 0xD4: SET(2, &memory[rIY+d], _rH);     break;
-            case 0xD5: SET(2, &memory[rIY+d], _rL);     break;
-            case 0xD6: SET(2, &memory[rIY+d]);          break;
-            case 0xD7: SET(2, &memory[rIY+d], _rA);     break;
-            case 0xD8: SET(3, &memory[rIY+d], _rB);     break;
-            case 0xD9: SET(3, &memory[rIY+d], _rC);     break;
-            case 0xDA: SET(3, &memory[rIY+d], _rD);     break;
-            case 0xDB: SET(3, &memory[rIY+d], _rE);     break;
-            case 0xDC: SET(3, &memory[rIY+d], _rH);     break;
-            case 0xDD: SET(3, &memory[rIY+d], _rL);     break;
-            case 0xDE: SET(3, &memory[rIY+d]);          break;
-            case 0xDF: SET(3, &memory[rIY+d], _rA);     break;
-
-            case 0xE0: SET(4, &memory[rIY+d], _rB);     break;
-            case 0xE1: SET(4, &memory[rIY+d], _rC);     break;
-            case 0xE2: SET(4, &memory[rIY+d], _rD);     break;
-            case 0xE3: SET(4, &memory[rIY+d], _rE);     break;
-            case 0xE4: SET(4, &memory[rIY+d], _rH);     break;
-            case 0xE5: SET(4, &memory[rIY+d], _rL);     break;
-            case 0xE6: SET(4, &memory[rIY+d]);          break;
-            case 0xE7: SET(4, &memory[rIY+d], _rA);     break;
-            case 0xE8: SET(5, &memory[rIY+d], _rB);     break;
-            case 0xE9: SET(5, &memory[rIY+d], _rC);     break;
-            case 0xEA: SET(5, &memory[rIY+d], _rD);     break;
-            case 0xEB: SET(5, &memory[rIY+d], _rE);     break;
-            case 0xEC: SET(5, &memory[rIY+d], _rH);     break;
-            case 0xED: SET(5, &memory[rIY+d], _rL);     break;
-            case 0xEE: SET(5, &memory[rIY+d]);          break;
-            case 0xEF: SET(5, &memory[rIY+d], _rA);     break;
-
-            case 0xF0: SET(6, &memory[rIY+d], _rB);     break;
-            case 0xF1: SET(6, &memory[rIY+d], _rC);     break;
-            case 0xF2: SET(6, &memory[rIY+d], _rD);     break;
-            case 0xF3: SET(6, &memory[rIY+d], _rE);     break;
-            case 0xF4: SET(6, &memory[rIY+d], _rH);     break;
-            case 0xF5: SET(6, &memory[rIY+d], _rL);     break;
-            case 0xF6: SET(6, &memory[rIY+d]);          break;
-            case 0xF7: SET(6, &memory[rIY+d], _rA);     break;
-            case 0xF8: SET(7, &memory[rIY+d], _rB);     break;
-            case 0xF9: SET(7, &memory[rIY+d], _rC);     break;
-            case 0xFA: SET(7, &memory[rIY+d], _rD);     break;
-            case 0xFB: SET(7, &memory[rIY+d], _rE);     break;
-            case 0xFC: SET(7, &memory[rIY+d], _rH);     break;
-            case 0xFD: SET(7, &memory[rIY+d], _rL);     break;
-            case 0xFE: SET(7, &memory[rIY+d]);          break;
-            case 0xFF: SET(7, &memory[rIY+d], _rA);     break;
+            case 0xF0: rB = WRITE_MEM_8(rIY+d, SET(6, READ_MEM_8(rIY+d))); break;
+            case 0xF1: rC = WRITE_MEM_8(rIY+d, SET(6, READ_MEM_8(rIY+d))); break;
+            case 0xF2: rD = WRITE_MEM_8(rIY+d, SET(6, READ_MEM_8(rIY+d))); break;
+            case 0xF3: rE = WRITE_MEM_8(rIY+d, SET(6, READ_MEM_8(rIY+d))); break;
+            case 0xF4: rH = WRITE_MEM_8(rIY+d, SET(6, READ_MEM_8(rIY+d))); break;
+            case 0xF5: rL = WRITE_MEM_8(rIY+d, SET(6, READ_MEM_8(rIY+d))); break;
+            case 0xF6:      WRITE_MEM_8(rIY+d, SET(6, READ_MEM_8(rIY+d))); break;
+            case 0xF7: rA = WRITE_MEM_8(rIY+d, SET(6, READ_MEM_8(rIY+d))); break;
+            case 0xF8: rB = WRITE_MEM_8(rIY+d, SET(7, READ_MEM_8(rIY+d))); break;
+            case 0xF9: rC = WRITE_MEM_8(rIY+d, SET(7, READ_MEM_8(rIY+d))); break;
+            case 0xFA: rD = WRITE_MEM_8(rIY+d, SET(7, READ_MEM_8(rIY+d))); break;
+            case 0xFB: rE = WRITE_MEM_8(rIY+d, SET(7, READ_MEM_8(rIY+d))); break;
+            case 0xFC: rH = WRITE_MEM_8(rIY+d, SET(7, READ_MEM_8(rIY+d))); break;
+            case 0xFD: rL = WRITE_MEM_8(rIY+d, SET(7, READ_MEM_8(rIY+d))); break;
+            case 0xFE:      WRITE_MEM_8(rIY+d, SET(7, READ_MEM_8(rIY+d))); break;
+            case 0xFF: rA = WRITE_MEM_8(rIY+d, SET(7, READ_MEM_8(rIY+d))); break;
         }
     }