From 66d9d0286f9471391db22b9dcd4525359a9a6b43 Mon Sep 17 00:00:00 2001 From: Raimon Zamora Date: Wed, 13 Mar 2024 13:24:18 +0100 Subject: [PATCH] - Implementades les tables Main, Bit, IX i IX Bit --- z80.cpp | 1203 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 1199 insertions(+), 4 deletions(-) diff --git a/z80.cpp b/z80.cpp index ed704e0..bcc32cc 100644 --- a/z80.cpp +++ b/z80.cpp @@ -5,6 +5,9 @@ namespace z80 static uint8_t *memory = nullptr; static uint32_t t_states = 0; + #define _rM16(a) (uint16_t*)&memory[a] + #define rM16(a) *_rM16(a) + #define fC 0b00000001 #define fN 0b00000010 #define fP 0b00000100 @@ -55,8 +58,13 @@ namespace z80 uint16_t *_rDE2 = (uint16_t*)®s[12]; uint16_t *_rHL2 = (uint16_t*)®s[14]; + uint8_t *_rIXL = ®s[16]; + uint8_t *_rIXH = ®s[17]; + uint8_t *_rIYL = ®s[18]; + uint8_t *_rIYH = ®s[19]; uint16_t *_rIX = (uint16_t*)®s[16]; uint16_t *_rIY = (uint16_t*)®s[18]; + uint16_t *_rSP = (uint16_t*)®s[20]; uint8_t *_rI = ®s[22]; @@ -99,6 +107,10 @@ namespace z80 #define rDE2 (*_rDE2) #define rHL2 (*_rHL2) + #define rIXH (*_rIXH) + #define rIXL (*_rIXL) + #define rIYH (*_rIYH) + #define rIYL (*_rIYL) #define rIX (*_rIX) #define rIY (*_rIY) #define rSP (*_rSP) @@ -115,6 +127,19 @@ namespace z80 return memory[rPC++] + memory[rPC++] << 8; } + void PUSH(uint16_t b) + { + memory[rSP-2] = b & 0xff; + memory[rSP-1] = (b >> 8) & 0xff; + rSP-=2; + } + + void POP(uint16_t *a) + { + *a = memory[rSP] + (memory[rSP+1] << 8); + rSP+=2; + } + uint16_t LD8() { return memory[rPC++]; @@ -130,6 +155,12 @@ namespace z80 reg--; } + void ADD16(uint16_t* a, uint16_t b) + { + // [TODO] operadors mes grans, per a no perdre el carry_out + *a = *a + b; + } + void INC8(uint8_t *reg) { reg++; @@ -140,6 +171,52 @@ namespace z80 reg--; } + void ADD8(uint8_t* a, uint8_t b) + { + // [TODO] operadors mes grans, per a no perdre el carry_out + *a = *a + b; + } + + void ADC8(uint8_t* a, uint8_t b) + { + // [TODO] operadors mes grans, per a no perdre el carry_out + *a = *a + b; + if (rF & fC) *a++; + } + + void SUB8(uint8_t b) + { + // [TODO] operadors mes grans, per a no perdre el carry_out + rA = rA - b; + } + + void SBC8(uint8_t* a, uint8_t b) + { + // [TODO] operadors mes grans, per a no perdre el carry_out + *a = *a - b; + if (rF & fC) *a--; + } + + void AND(uint8_t b) + { + rA = rA & b; + } + + void XOR(uint8_t b) + { + rA = rA ^ b; + } + + void OR(uint8_t b) + { + rA = rA & b; + } + + void CP(uint8_t b) + { + rA = rA ^ b; + } + void RLCA() { // [TODO] @@ -170,9 +247,14 @@ namespace z80 // [TODO] } - void ADD16(uint16_t* a, uint16_t b) + void SCF() { - *a = *a + b; + // [TODO] + } + + void CCF() + { + // [TODO] } void DJNZ() @@ -185,6 +267,111 @@ namespace z80 // [TODO] } + void JP(uint8_t cond, int8_t disp) + { + // [TODO] + } + + void CALL(uint8_t cond, int8_t disp) + { + // [TODO] + } + + void RET(uint8_t cond) + { + // [TODO] + } + + void RST(uint8_t vec) + { + // [TODO] + } + + void IN(uint8_t *dir, uint8_t val) + { + // [TODO] + } + + void OUT(uint8_t dir, uint8_t val) + { + // [TODO] + } + + void DI() + { + // [TODO] + } + + void EI() + { + // [TODO] + } + + void HALT() + { + // [TODO] + } + + void RLC(uint8_t *v, uint8_t *r=nullptr) + { + // [TODO] + } + + void RRC(uint8_t *v, uint8_t *r=nullptr) + { + // [TODO] + } + + void RL(uint8_t *v, uint8_t *r=nullptr) + { + // [TODO] + } + + void RR(uint8_t *v, uint8_t *r=nullptr) + { + // [TODO] + } + + void SLA(uint8_t *v, uint8_t *r=nullptr) + { + // [TODO] + } + + void SRA(uint8_t *v, uint8_t *r=nullptr) + { + // [TODO] + } + + void SLL(uint8_t *v, uint8_t *r=nullptr) + { + // [TODO] + } + + void SRL(uint8_t *v, uint8_t *r=nullptr) + { + // [TODO] + } + + void BIT(uint8_t pos, uint8_t v) + { + // [TODO] + } + + void SET(uint8_t pos, uint8_t *v, uint8_t *r=nullptr) + { + // [TODO] + } + + void RES(uint8_t pos, uint8_t *v, uint8_t *r=nullptr) + { + // [TODO] + } + + void INVALID() + { + // [TODO] + } + void reset(uint8_t* mem) { memory = mem; @@ -192,6 +379,12 @@ namespace z80 t_states = 0; } + void BIT_INSTRUCTIONS(); + void IX_INSTRUCTIONS(); + void IX_BIT_INSTRUCTIONS(); + void MISC_INSTRUCTIONS(); + void IY_INSTRUCTIONS(); + void step() { const uint8_t opcode = memory[rPC++]; @@ -236,7 +429,7 @@ namespace z80 case 0x20: JR(cNZ, int8_t(rD)); break; case 0x21: rHL = LD16(); break; - case 0x22: tmp=LD16(); memory[tmp] = rL; memory[tmp+1] = rH; break; + case 0x22: rM16(LD16()) = rHL; break; case 0x23: INC16(_rHL); break; case 0x24: INC8(_rH); break; case 0x25: DEC8(_rH); break; @@ -244,13 +437,1015 @@ namespace z80 case 0x27: DAA(); break; case 0x28: JR(cZ, int8_t(rD)); break; case 0x29: ADD16(_rHL, rHL); break; - case 0x2A: tmp=LD16(); rL = memory[tmp]; rH = memory[tmp+1]; break; + case 0x2A: rHL = rM16(LD16()); break; case 0x2B: DEC16(_rHL); break; case 0x2C: INC8(_rL); break; case 0x2D: DEC8(_rL); break; case 0x2E: rL = LD8(); break; case 0x2F: CPL(); break; + case 0x30: JR(cNC, int8_t(rD)); break; + case 0x31: rSP = LD16(); break; + case 0x32: memory[LD16()] = rA; break; + case 0x33: INC16(_rSP); break; + case 0x34: INC8(&memory[rHL]); break; + case 0x35: DEC8(&memory[rHL]); break; + case 0x36: memory[rHL] = LD8(); break; + case 0x37: SCF(); break; + case 0x38: JR(cC, int8_t(rD)); break; + case 0x39: ADD16(_rHL, rSP); break; + case 0x3A: rA = memory[LD16()]; break; + case 0x3B: DEC16(_rSP); break; + case 0x3C: INC8(_rA); break; + case 0x3D: DEC8(_rA); break; + case 0x3E: rA = LD8(); break; + case 0x3F: CCF(); break; + + case 0x40: rB = rB; break; + case 0x41: rB = rC; break; + case 0x42: rB = rD; break; + case 0x43: rB = rE; break; + case 0x44: rB = rH; break; + case 0x45: rB = rL; break; + case 0x46: rB = memory[rHL]; break; + case 0x47: rB = rA; break; + case 0x48: rC = rB; break; + case 0x49: rC = rC; break; + case 0x4A: rC = rD; break; + case 0x4B: rC = rE; break; + case 0x4C: rC = rH; break; + case 0x4D: rC = rL; break; + case 0x4E: rC = memory[rHL]; break; + case 0x4F: rC = rA; break; + + case 0x50: rD = rB; break; + case 0x51: rD = rC; break; + case 0x52: rD = rD; break; + case 0x53: rD = rE; break; + case 0x54: rD = rH; break; + case 0x55: rD = rL; break; + case 0x56: rD = memory[rHL]; break; + case 0x57: rD = rA; break; + case 0x58: rE = rB; break; + case 0x59: rE = rC; break; + case 0x5A: rE = rD; break; + case 0x5B: rE = rE; break; + case 0x5C: rE = rH; break; + case 0x5D: rE = rL; break; + case 0x5E: rE = memory[rHL]; break; + case 0x5F: rE = rA; break; + + case 0x60: rH = rB; break; + case 0x61: rH = rC; break; + case 0x62: rH = rD; break; + case 0x63: rH = rE; break; + case 0x64: rH = rH; break; + case 0x65: rH = rL; break; + case 0x66: rH = memory[rHL]; break; + case 0x67: rH = rA; break; + case 0x68: rL = rB; break; + case 0x69: rL = rC; break; + case 0x6A: rL = rD; break; + case 0x6B: rL = rE; break; + case 0x6C: rL = rH; break; + case 0x6D: rL = rL; break; + case 0x6E: rL = memory[rHL]; break; + case 0x6F: rL = rA; break; + + case 0x70: memory[rHL] = rB; break; + case 0x71: memory[rHL] = rC; break; + case 0x72: memory[rHL] = rD; break; + case 0x73: memory[rHL] = rE; break; + case 0x74: memory[rHL] = rH; break; + case 0x75: memory[rHL] = rL; break; + case 0x76: HALT(); break; + case 0x77: memory[rHL] = rA; break; + case 0x78: rA = rB; break; + case 0x79: rA = rC; break; + case 0x7A: rA = rD; break; + case 0x7B: rA = rE; break; + case 0x7C: rA = rH; break; + case 0x7D: rA = rL; break; + case 0x7E: rA = memory[rHL]; 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, rH); break; + case 0x85: ADD8(_rA, rL); break; + case 0x86: ADD8(_rA, memory[rHL]); 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, rH); break; + case 0x8D: ADC8(_rA, rL); break; + case 0x8E: ADC8(_rA, memory[rHL]); break; + case 0x8F: ADC8(_rA, rA); break; + + case 0x90: SUB8(rB); break; + case 0x91: SUB8(rC); break; + case 0x92: SUB8(rD); break; + case 0x93: SUB8(rE); break; + case 0x94: SUB8(rH); break; + case 0x95: SUB8(rL); break; + case 0x96: SUB8(memory[rHL]); 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, rH); break; + case 0x9D: SBC8(_rA, rL); break; + case 0x9E: SBC8(_rA, memory[rHL]); break; + case 0x9F: SBC8(_rA, rA); break; + + case 0xA0: AND(rB); break; + case 0xA1: AND(rC); break; + case 0xA2: AND(rD); break; + case 0xA3: AND(rE); break; + case 0xA4: AND(rH); break; + case 0xA5: AND(rL); break; + case 0xA6: AND(memory[rHL]); break; + case 0xA7: AND(rA); break; + case 0xA8: XOR(rB); break; + case 0xA9: XOR(rC); break; + case 0xAA: XOR(rD); break; + case 0xAB: XOR(rE); break; + case 0xAC: XOR(rH); break; + case 0xAD: XOR(rL); break; + case 0xAE: XOR(memory[rHL]); break; + case 0xAF: XOR(rA); break; + + case 0xB0: OR(rB); break; + case 0xB1: OR(rC); break; + case 0xB2: OR(rD); break; + case 0xB3: OR(rE); break; + case 0xB4: OR(rH); break; + case 0xB5: OR(rL); break; + case 0xB6: OR(memory[rHL]); break; + case 0xB7: OR(rA); break; + case 0xB8: CP(rB); break; + case 0xB9: CP(rC); break; + case 0xBA: CP(rD); break; + case 0xBB: CP(rE); break; + case 0xBC: CP(rH); break; + case 0xBD: CP(rL); break; + case 0xBE: CP(memory[rHL]); break; + case 0xBF: CP(rA); break; + + case 0xC0: RET(cNZ); break; + case 0xC1: POP(_rBC); break; + case 0xC2: JP(cNZ, LD16()); break; + case 0xC3: JP(cNO, LD16()); break; + case 0xC4: CALL(cNZ, LD16()); break; + case 0xC5: PUSH(rBC); break; + case 0xC6: ADD8(_rA, LD8()); break; + case 0xC7: RST(0x00); break; + case 0xC8: RET(cZ); break; + case 0xC9: RET(cNO); break; + case 0xCA: JP(cZ, LD16()); break; + case 0xCB: BIT_INSTRUCTIONS(); break; + case 0xCC: CALL(cZ, LD16()); break; + case 0xCD: CALL(cNO, LD16()); break; + case 0xCE: ADC8(_rA, LD8()); break; + case 0xCF: RST(0x08); break; + + case 0xD0: RET(cNC); break; + case 0xD1: POP(_rDE); break; + case 0xD2: JP(cNC, LD16()); break; + case 0xD3: OUT(LD8(), rA); break; + case 0xD4: CALL(cNC, LD16()); break; + case 0xD5: PUSH(rDE); break; + case 0xD6: SUB8(LD8()); break; + case 0xD7: RST(0x10); break; + case 0xD8: RET(cC); break; + case 0xD9: SWAP(rBC, rBC2);SWAP(rDE, rDE2);SWAP(rHL, rHL2); break; + case 0xDA: JP(cC, LD16()); break; + case 0xDB: IN(_rA, LD8()); break; + case 0xDC: CALL(cC, LD16()); break; + case 0xDD: IX_INSTRUCTIONS(); break; + case 0xDE: SBC8(_rA, LD8()); break; + case 0xDF: RST(0x18); break; + + case 0xE0: RET(cPO); break; + case 0xE1: POP(_rHL); break; + case 0xE2: JP(cPO, LD16()); break; + case 0xE3: SWAP(rHL, rM16(rSP)); break; + case 0xE4: CALL(cPO, LD16()); break; + case 0xE5: PUSH(rHL); break; + case 0xE6: AND(LD8()); break; + case 0xE7: RST(0x20); break; + case 0xE8: RET(cPE); break; + case 0xE9: JP(cNO, memory[rHL]); break; + case 0xEA: JP(cPE, LD16()); break; + case 0xEB: SWAP(rDE, rHL); break; + case 0xEC: CALL(cPE, LD16()); break; + case 0xED: MISC_INSTRUCTIONS(); break; + case 0xEE: XOR(LD8()); break; + case 0xEF: RST(0x28); break; + + case 0xF0: RET(cP); break; + case 0xF1: POP(_rAF); break; + case 0xF2: JP(cP, LD16()); break; + case 0xF3: DI(); break; + case 0xF4: CALL(cP, LD16()); break; + case 0xF5: PUSH(rAF); break; + case 0xF6: OR(LD8()); break; + case 0xF7: RST(0x30); break; + case 0xF8: RET(cM); break; + case 0xF9: rSP = rHL; break; + case 0xFA: JP(cM, LD16()); break; + case 0xFB: EI(); break; + case 0xFC: CALL(cM, LD16()); break; + case 0xFD: IY_INSTRUCTIONS(); break; + case 0xFE: CP(LD8()); break; + case 0xFF: RST(0x38); break; + } + } + + void BIT_INSTRUCTIONS() + { + const uint8_t opcode = memory[rPC++]; + t_states+=4; + switch (opcode) + { + case 0x00: RLC(_rB); break; + case 0x01: RLC(_rC); break; + case 0x02: RLC(_rD); break; + case 0x03: RLC(_rE); break; + case 0x04: RLC(_rH); break; + case 0x05: RLC(_rL); break; + case 0x06: RLC(&memory[rHL]); break; + case 0x07: RLC(_rA); break; + case 0x08: RRC(_rB); break; + case 0x09: RRC(_rC); break; + case 0x0A: RRC(_rD); break; + case 0x0B: RRC(_rE); break; + case 0x0C: RRC(_rH); break; + case 0x0D: RRC(_rL); break; + case 0x0E: RRC(&memory[rHL]); break; + case 0x0F: RRC(_rA); break; + + case 0x10: RL(_rB); break; + case 0x11: RL(_rC); break; + case 0x12: RL(_rD); break; + case 0x13: RL(_rE); break; + case 0x14: RL(_rH); break; + case 0x15: RL(_rL); break; + case 0x16: RL(&memory[rHL]); break; + case 0x17: RL(_rA); break; + case 0x18: RR(_rB); break; + case 0x19: RR(_rC); break; + case 0x1A: RR(_rD); break; + case 0x1B: RR(_rE); break; + case 0x1C: RR(_rH); break; + case 0x1D: RR(_rL); break; + case 0x1E: RR(&memory[rHL]); break; + case 0x1F: RR(_rA); break; + + case 0x20: SLA(_rB); break; + case 0x21: SLA(_rC); break; + case 0x22: SLA(_rD); break; + case 0x23: SLA(_rE); break; + case 0x24: SLA(_rH); break; + case 0x25: SLA(_rL); break; + case 0x26: SLA(&memory[rHL]); break; + case 0x27: SLA(_rA); break; + case 0x28: SRA(_rB); break; + case 0x29: SRA(_rC); break; + case 0x2A: SRA(_rD); break; + case 0x2B: SRA(_rE); break; + case 0x2C: SRA(_rH); break; + case 0x2D: SRA(_rL); break; + case 0x2E: SRA(&memory[rHL]); break; + case 0x2F: SRA(_rA); break; + + case 0x30: SLL(_rB); break; + case 0x31: SLL(_rC); break; + case 0x32: SLL(_rD); break; + case 0x33: SLL(_rE); break; + case 0x34: SLL(_rH); break; + case 0x35: SLL(_rL); break; + case 0x36: SLL(&memory[rHL]); break; + case 0x37: SLL(_rA); break; + case 0x38: SRL(_rB); break; + case 0x39: SRL(_rC); break; + case 0x3A: SRL(_rD); break; + case 0x3B: SRL(_rE); break; + case 0x3C: SRL(_rH); break; + case 0x3D: SRL(_rL); break; + case 0x3E: SRL(&memory[rHL]); break; + case 0x3F: SRL(_rA); break; + + case 0x40: BIT(0, rB); break; + case 0x41: BIT(0, rC); break; + case 0x42: BIT(0, rD); break; + case 0x43: BIT(0, rE); break; + case 0x44: BIT(0, rH); break; + case 0x45: BIT(0, rL); break; + case 0x46: BIT(0, memory[rHL]); break; + case 0x47: BIT(0, rA); break; + case 0x48: BIT(1, rB); break; + case 0x49: BIT(1, rC); break; + case 0x4A: BIT(1, rD); break; + case 0x4B: BIT(1, rE); break; + case 0x4C: BIT(1, rH); break; + case 0x4D: BIT(1, rL); break; + case 0x4E: BIT(1, memory[rHL]); break; + case 0x4F: BIT(1, rA); break; + + case 0x50: BIT(2, rB); break; + case 0x51: BIT(2, rC); break; + case 0x52: BIT(2, rD); break; + case 0x53: BIT(2, rE); break; + case 0x54: BIT(2, rH); break; + case 0x55: BIT(2, rL); break; + case 0x56: BIT(2, memory[rHL]); break; + case 0x57: BIT(2, rA); break; + case 0x58: BIT(3, rB); break; + case 0x59: BIT(3, rC); break; + case 0x5A: BIT(3, rD); break; + case 0x5B: BIT(3, rE); break; + case 0x5C: BIT(3, rH); break; + case 0x5D: BIT(3, rL); break; + case 0x5E: BIT(3, memory[rHL]); break; + case 0x5F: BIT(3, rA); break; + + case 0x60: BIT(4, rB); break; + case 0x61: BIT(4, rC); break; + case 0x62: BIT(4, rD); break; + case 0x63: BIT(4, rE); break; + case 0x64: BIT(4, rH); break; + case 0x65: BIT(4, rL); break; + case 0x66: BIT(4, memory[rHL]); break; + case 0x67: BIT(4, rA); break; + case 0x68: BIT(5, rB); break; + case 0x69: BIT(5, rC); break; + case 0x6A: BIT(5, rD); break; + case 0x6B: BIT(5, rE); break; + case 0x6C: BIT(5, rH); break; + case 0x6D: BIT(5, rL); break; + case 0x6E: BIT(5, memory[rHL]); break; + case 0x6F: BIT(5, rA); break; + + case 0x70: BIT(6, rB); break; + case 0x71: BIT(6, rC); break; + case 0x72: BIT(6, rD); break; + case 0x73: BIT(6, rE); break; + case 0x74: BIT(6, rH); break; + case 0x75: BIT(6, rL); break; + case 0x76: BIT(6, memory[rHL]); break; + case 0x77: BIT(6, rA); break; + case 0x78: BIT(7, rB); break; + case 0x79: BIT(7, rC); break; + case 0x7A: BIT(7, rD); break; + case 0x7B: BIT(7, rE); break; + case 0x7C: BIT(7, rH); break; + case 0x7D: BIT(7, rL); break; + case 0x7E: BIT(7, memory[rHL]); break; + case 0x7F: BIT(7, rA); break; + + case 0x80: RES(0, _rB); break; + case 0x81: RES(0, _rC); break; + case 0x82: RES(0, _rD); break; + case 0x83: RES(0, _rE); break; + case 0x84: RES(0, _rH); break; + case 0x85: RES(0, _rL); break; + case 0x86: RES(0, &memory[rHL]); break; + case 0x87: RES(0, _rA); break; + case 0x88: RES(1, _rB); break; + case 0x89: RES(1, _rC); break; + case 0x8A: RES(1, _rD); break; + case 0x8B: RES(1, _rE); break; + case 0x8C: RES(1, _rH); break; + case 0x8D: RES(1, _rL); break; + case 0x8E: RES(1, &memory[rHL]); break; + case 0x8F: RES(1, _rA); break; + + case 0x90: RES(2, _rB); break; + case 0x91: RES(2, _rC); break; + case 0x92: RES(2, _rD); break; + case 0x93: RES(2, _rE); break; + case 0x94: RES(2, _rH); break; + case 0x95: RES(2, _rL); break; + case 0x96: RES(2, &memory[rHL]); break; + case 0x97: RES(2, _rA); break; + case 0x98: RES(3, _rB); break; + case 0x99: RES(3, _rC); break; + case 0x9A: RES(3, _rD); break; + case 0x9B: RES(3, _rE); break; + case 0x9C: RES(3, _rH); break; + case 0x9D: RES(3, _rL); break; + case 0x9E: RES(3, &memory[rHL]); break; + case 0x9F: RES(3, _rA); break; + + case 0xA0: RES(4, _rB); break; + case 0xA1: RES(4, _rC); break; + case 0xA2: RES(4, _rD); break; + case 0xA3: RES(4, _rE); break; + case 0xA4: RES(4, _rH); break; + case 0xA5: RES(4, _rL); break; + case 0xA6: RES(4, &memory[rHL]); break; + case 0xA7: RES(4, _rA); break; + case 0xA8: RES(5, _rB); break; + case 0xA9: RES(5, _rC); break; + case 0xAA: RES(5, _rD); break; + case 0xAB: RES(5, _rE); break; + case 0xAC: RES(5, _rH); break; + case 0xAD: RES(5, _rL); break; + case 0xAE: RES(5, &memory[rHL]); break; + case 0xAF: RES(5, _rA); break; + + case 0xB0: RES(6, _rB); break; + case 0xB1: RES(6, _rC); break; + case 0xB2: RES(6, _rD); break; + case 0xB3: RES(6, _rE); break; + case 0xB4: RES(6, _rH); break; + case 0xB5: RES(6, _rL); break; + case 0xB6: RES(6, &memory[rHL]); break; + case 0xB7: RES(6, _rA); break; + case 0xB8: RES(7, _rB); break; + case 0xB9: RES(7, _rC); break; + case 0xBA: RES(7, _rD); break; + case 0xBB: RES(7, _rE); break; + case 0xBC: RES(7, _rH); break; + case 0xBD: RES(7, _rL); break; + case 0xBE: RES(7, &memory[rHL]); break; + case 0xBF: RES(7, _rA); break; + + case 0xC0: SET(0, _rB); break; + case 0xC1: SET(0, _rC); break; + case 0xC2: SET(0, _rD); break; + case 0xC3: SET(0, _rE); break; + case 0xC4: SET(0, _rH); break; + case 0xC5: SET(0, _rL); break; + case 0xC6: SET(0, &memory[rHL]); break; + case 0xC7: SET(0, _rA); break; + case 0xC8: SET(1, _rB); break; + case 0xC9: SET(1, _rC); break; + case 0xCA: SET(1, _rD); break; + case 0xCB: SET(1, _rE); break; + case 0xCC: SET(1, _rH); break; + case 0xCD: SET(1, _rL); break; + case 0xCE: SET(1, &memory[rHL]); break; + case 0xCF: SET(1, _rA); break; + + case 0xD0: SET(2, _rB); break; + case 0xD1: SET(2, _rC); break; + case 0xD2: SET(2, _rD); break; + case 0xD3: SET(2, _rE); break; + case 0xD4: SET(2, _rH); break; + case 0xD5: SET(2, _rL); break; + case 0xD6: SET(2, &memory[rHL]); break; + case 0xD7: SET(2, _rA); break; + case 0xD8: SET(3, _rB); break; + case 0xD9: SET(3, _rC); break; + case 0xDA: SET(3, _rD); break; + case 0xDB: SET(3, _rE); break; + case 0xDC: SET(3, _rH); break; + case 0xDD: SET(3, _rL); break; + case 0xDE: SET(3, &memory[rHL]); break; + case 0xDF: SET(3, _rA); break; + + case 0xE0: SET(4, _rB); break; + case 0xE1: SET(4, _rC); break; + case 0xE2: SET(4, _rD); break; + case 0xE3: SET(4, _rE); break; + case 0xE4: SET(4, _rH); break; + case 0xE5: SET(4, _rL); break; + case 0xE6: SET(4, &memory[rHL]); break; + case 0xE7: SET(4, _rA); break; + case 0xE8: SET(5, _rB); break; + case 0xE9: SET(5, _rC); break; + case 0xEA: SET(5, _rD); break; + case 0xEB: SET(5, _rE); break; + case 0xEC: SET(5, _rH); break; + case 0xED: SET(5, _rL); break; + case 0xEE: SET(5, &memory[rHL]); break; + case 0xEF: SET(5, _rA); break; + + case 0xF0: SET(6, _rB); break; + case 0xF1: SET(6, _rC); break; + case 0xF2: SET(6, _rD); break; + case 0xF3: SET(6, _rE); break; + case 0xF4: SET(6, _rH); break; + case 0xF5: SET(6, _rL); break; + case 0xF6: SET(6, &memory[rHL]); break; + case 0xF7: SET(6, _rA); break; + case 0xF8: SET(7, _rB); break; + case 0xF9: SET(7, _rC); break; + case 0xFA: SET(7, _rD); break; + case 0xFB: SET(7, _rE); break; + case 0xFC: SET(7, _rH); break; + case 0xFD: SET(7, _rL); break; + case 0xFE: SET(7, &memory[rHL]); break; + case 0xFF: SET(7, _rA); break; + } + } + + void IX_INSTRUCTIONS() + { + const uint8_t opcode = memory[rPC++]; + t_states+=4; + uint8_t d; + + switch (opcode) + { + case 0x00: INVALID(); break; + case 0x01: INVALID(); break; + case 0x02: INVALID(); break; + case 0x03: INVALID(); break; + case 0x04: INC8(_rB); break; + case 0x05: DEC8(_rB); break; + case 0x06: rB = LD8(); break; + case 0x07: INVALID(); break; + case 0x08: INVALID(); break; + case 0x09: ADD16(_rIX, rBC); break; + case 0x0A: INVALID(); break; + case 0x0B: INVALID(); break; + case 0x0C: INC8(_rC); break; + case 0x0D: DEC8(_rC); break; + case 0x0E: rC = LD8(); break; + case 0x0F: INVALID(); break; + + case 0x10: INVALID(); break; + case 0x11: INVALID(); break; + case 0x12: INVALID(); break; + case 0x13: INVALID(); break; + case 0x14: INC8(_rD); break; + case 0x15: DEC8(_rD); break; + case 0x16: rD = LD8(); break; + case 0x17: INVALID(); break; + case 0x18: INVALID(); break; + case 0x19: ADD16(_rIX, rDE); break; + case 0x1A: INVALID(); break; + case 0x1B: INVALID(); break; + case 0x1C: INC8(_rE); break; + case 0x1D: DEC8(_rE); break; + case 0x1E: rE = LD8(); break; + case 0x1F: INVALID(); break; + + case 0x20: INVALID(); break; + case 0x21: rIX = LD16(); break; + case 0x22: rM16(LD16()) = rIX; break; + case 0x23: INC16(_rIX); break; + case 0x24: INC8(_rIXH); break; + case 0x25: DEC8(_rIXH); break; + case 0x26: rIXH = LD8(); break; + case 0x27: INVALID(); break; + case 0x28: INVALID(); break; + case 0x29: ADD16(_rIX, rIX); break; + case 0x2A: rIX = rM16(LD16()); break; + case 0x2B: DEC16(_rIX); break; + case 0x2C: INC8(_rIXL); break; + case 0x2D: DEC8(_rIXL); break; + case 0x2E: rIXL = LD8(); 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[rIX+LD8()]); break; + case 0x35: DEC8(&memory[rIX+LD8()]); break; + case 0x36: d=LD8(); memory[rIX+d]=LD8(); break; + case 0x37: INVALID(); break; + case 0x38: INVALID(); break; + case 0x39: ADD16(_rIX, rSP); break; + case 0x3A: INVALID(); break; + case 0x3B: INVALID(); break; + case 0x3C: INC8(_rA); break; + case 0x3D: DEC8(_rA); break; + case 0x3E: rA = LD8(); break; + case 0x3F: INVALID(); break; + + case 0x40: rB = rB; break; + case 0x41: rB = rC; break; + case 0x42: rB = rD; break; + case 0x43: rB = rE; break; + case 0x44: rB = rIXH; break; + case 0x45: rB = rIXL; break; + case 0x46: rB = memory[rIX+LD8()]; break; + case 0x47: rB = rA; break; + case 0x48: rC = rB; break; + case 0x49: rC = rC; break; + case 0x4A: rC = rD; break; + case 0x4B: rC = rE; break; + case 0x4C: rC = rIXH; break; + case 0x4D: rC = rIXL; break; + case 0x4E: rC = memory[rIX+LD8()]; break; + case 0x4F: rC = rA; break; + + case 0x50: rD = rB; break; + case 0x51: rD = rC; break; + case 0x52: rD = rD; break; + case 0x53: rD = rE; break; + case 0x54: rD = rIXH; break; + case 0x55: rD = rIXL; break; + case 0x56: rD = memory[rIX+LD8()]; break; + case 0x57: rD = rA; break; + case 0x58: rE = rB; break; + case 0x59: rE = rC; break; + case 0x5A: rE = rD; break; + case 0x5B: rE = rE; break; + case 0x5C: rE = rIXH; break; + case 0x5D: rE = rIXL; break; + case 0x5E: rE = memory[rIX+LD8()]; break; + case 0x5F: rE = rA; break; + + case 0x60: rIXH = rB; break; + case 0x61: rIXH = rC; break; + case 0x62: rIXH = rD; break; + case 0x63: rIXH = rE; break; + case 0x64: rIXH = rIXH; break; + case 0x65: rIXH = rIXL; break; + case 0x66: rH = memory[rIX+LD8()]; break; + case 0x67: rIXH = rA; break; + case 0x68: rIXL = rB; break; + case 0x69: rIXL = rC; break; + case 0x6A: rIXL = rD; break; + case 0x6B: rIXL = rE; break; + case 0x6C: rIXL = rIXH; break; + case 0x6D: rIXL = rIXL; break; + case 0x6E: rL = memory[rIX+LD8()]; break; + case 0x6F: rIXL = rA; break; + + case 0x70: memory[rIX+LD8()] = rB; break; + case 0x71: memory[rIX+LD8()] = rC; break; + case 0x72: memory[rIX+LD8()] = rD; break; + case 0x73: memory[rIX+LD8()] = rE; break; + case 0x74: memory[rIX+LD8()] = rH; break; + case 0x75: memory[rIX+LD8()] = rL; break; + case 0x76: INVALID(); break; + case 0x77: memory[rIX+LD8()] = rA; break; + case 0x78: rA = rB; break; + case 0x79: rA = rC; break; + case 0x7A: rA = rD; break; + case 0x7B: rA = rE; break; + case 0x7C: rA = rIXH; break; + case 0x7D: rA = rIXL; break; + case 0x7E: rA = memory[rIX+LD8()]; 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, rIXH); break; + case 0x85: ADD8(_rA, rIXL); break; + case 0x86: ADD8(_rA, memory[rIX+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, rIXH); break; + case 0x8D: ADC8(_rA, rIXL); break; + case 0x8E: ADC8(_rA, memory[rIX+LD8()]); break; + case 0x8F: ADC8(_rA, rA); break; + + case 0x90: SUB8(rB); break; + case 0x91: SUB8(rC); break; + case 0x92: SUB8(rD); break; + case 0x93: SUB8(rE); break; + case 0x94: SUB8(rIXH); break; + case 0x95: SUB8(rIXL); break; + case 0x96: SUB8(memory[rIX+LD8()]); 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, rIXH); break; + case 0x9D: SBC8(_rA, rIXL); break; + case 0x9E: SBC8(_rA, memory[rIX+LD8()]); break; + case 0x9F: SBC8(_rA, rA); break; + + case 0xA0: AND(rB); break; + case 0xA1: AND(rC); break; + case 0xA2: AND(rD); break; + case 0xA3: AND(rE); break; + case 0xA4: AND(rIXH); break; + case 0xA5: AND(rIXL); break; + case 0xA6: AND(memory[rIX+LD8()]); break; + case 0xA7: AND(rA); break; + case 0xA8: XOR(rB); break; + case 0xA9: XOR(rC); break; + case 0xAA: XOR(rD); break; + case 0xAB: XOR(rE); break; + case 0xAC: XOR(rIXH); break; + case 0xAD: XOR(rIXL); break; + case 0xAE: XOR(memory[rIX+LD8()]); break; + case 0xAF: XOR(rA); break; + + case 0xB0: OR(rB); break; + case 0xB1: OR(rC); break; + case 0xB2: OR(rD); break; + case 0xB3: OR(rE); break; + case 0xB4: OR(rIXH); break; + case 0xB5: OR(rIXL); break; + case 0xB6: OR(memory[rIX+LD8()]); break; + case 0xB7: OR(rA); break; + case 0xB8: CP(rB); break; + case 0xB9: CP(rC); break; + case 0xBA: CP(rD); break; + case 0xBB: CP(rE); break; + case 0xBC: CP(rIXH); break; + case 0xBD: CP(rIXL); break; + case 0xBE: CP(memory[rIX+LD8()]); break; + case 0xBF: CP(rA); break; + + case 0xCB: IX_BIT_INSTRUCTIONS(); break; + case 0xE1: POP(_rIX); break; + case 0xE3: SWAP(rIX, rM16(rSP)); break; + case 0xE5: PUSH(rIX); break; + case 0xE9: JP(cNO, memory[rHL]); break; + case 0xF9: rIX = rSP; break; + default: INVALID(); break; + } + } + + void IX_BIT_INSTRUCTIONS() + { + const uint8_t opcode = memory[rPC++]; + t_states+=4; + 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 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 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 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 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 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 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 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 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 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 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 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 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; } } } \ No newline at end of file