@fugloy/emu 0.0.0-stage → 0.2.0

package/src/cpu/z80cpu.js

@@ -0,0 +1,3343 @@
+/**
+ * Z80 CPU Emulator Core
+ * Implements COMPLETE Z80 instruction set with cycle-accurate timing
+ *
+ * This is a FULL Z80 implementation matching the real TRS-80 Model III.
+ * ALL instructions must be implemented:
+ * - Base opcodes: 0x00-0xFF (252 instructions)
+ * - CB prefix: 0xCB00-0xCBFF (bit operations, rotates, shifts)
+ * - ED prefix: 0xED00-0xEDFF (extended instructions, block operations)
+ * - DD prefix: 0xDD00-0xDDFF (IX register operations)
+ * - FD prefix: 0xFD00-0xFDFF (IY register operations)
+ *
+ * Reference: docs/cschweda-z80-assembler-8a5edab282632443.txt (opcodes.js)
+ */
+
+// Flag bit positions
+const FLAG_C = 0; // Carry
+const FLAG_N = 1; // Add/Subtract
+const FLAG_PV = 2; // Parity/Overflow
+const FLAG_H = 4; // Half Carry
+const FLAG_Z = 6; // Zero
+const FLAG_S = 7; // Sign
+
+// The 8-bit registers auto-mask writes to 8 bits via accessor properties
+// over a closure-private backing store. Accessors, not a Proxy: register
+// access is the hottest path in the emulator, and V8 inline-caches plain
+// accessors where every Proxy trap costs a handler call plus a key
+// lookup — swapping the Proxy for accessors measured 3.25x faster
+// overall emulation. The backing store is only reachable through the
+// setters, so its values are always pre-masked and reads need no mask.
+const EIGHT_BIT_REGS = [
+  "A", "F", "B", "C", "D", "E", "H", "L",
+  "A_", "F_", "B_", "C_", "D_", "E_", "H_", "L_",
+  "IXH", "IXL", "IYH", "IYL",
+  "I", "R",
+];
+
+// DD/FD CB register field (low 3 bits) -> destination for the
+// undocumented result copy; index 6 is the documented memory-only form.
+const INDEXED_CB_COPY_REGS = ["B", "C", "D", "E", "H", "L", null, "A"];
+
+function makeRegisterFile() {
+  const raw = {};
+  for (const name of EIGHT_BIT_REGS) {
+    raw[name] = 0x00;
+  }
+  // SP/PC stay plain 16-bit data properties; every write site masks them.
+  const registers = {
+    SP: 0xffff,
+    PC: 0x0000,
+  };
+  for (const name of EIGHT_BIT_REGS) {
+    Object.defineProperty(registers, name, {
+      enumerable: true,
+      get() {
+        return raw[name];
+      },
+      set(value) {
+        raw[name] = value & 0xff;
+      },
+    });
+  }
+  return registers;
+}
+
+export class Z80CPU {
+  constructor() {
+    this.registers = makeRegisterFile();
+
+    // Interrupt system
+    this.IFF1 = false;
+    this.IFF2 = false;
+    this.interruptMode = 0;
+    this.halted = false;
+    // EI enables interrupts only after the instruction that follows it;
+    // counts down at the end of each executed instruction (2 -> 1 -> enable).
+    this.pendingEI = 0;
+    this.afterPrefix = false; // a DD or FD the next byte made a no-op; no maskable interrupt until it runs
+
+    // When true, unimplemented opcodes throw instead of executing as NOP.
+    // Test harnesses use this so instruction-set gaps can't hide.
+    this.strictMode = false;
+    // Where warnings go (unimplemented opcodes); a no-op unless the host sets one.
+    this.log = () => {};
+
+    // Execution state
+    this.cycles = 0;
+    this.lastOpCycles = 0;
+    this.wz = 0x0000; // MEMPTR (internal address latch)
+
+    // External interfaces (connected by system)
+    this.readMemory = (address) => 0x00;
+    this.writeMemory = (address, value) => {};
+    this.readPort = (port) => 0x00;
+    this.writePort = (port, value) => {};
+
+    // Unimplemented opcode tracking (for debugging)
+    this.unimplementedOpcodes = new Set();
+
+    // Setup opcode handlers
+    this.setupOpcodeHandlers();
+  }
+
+  // Register pair getters/setters
+  getRegisterPair(high, low) {
+    return (this.registers[high] << 8) | this.registers[low];
+  }
+
+  setRegisterPair(high, low, value) {
+    this.registers[high] = (value >> 8) & 0xff;
+    this.registers[low] = value & 0xff;
+  }
+
+  // Ensure 8-bit registers wrap correctly
+  setRegister(reg, value) {
+    this.registers[reg] = value & 0xff;
+  }
+
+  get BC() {
+    return this.getRegisterPair("B", "C");
+  }
+  set BC(value) {
+    this.setRegisterPair("B", "C", value);
+  }
+
+  get DE() {
+    return this.getRegisterPair("D", "E");
+  }
+  set DE(value) {
+    this.setRegisterPair("D", "E", value);
+  }
+
+  get HL() {
+    return this.getRegisterPair("H", "L");
+  }
+  set HL(value) {
+    this.setRegisterPair("H", "L", value);
+  }
+
+  get IX() {
+    return this.getRegisterPair("IXH", "IXL");
+  }
+  set IX(value) {
+    this.setRegisterPair("IXH", "IXL", value);
+  }
+
+  get IY() {
+    return this.getRegisterPair("IYH", "IYL");
+  }
+  set IY(value) {
+    this.setRegisterPair("IYH", "IYL", value);
+  }
+
+  // Flag operations
+  getFlag(flag) {
+    return (this.registers.F >> flag) & 1;
+  }
+
+  /**
+   * Undocumented X/Y flags (F bits 3 and 5): every flag-writing
+   * instruction copies bits 3/5 of some instruction-specific value —
+   * usually the result, but CP uses its operand, BIT n,(HL) uses
+   * MEMPTR's high byte, and the block ops use a synthetic n (see the
+   * call sites). ZEXALL-class fidelity lives or dies here.
+   */
+  _xy(value) {
+    this.registers.F = (this.registers.F & ~0x28) | (value & 0x28);
+  }
+
+  /** Block-op X/Y mapping: Y = bit 1 of n, X = bit 3 of n. */
+  _xyBlock(n) {
+    this.registers.F =
+      (this.registers.F & ~0x28) | ((n & 0x02) << 4) | (n & 0x08);
+  }
+
+  setFlag(flag, value) {
+    if (value) {
+      this.registers.F |= 1 << flag;
+    } else {
+      this.registers.F &= ~(1 << flag);
+    }
+  }
+
+  get flagC() {
+    return this.getFlag(FLAG_C);
+  }
+  set flagC(v) {
+    this.setFlag(FLAG_C, v);
+  }
+
+  get flagN() {
+    return this.getFlag(FLAG_N);
+  }
+  set flagN(v) {
+    this.setFlag(FLAG_N, v);
+  }
+
+  get flagPV() {
+    return this.getFlag(FLAG_PV);
+  }
+  set flagPV(v) {
+    this.setFlag(FLAG_PV, v);
+  }
+
+  get flagH() {
+    return this.getFlag(FLAG_H);
+  }
+  set flagH(v) {
+    this.setFlag(FLAG_H, v);
+  }
+
+  get flagZ() {
+    return this.getFlag(FLAG_Z);
+  }
+  set flagZ(v) {
+    this.setFlag(FLAG_Z, v);
+  }
+
+  get flagS() {
+    return this.getFlag(FLAG_S);
+  }
+  set flagS(v) {
+    this.setFlag(FLAG_S, v);
+  }
+
+  // Reset CPU
+  reset() {
+    this.registers.PC = 0x0000;
+    this.registers.SP = 0xffff;
+    this.registers.I = 0x00;
+    this.registers.R = 0x00;
+    this.wz = 0x0000; // MEMPTR — feeds BIT n,(HL)'s X/Y flags
+    this.halted = false;
+    this.IFF1 = false;
+    this.IFF2 = false;
+    this.interruptMode = 0;
+    this.pendingEI = 0;
+    this.afterPrefix = false; // a DD or FD the next byte made a no-op; no maskable interrupt until it runs
+    this.cycles = 0;
+  }
+
+  // Execute single instruction
+  executeInstruction() {
+    this.afterPrefix = false;
+    if (this.halted) {
+      this.lastOpCycles = 4;
+      this.cycles += 4;
+      return 4;
+    }
+
+    const opcode = this.readMemory(this.registers.PC);
+    this.registers.PC = (this.registers.PC + 1) & 0xffff;
+
+    this.incrementR();
+
+    const cycles = this.decodeAndExecute(opcode);
+
+    // Promote a pending EI once the instruction after EI has completed
+    if (this.pendingEI > 0) {
+      this.pendingEI--;
+      if (this.pendingEI === 0) {
+        this.IFF1 = true;
+        this.IFF2 = true;
+      }
+    }
+
+    this.lastOpCycles = cycles;
+    this.cycles += cycles;
+
+    return cycles;
+  }
+
+  // R increments once per opcode fetch (so twice for prefixed
+  // instructions); bit 7 is only ever set by LD R,A and must be preserved.
+  incrementR() {
+    this.registers.R =
+      (this.registers.R & 0x80) | ((this.registers.R + 1) & 0x7f);
+  }
+
+  /**
+   * Accept a maskable interrupt (the Model III raises these at 30 Hz).
+   * Returns true if the interrupt was taken. In IM 2 the dataBus byte
+   * selects the vector-table entry; the Model III bus presents 0xFF,
+   * which in IM 0/1 behaves as RST 38.
+   */
+  interrupt(dataBus = 0xff) {
+    if (!this.IFF1 || this.pendingEI > 0 || this.afterPrefix) {
+      return false;
+    }
+
+    this.halted = false;
+    this.IFF1 = false;
+    this.IFF2 = false;
+    this.incrementR(); // acknowledge is an M1 cycle
+
+    this.registers.SP = (this.registers.SP - 1) & 0xffff;
+    this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+    this.registers.SP = (this.registers.SP - 1) & 0xffff;
+    this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+
+    if (this.interruptMode === 2) {
+      const vecAddr = ((this.registers.I << 8) | (dataBus & 0xfe)) & 0xffff;
+      const low = this.readMemory(vecAddr);
+      const high = this.readMemory((vecAddr + 1) & 0xffff);
+      this.registers.PC = (high << 8) | low;
+      this.cycles += 19;
+    } else {
+      // IM 0 with 0xFF on the bus is RST 38 — identical to IM 1 here
+      this.registers.PC = 0x0038;
+      this.cycles += 13;
+    }
+    this.wz = this.registers.PC; // MEMPTR, as for CALL
+
+    return true;
+  }
+
+  /**
+   * Non-maskable interrupt: always taken, saves IFF1 into IFF2 so RETN
+   * can restore it, jumps to 0x0066.
+   */
+  nmi() {
+    this.halted = false;
+    this.IFF2 = this.IFF1;
+    this.IFF1 = false;
+    this.incrementR(); // acknowledge is an M1 cycle
+
+    this.registers.SP = (this.registers.SP - 1) & 0xffff;
+    this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+    this.registers.SP = (this.registers.SP - 1) & 0xffff;
+    this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+
+    this.registers.PC = 0x0066;
+    this.wz = 0x0066; // MEMPTR, as for CALL
+    this.cycles += 11;
+  }
+
+  // Decode and execute opcode
+  decodeAndExecute(opcode) {
+    // Extended instructions (second opcode fetch bumps R again)
+    if (opcode === 0xcb) {
+      this.incrementR();
+      return this.executeCB();
+    }
+    if (opcode === 0xed) {
+      this.incrementR();
+      return this.executeED();
+    }
+    if (opcode === 0xdd) {
+      return this.executeDD();
+    }
+    if (opcode === 0xfd) {
+      return this.executeFD();
+    }
+
+    // Standard instructions
+    const handler = this.opcodeHandlers[opcode];
+    if (handler) {
+      return handler.call(this);
+    }
+
+    return this.reportUnimplemented(opcode, "");
+  }
+
+  // Shared unimplemented-opcode path: throw in strict mode so gaps
+  // surface in tests; warn once and NOP otherwise (browser behavior).
+  reportUnimplemented(opcode, prefix) {
+    const label = `${prefix}0x${opcode
+      .toString(16)
+      .toUpperCase()
+      .padStart(2, "0")}`;
+    if (this.strictMode) {
+      throw new Error(
+        `Unimplemented opcode ${label} at PC=0x${(this.registers.PC - 1)
+          .toString(16)
+          .padStart(4, "0")}`
+      );
+    }
+    const key = prefix ? `${prefix}${opcode}` : opcode;
+    if (!this.unimplementedOpcodes.has(key)) {
+      this.unimplementedOpcodes.add(key);
+      this.log("warn",
+        `Unimplemented opcode: ${label} at PC=0x${(this.registers.PC - 1)
+          .toString(16)
+          .padStart(4, "0")}`
+      );
+    }
+    return 4;
+  }
+
+  // Setup opcode handlers
+  setupOpcodeHandlers() {
+    this.opcodeHandlers = {};
+
+    // NOP
+    this.opcodeHandlers[0x00] = () => 4;
+
+    // HALT
+    this.opcodeHandlers[0x76] = () => {
+      this.halted = true;
+      return 4;
+    };
+
+    // LD r, n (immediate loads)
+    const ldRegImm = (reg) => {
+      this.registers[reg] = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      return 7;
+    };
+
+    this.opcodeHandlers[0x3e] = () => ldRegImm("A");
+    this.opcodeHandlers[0x06] = () => ldRegImm("B");
+    this.opcodeHandlers[0x0e] = () => ldRegImm("C");
+    this.opcodeHandlers[0x16] = () => ldRegImm("D");
+    this.opcodeHandlers[0x1e] = () => ldRegImm("E");
+    this.opcodeHandlers[0x26] = () => ldRegImm("H");
+    this.opcodeHandlers[0x2e] = () => ldRegImm("L");
+
+    // ADD A, r
+    this.opcodeHandlers[0x87] = () => this.addA(this.registers.A);
+    this.opcodeHandlers[0x80] = () => this.addA(this.registers.B);
+    this.opcodeHandlers[0x81] = () => this.addA(this.registers.C);
+    this.opcodeHandlers[0x82] = () => this.addA(this.registers.D);
+    this.opcodeHandlers[0x83] = () => this.addA(this.registers.E);
+    this.opcodeHandlers[0x84] = () => this.addA(this.registers.H);
+    this.opcodeHandlers[0x85] = () => this.addA(this.registers.L);
+
+    // SUB r
+    this.opcodeHandlers[0x97] = () => this.subA(this.registers.A);
+    this.opcodeHandlers[0x90] = () => this.subA(this.registers.B);
+    this.opcodeHandlers[0x91] = () => this.subA(this.registers.C);
+    this.opcodeHandlers[0x92] = () => this.subA(this.registers.D);
+    this.opcodeHandlers[0x93] = () => this.subA(this.registers.E);
+    this.opcodeHandlers[0x94] = () => this.subA(this.registers.H);
+    this.opcodeHandlers[0x95] = () => this.subA(this.registers.L);
+
+    // JP nn - unconditional jump
+    this.opcodeHandlers[0xc3] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (high << 8) | low;
+      return 10;
+    };
+
+    // JP Z, nn - conditional jump
+    this.opcodeHandlers[0xca] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+
+      if (this.flagZ) {
+        this.registers.PC = (high << 8) | low;
+      }
+      return 10;
+    };
+
+    // JP NZ, nn
+    this.opcodeHandlers[0xc2] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+
+      if (!this.flagZ) {
+        this.registers.PC = (high << 8) | low;
+      }
+      return 10;
+    };
+
+    // CP n - compare immediate
+    this.opcodeHandlers[0xfe] = () => {
+      const value = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.subA(value, true);
+      return 7;
+    };
+
+    // RET - return from subroutine
+    this.opcodeHandlers[0xc9] = () => {
+      const low = this.readMemory(this.registers.SP);
+      const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+      this.registers.SP = (this.registers.SP + 2) & 0xffff;
+      this.registers.PC = (high << 8) | low;
+      this.wz = this.registers.PC;
+      return 10;
+    };
+
+    // CALL nn - call subroutine
+    this.opcodeHandlers[0xcd] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      const targetAddr = (high << 8) | low;
+      this.wz = targetAddr;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+
+      // Push return address (little-endian)
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+
+      this.registers.PC = targetAddr;
+      return 17;
+    };
+
+    // PUSH BC
+    // Stack grows downward. Push low byte (C) first, then high byte (B)
+    this.opcodeHandlers[0xc5] = () => {
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      this.writeMemory(this.registers.SP, this.registers.B); // High byte
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      this.writeMemory(this.registers.SP, this.registers.C); // Low byte
+      return 11;
+    };
+
+    // POP BC
+    this.opcodeHandlers[0xc1] = () => {
+      this.registers.C = this.readMemory(this.registers.SP);
+      this.registers.SP = (this.registers.SP + 1) & 0xffff;
+      this.registers.B = this.readMemory(this.registers.SP);
+      this.registers.SP = (this.registers.SP + 1) & 0xffff;
+      return 10;
+    };
+
+    // PUSH DE
+    this.opcodeHandlers[0xd5] = () => {
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      this.writeMemory(this.registers.SP, this.registers.D);
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      this.writeMemory(this.registers.SP, this.registers.E);
+      return 11;
+    };
+
+    // POP DE
+    this.opcodeHandlers[0xd1] = () => {
+      this.registers.E = this.readMemory(this.registers.SP);
+      this.registers.SP = (this.registers.SP + 1) & 0xffff;
+      this.registers.D = this.readMemory(this.registers.SP);
+      this.registers.SP = (this.registers.SP + 1) & 0xffff;
+      return 10;
+    };
+
+    // PUSH HL
+    this.opcodeHandlers[0xe5] = () => {
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      this.writeMemory(this.registers.SP, this.registers.H);
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      this.writeMemory(this.registers.SP, this.registers.L);
+      return 11;
+    };
+
+    // POP HL
+    this.opcodeHandlers[0xe1] = () => {
+      this.registers.L = this.readMemory(this.registers.SP);
+      this.registers.SP = (this.registers.SP + 1) & 0xffff;
+      this.registers.H = this.readMemory(this.registers.SP);
+      this.registers.SP = (this.registers.SP + 1) & 0xffff;
+      return 10;
+    };
+
+    // LD (HL), n
+    this.opcodeHandlers[0x36] = () => {
+      const value = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.writeMemory(this.HL, value);
+      return 10;
+    };
+
+    // LD A, (HL)
+    this.opcodeHandlers[0x7e] = () => {
+      this.registers.A = this.readMemory(this.HL);
+      return 7;
+    };
+
+    // INC r
+    this.opcodeHandlers[0x3c] = () => this.incReg("A");
+    this.opcodeHandlers[0x04] = () => this.incReg("B");
+    this.opcodeHandlers[0x0c] = () => this.incReg("C");
+    this.opcodeHandlers[0x14] = () => this.incReg("D");
+    this.opcodeHandlers[0x1c] = () => this.incReg("E");
+    this.opcodeHandlers[0x24] = () => this.incReg("H");
+    this.opcodeHandlers[0x2c] = () => this.incReg("L");
+
+    // DEC r
+    this.opcodeHandlers[0x3d] = () => this.decReg("A");
+    this.opcodeHandlers[0x05] = () => this.decReg("B");
+    this.opcodeHandlers[0x0d] = () => this.decReg("C");
+    this.opcodeHandlers[0x15] = () => this.decReg("D");
+    this.opcodeHandlers[0x1d] = () => this.decReg("E");
+    this.opcodeHandlers[0x25] = () => this.decReg("H");
+    this.opcodeHandlers[0x2d] = () => this.decReg("L");
+
+    // LD BC, nn (0x01)
+    this.opcodeHandlers[0x01] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      this.BC = (high << 8) | low;
+      return 10;
+    };
+
+    // LD DE, nn (0x11)
+    this.opcodeHandlers[0x11] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      this.DE = (high << 8) | low;
+      return 10;
+    };
+
+    // LD HL, nn
+    this.opcodeHandlers[0x21] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      this.HL = (high << 8) | low;
+      return 10;
+    };
+
+    // LD SP, nn (0x31)
+    this.opcodeHandlers[0x31] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      this.registers.SP = (high << 8) | low;
+      return 10;
+    };
+
+    // LD (nn), HL (0x22)
+    this.opcodeHandlers[0x22] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      const addr = (high << 8) | low;
+      this.wz = (addr + 1) & 0xffff;
+      this.writeMemory(addr, this.registers.L);
+      this.writeMemory((addr + 1) & 0xffff, this.registers.H);
+      return 16;
+    };
+
+    // LD HL, (nn) (0x2A)
+    this.opcodeHandlers[0x2a] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      const addr = (high << 8) | low;
+      this.wz = (addr + 1) & 0xffff;
+      this.registers.L = this.readMemory(addr);
+      this.registers.H = this.readMemory((addr + 1) & 0xffff);
+      return 16;
+    };
+
+    // LD (nn), A (0x32)
+    this.opcodeHandlers[0x32] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      const addr = (high << 8) | low;
+      this.writeMemory(addr, this.registers.A);
+      this.wz = ((addr + 1) & 0xff) | (this.registers.A << 8);
+      return 13;
+    };
+
+    // LD A, (nn) (0x3A)
+    this.opcodeHandlers[0x3a] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      const addr = (high << 8) | low;
+      this.registers.A = this.readMemory(addr);
+      this.wz = (addr + 1) & 0xffff;
+      return 13;
+    };
+
+    // LD A, (BC) (0x0A)
+    this.opcodeHandlers[0x0a] = () => {
+      this.registers.A = this.readMemory(this.BC);
+      this.wz = (this.BC + 1) & 0xffff;
+      return 7;
+    };
+
+    // LD A, (DE) (0x1A)
+    this.opcodeHandlers[0x1a] = () => {
+      this.registers.A = this.readMemory(this.DE);
+      this.wz = (this.DE + 1) & 0xffff;
+      return 7;
+    };
+
+    // LD (BC), A (0x02)
+    this.opcodeHandlers[0x02] = () => {
+      this.writeMemory(this.BC, this.registers.A);
+      this.wz = ((this.BC + 1) & 0xff) | (this.registers.A << 8);
+      return 7;
+    };
+
+    // LD (DE), A (0x12)
+    this.opcodeHandlers[0x12] = () => {
+      this.writeMemory(this.DE, this.registers.A);
+      this.wz = ((this.DE + 1) & 0xff) | (this.registers.A << 8);
+      return 7;
+    };
+
+    // OUT (n), A
+    this.opcodeHandlers[0xd3] = () => {
+      const port = this.readMemory(this.registers.PC);
+      this.wz = (this.registers.A << 8) | ((port + 1) & 0xff);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.writePort(port, this.registers.A);
+      return 11;
+    };
+
+    // IN A, (n)
+    this.opcodeHandlers[0xdb] = () => {
+      const port = this.readMemory(this.registers.PC);
+      this.wz = (((this.registers.A << 8) | port) + 1) & 0xffff;
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.registers.A = this.readPort(port);
+      return 11;
+    };
+
+    // ADD A, (HL) (0x86)
+    this.opcodeHandlers[0x86] = () => {
+      this.addA(this.readMemory(this.HL));
+      return 7;
+    };
+
+    // ADC A, r (0x8F-0x8E)
+    this.opcodeHandlers[0x8f] = () => this.adcA(this.registers.A);
+    this.opcodeHandlers[0x88] = () => this.adcA(this.registers.B);
+    this.opcodeHandlers[0x89] = () => this.adcA(this.registers.C);
+    this.opcodeHandlers[0x8a] = () => this.adcA(this.registers.D);
+    this.opcodeHandlers[0x8b] = () => this.adcA(this.registers.E);
+    this.opcodeHandlers[0x8c] = () => this.adcA(this.registers.H);
+    this.opcodeHandlers[0x8d] = () => this.adcA(this.registers.L);
+    this.opcodeHandlers[0x8e] = () => {
+      this.adcA(this.readMemory(this.HL));
+      return 7;
+    };
+
+    // SBC A, r (0x9F-0x9E)
+    this.opcodeHandlers[0x9f] = () => this.sbcA(this.registers.A);
+    this.opcodeHandlers[0x98] = () => this.sbcA(this.registers.B);
+    this.opcodeHandlers[0x99] = () => this.sbcA(this.registers.C);
+    this.opcodeHandlers[0x9a] = () => this.sbcA(this.registers.D);
+    this.opcodeHandlers[0x9b] = () => this.sbcA(this.registers.E);
+    this.opcodeHandlers[0x9c] = () => this.sbcA(this.registers.H);
+    this.opcodeHandlers[0x9d] = () => this.sbcA(this.registers.L);
+    this.opcodeHandlers[0x9e] = () => {
+      this.sbcA(this.readMemory(this.HL));
+      return 7;
+    };
+
+    // SUB A, (HL) (0x96)
+    this.opcodeHandlers[0x96] = () => {
+      this.subA(this.readMemory(this.HL));
+      return 7;
+    };
+
+    // AND r (0xA0-0xA7)
+    this.opcodeHandlers[0xa7] = () => this.andA(this.registers.A);
+    this.opcodeHandlers[0xa0] = () => this.andA(this.registers.B);
+    this.opcodeHandlers[0xa1] = () => this.andA(this.registers.C);
+    this.opcodeHandlers[0xa2] = () => this.andA(this.registers.D);
+    this.opcodeHandlers[0xa3] = () => this.andA(this.registers.E);
+    this.opcodeHandlers[0xa4] = () => this.andA(this.registers.H);
+    this.opcodeHandlers[0xa5] = () => this.andA(this.registers.L);
+    this.opcodeHandlers[0xa6] = () => {
+      this.andA(this.readMemory(this.HL));
+      return 7;
+    };
+
+    // XOR r (0xA8-0xAF)
+    this.opcodeHandlers[0xaf] = () => this.xorA(this.registers.A);
+    this.opcodeHandlers[0xa8] = () => this.xorA(this.registers.B);
+    this.opcodeHandlers[0xa9] = () => this.xorA(this.registers.C);
+    this.opcodeHandlers[0xaa] = () => this.xorA(this.registers.D);
+    this.opcodeHandlers[0xab] = () => this.xorA(this.registers.E);
+    this.opcodeHandlers[0xac] = () => this.xorA(this.registers.H);
+    this.opcodeHandlers[0xad] = () => this.xorA(this.registers.L);
+    this.opcodeHandlers[0xae] = () => {
+      this.xorA(this.readMemory(this.HL));
+      return 7;
+    };
+
+    // OR r (0xB0-0xB7)
+    this.opcodeHandlers[0xb7] = () => this.orA(this.registers.A);
+    this.opcodeHandlers[0xb0] = () => this.orA(this.registers.B);
+    this.opcodeHandlers[0xb1] = () => this.orA(this.registers.C);
+    this.opcodeHandlers[0xb2] = () => this.orA(this.registers.D);
+    this.opcodeHandlers[0xb3] = () => this.orA(this.registers.E);
+    this.opcodeHandlers[0xb4] = () => this.orA(this.registers.H);
+    this.opcodeHandlers[0xb5] = () => this.orA(this.registers.L);
+    this.opcodeHandlers[0xb6] = () => {
+      this.orA(this.readMemory(this.HL));
+      return 7;
+    };
+
+    // LD r, r (0x40-0x7F) - register-to-register transfers
+    // Pattern: 0x40 | (dest << 3) | src
+    const regs = ["B", "C", "D", "E", "H", "L", null, "A"];
+    for (let dest = 0; dest < 8; dest++) {
+      for (let src = 0; src < 8; src++) {
+        if (dest === 6 || src === 6) continue; // Skip (HL) cases
+        const opcode = 0x40 | (dest << 3) | src;
+        const destReg = regs[dest];
+        const srcReg = regs[src];
+        this.opcodeHandlers[opcode] = () => {
+          this.registers[destReg] = this.registers[srcReg];
+          return 4;
+        };
+      }
+    }
+
+    // LD (HL), r (0x70-0x75)
+    this.opcodeHandlers[0x70] = () => {
+      this.writeMemory(this.HL, this.registers.B);
+      return 7;
+    };
+    this.opcodeHandlers[0x71] = () => {
+      this.writeMemory(this.HL, this.registers.C);
+      return 7;
+    };
+    this.opcodeHandlers[0x72] = () => {
+      this.writeMemory(this.HL, this.registers.D);
+      return 7;
+    };
+    this.opcodeHandlers[0x73] = () => {
+      this.writeMemory(this.HL, this.registers.E);
+      return 7;
+    };
+    this.opcodeHandlers[0x74] = () => {
+      this.writeMemory(this.HL, this.registers.H);
+      return 7;
+    };
+    this.opcodeHandlers[0x75] = () => {
+      this.writeMemory(this.HL, this.registers.L);
+      return 7;
+    };
+    this.opcodeHandlers[0x77] = () => {
+      this.writeMemory(this.HL, this.registers.A);
+      return 7;
+    };
+
+    // LD r, (HL) (0x46, 0x4E, 0x56, 0x5E, 0x66, 0x6E)
+    this.opcodeHandlers[0x46] = () => {
+      this.registers.B = this.readMemory(this.HL);
+      return 7;
+    };
+    this.opcodeHandlers[0x4e] = () => {
+      this.registers.C = this.readMemory(this.HL);
+      return 7;
+    };
+    this.opcodeHandlers[0x56] = () => {
+      this.registers.D = this.readMemory(this.HL);
+      return 7;
+    };
+    this.opcodeHandlers[0x5e] = () => {
+      this.registers.E = this.readMemory(this.HL);
+      return 7;
+    };
+    this.opcodeHandlers[0x66] = () => {
+      this.registers.H = this.readMemory(this.HL);
+      return 7;
+    };
+    this.opcodeHandlers[0x6e] = () => {
+      this.registers.L = this.readMemory(this.HL);
+      return 7;
+    };
+
+    // ADD A, n (0xC6)
+    this.opcodeHandlers[0xc6] = () => {
+      const value = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.addA(value);
+      return 7;
+    };
+
+    // ADC A, n (0xCE)
+    this.opcodeHandlers[0xce] = () => {
+      const value = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.adcA(value);
+      return 7;
+    };
+
+    // SUB A, n (0xD6)
+    this.opcodeHandlers[0xd6] = () => {
+      const value = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.subA(value);
+      return 7;
+    };
+
+    // SBC A, n (0xDE)
+    this.opcodeHandlers[0xde] = () => {
+      const value = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.sbcA(value);
+      return 7;
+    };
+
+    // AND n (0xE6)
+    this.opcodeHandlers[0xe6] = () => {
+      const value = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.andA(value);
+      return 7;
+    };
+
+    // XOR n (0xEE)
+    this.opcodeHandlers[0xee] = () => {
+      const value = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.xorA(value);
+      return 7;
+    };
+
+    // OR n (0xF6)
+    this.opcodeHandlers[0xf6] = () => {
+      const value = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.orA(value);
+      return 7;
+    };
+
+    // CP r (0xBF-0xBE)
+    this.opcodeHandlers[0xbf] = () => this.subA(this.registers.A, true);
+    this.opcodeHandlers[0xb8] = () => this.subA(this.registers.B, true);
+    this.opcodeHandlers[0xb9] = () => this.subA(this.registers.C, true);
+    this.opcodeHandlers[0xba] = () => this.subA(this.registers.D, true);
+    this.opcodeHandlers[0xbb] = () => this.subA(this.registers.E, true);
+    this.opcodeHandlers[0xbc] = () => this.subA(this.registers.H, true);
+    this.opcodeHandlers[0xbd] = () => this.subA(this.registers.L, true);
+    this.opcodeHandlers[0xbe] = () => {
+      this.subA(this.readMemory(this.HL), true);
+      return 7;
+    };
+
+    // INC (HL) (0x34)
+    this.opcodeHandlers[0x34] = () => {
+      const value = this.readMemory(this.HL);
+      const result = (value + 1) & 0xff;
+      this.writeMemory(this.HL, result);
+      this.flagZ = result === 0;
+      this.flagS = (result & 0x80) !== 0;
+      this.flagH = (value & 0x0f) === 0x0f;
+      this.flagPV = value === 0x7f;
+      this.flagN = 0;
+      this._xy(result);
+      return 11;
+    };
+
+    // DEC (HL) (0x35)
+    this.opcodeHandlers[0x35] = () => {
+      const value = this.readMemory(this.HL);
+      const result = (value - 1) & 0xff;
+      this.writeMemory(this.HL, result);
+      this.flagZ = result === 0;
+      this.flagS = (result & 0x80) !== 0;
+      this.flagH = (value & 0x0f) === 0x00;
+      this.flagPV = value === 0x80;
+      this.flagN = 1;
+      this._xy(result);
+      return 11;
+    };
+
+    // JP C, nn (0xDA)
+    this.opcodeHandlers[0xda] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (this.flagC) {
+        this.registers.PC = (high << 8) | low;
+      }
+      return 10;
+    };
+
+    // JP NC, nn (0xD2)
+    this.opcodeHandlers[0xd2] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (!this.flagC) {
+        this.registers.PC = (high << 8) | low;
+      }
+      return 10;
+    };
+
+    // JP P, nn (0xF2)
+    this.opcodeHandlers[0xf2] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (!this.flagS) {
+        this.registers.PC = (high << 8) | low;
+      }
+      return 10;
+    };
+
+    // JP M, nn (0xFA)
+    this.opcodeHandlers[0xfa] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (this.flagS) {
+        this.registers.PC = (high << 8) | low;
+      }
+      return 10;
+    };
+
+    // JP PO, nn (0xE2)
+    this.opcodeHandlers[0xe2] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (!this.flagPV) {
+        this.registers.PC = (high << 8) | low;
+      }
+      return 10;
+    };
+
+    // JP PE, nn (0xEA)
+    this.opcodeHandlers[0xea] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (this.flagPV) {
+        this.registers.PC = (high << 8) | low;
+      }
+      return 10;
+    };
+
+    // JP (HL) (0xE9)
+    this.opcodeHandlers[0xe9] = () => {
+      this.registers.PC = this.HL;
+      return 4;
+    };
+
+    // JR e (0x18) - relative jump
+    this.opcodeHandlers[0x18] = () => {
+      const offset = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      const signedOffset = offset & 0x80 ? offset - 256 : offset;
+      this.registers.PC = (this.registers.PC + signedOffset) & 0xffff;
+      this.wz = this.registers.PC;
+      return 12;
+    };
+
+    // JR Z, e (0x28)
+    this.opcodeHandlers[0x28] = () => {
+      const offset = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      if (this.flagZ) {
+        const signedOffset = offset & 0x80 ? offset - 256 : offset;
+        this.registers.PC = (this.registers.PC + signedOffset) & 0xffff;
+        this.wz = this.registers.PC;
+        return 12;
+      }
+      return 7;
+    };
+
+    // JR NZ, e (0x20)
+    this.opcodeHandlers[0x20] = () => {
+      const offset = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      if (!this.flagZ) {
+        const signedOffset = offset & 0x80 ? offset - 256 : offset;
+        this.registers.PC = (this.registers.PC + signedOffset) & 0xffff;
+        this.wz = this.registers.PC;
+        return 12;
+      }
+      return 7;
+    };
+
+    // JR C, e (0x38)
+    this.opcodeHandlers[0x38] = () => {
+      const offset = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      if (this.flagC) {
+        const signedOffset = offset & 0x80 ? offset - 256 : offset;
+        this.registers.PC = (this.registers.PC + signedOffset) & 0xffff;
+        this.wz = this.registers.PC;
+        return 12;
+      }
+      return 7;
+    };
+
+    // JR NC, e (0x30)
+    this.opcodeHandlers[0x30] = () => {
+      const offset = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      if (!this.flagC) {
+        const signedOffset = offset & 0x80 ? offset - 256 : offset;
+        this.registers.PC = (this.registers.PC + signedOffset) & 0xffff;
+        this.wz = this.registers.PC;
+        return 12;
+      }
+      return 7;
+    };
+
+    // DJNZ e (0x10)
+    this.opcodeHandlers[0x10] = () => {
+      const offset = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      this.registers.B = (this.registers.B - 1) & 0xff;
+      if (this.registers.B !== 0) {
+        const signedOffset = offset & 0x80 ? offset - 256 : offset;
+        this.registers.PC = (this.registers.PC + signedOffset) & 0xffff;
+        this.wz = this.registers.PC;
+        return 13;
+      }
+      return 8;
+    };
+
+    // RET NZ (0xC0)
+    this.opcodeHandlers[0xc0] = () => {
+      if (!this.flagZ) {
+        const low = this.readMemory(this.registers.SP);
+        const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+        this.registers.SP = (this.registers.SP + 2) & 0xffff;
+        this.registers.PC = (high << 8) | low;
+        this.wz = this.registers.PC;
+        return 11;
+      }
+      return 5;
+    };
+
+    // RET Z (0xC8)
+    this.opcodeHandlers[0xc8] = () => {
+      if (this.flagZ) {
+        const low = this.readMemory(this.registers.SP);
+        const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+        this.registers.SP = (this.registers.SP + 2) & 0xffff;
+        this.registers.PC = (high << 8) | low;
+        this.wz = this.registers.PC;
+        return 11;
+      }
+      return 5;
+    };
+
+    // RET C (0xD8)
+    this.opcodeHandlers[0xd8] = () => {
+      if (this.flagC) {
+        const low = this.readMemory(this.registers.SP);
+        const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+        this.registers.SP = (this.registers.SP + 2) & 0xffff;
+        this.registers.PC = (high << 8) | low;
+        this.wz = this.registers.PC;
+        return 11;
+      }
+      return 5;
+    };
+
+    // RET NC (0xD0)
+    this.opcodeHandlers[0xd0] = () => {
+      if (!this.flagC) {
+        const low = this.readMemory(this.registers.SP);
+        const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+        this.registers.SP = (this.registers.SP + 2) & 0xffff;
+        this.registers.PC = (high << 8) | low;
+        this.wz = this.registers.PC;
+        return 11;
+      }
+      return 5;
+    };
+
+    // RET P (0xF0)
+    this.opcodeHandlers[0xf0] = () => {
+      if (!this.flagS) {
+        const low = this.readMemory(this.registers.SP);
+        const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+        this.registers.SP = (this.registers.SP + 2) & 0xffff;
+        this.registers.PC = (high << 8) | low;
+        this.wz = this.registers.PC;
+        return 11;
+      }
+      return 5;
+    };
+
+    // RET M (0xF8)
+    this.opcodeHandlers[0xf8] = () => {
+      if (this.flagS) {
+        const low = this.readMemory(this.registers.SP);
+        const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+        this.registers.SP = (this.registers.SP + 2) & 0xffff;
+        this.registers.PC = (high << 8) | low;
+        this.wz = this.registers.PC;
+        return 11;
+      }
+      return 5;
+    };
+
+    // RET PO (0xE0)
+    this.opcodeHandlers[0xe0] = () => {
+      if (!this.flagPV) {
+        const low = this.readMemory(this.registers.SP);
+        const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+        this.registers.SP = (this.registers.SP + 2) & 0xffff;
+        this.registers.PC = (high << 8) | low;
+        this.wz = this.registers.PC;
+        return 11;
+      }
+      return 5;
+    };
+
+    // RET PE (0xE8)
+    this.opcodeHandlers[0xe8] = () => {
+      if (this.flagPV) {
+        const low = this.readMemory(this.registers.SP);
+        const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+        this.registers.SP = (this.registers.SP + 2) & 0xffff;
+        this.registers.PC = (high << 8) | low;
+        this.wz = this.registers.PC;
+        return 11;
+      }
+      return 5;
+    };
+
+    // CALL Z, nn (0xCC)
+    this.opcodeHandlers[0xcc] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (this.flagZ) {
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+        this.registers.PC = (high << 8) | low;
+        return 17;
+      }
+      return 10;
+    };
+
+    // CALL NZ, nn (0xC4)
+    this.opcodeHandlers[0xc4] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (!this.flagZ) {
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+        this.registers.PC = (high << 8) | low;
+        return 17;
+      }
+      return 10;
+    };
+
+    // CALL C, nn (0xDC)
+    this.opcodeHandlers[0xdc] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (this.flagC) {
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+        this.registers.PC = (high << 8) | low;
+        return 17;
+      }
+      return 10;
+    };
+
+    // CALL NC, nn (0xD4)
+    this.opcodeHandlers[0xd4] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (!this.flagC) {
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+        this.registers.PC = (high << 8) | low;
+        return 17;
+      }
+      return 10;
+    };
+
+    // CALL P, nn (0xF4)
+    this.opcodeHandlers[0xf4] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (!this.flagS) {
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+        this.registers.PC = (high << 8) | low;
+        return 17;
+      }
+      return 10;
+    };
+
+    // CALL M, nn (0xFC)
+    this.opcodeHandlers[0xfc] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (this.flagS) {
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+        this.registers.PC = (high << 8) | low;
+        return 17;
+      }
+      return 10;
+    };
+
+    // CALL PO, nn (0xE4)
+    this.opcodeHandlers[0xe4] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (!this.flagPV) {
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+        this.registers.PC = (high << 8) | low;
+        return 17;
+      }
+      return 10;
+    };
+
+    // CALL PE, nn (0xEC)
+    this.opcodeHandlers[0xec] = () => {
+      const low = this.readMemory(this.registers.PC);
+      const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+      this.wz = (high << 8) | low;
+      this.registers.PC = (this.registers.PC + 2) & 0xffff;
+      if (this.flagPV) {
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+        this.registers.PC = (high << 8) | low;
+        return 17;
+      }
+      return 10;
+    };
+
+    // RST p (0xC7-0xFF, step 8)
+    for (let i = 0; i < 8; i++) {
+      const opcode = 0xc7 | (i << 3);
+      const addr = i * 8;
+      this.opcodeHandlers[opcode] = () => {
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, (this.registers.PC >> 8) & 0xff);
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, this.registers.PC & 0xff);
+        this.registers.PC = addr;
+        this.wz = addr;
+        return 11;
+      };
+    }
+
+    // DI (0xF3)
+    this.opcodeHandlers[0xf3] = () => {
+      this.IFF1 = false;
+      this.IFF2 = false;
+      this.pendingEI = 0; // a DI right after EI wins
+      return 4;
+    };
+
+    // EI (0xFB) - takes effect after the NEXT instruction completes, so
+    // an EI;RETI pair can't be interrupted between the two instructions.
+    this.opcodeHandlers[0xfb] = () => {
+      this.pendingEI = 2;
+      return 4;
+    };
+
+    // SCF (0x37) - Set Carry Flag
+    this.opcodeHandlers[0x37] = () => {
+      this.flagC = true;
+      this.flagH = false;
+      this.flagN = false;
+      this._xy(this.registers.A);
+      return 4;
+    };
+
+    // CCF (0x3F) - Complement Carry Flag; H receives the previous carry
+    this.opcodeHandlers[0x3f] = () => {
+      const oldCarry = this.flagC;
+      this.flagC = !oldCarry;
+      this.flagH = oldCarry;
+      this.flagN = false;
+      this._xy(this.registers.A);
+      return 4;
+    };
+
+    // CPL (0x2F) - Complement Accumulator
+    this.opcodeHandlers[0x2f] = () => {
+      this.registers.A = ~this.registers.A & 0xff;
+      this.flagH = true;
+      this.flagN = true;
+      this._xy(this.registers.A);
+      return 4;
+    };
+
+    // DAA (0x27) - Decimal Adjust Accumulator (canonical N/H/C correction)
+    this.opcodeHandlers[0x27] = () => {
+      const before = this.registers.A;
+      let correction = 0;
+      let carry = this.flagC ? 1 : 0;
+
+      if (this.flagH || (before & 0x0f) > 9) {
+        correction = 0x06;
+      }
+      if (carry || before > 0x99) {
+        correction |= 0x60;
+        carry = 1;
+      }
+
+      const a = this.flagN
+        ? (before - correction) & 0xff
+        : (before + correction) & 0xff;
+
+      // H after DAA: for additions, carry out of bit 3 of the correction
+      // step; for subtractions, only when the low nibble borrows.
+      this.flagH = this.flagN
+        ? this.flagH && (before & 0x0f) < 0x06
+        : (before & 0x0f) + (correction & 0x0f) > 0x0f;
+      this.flagC = carry;
+      this.registers.A = a;
+      this.flagZ = a === 0;
+      this.flagS = (a & 0x80) !== 0;
+      this.flagPV = this.parity(a);
+      this._xy(a);
+      return 4;
+    };
+
+    // RLCA (0x07)
+    this.opcodeHandlers[0x07] = () => {
+      const a = this.registers.A;
+      this.flagC = (a & 0x80) !== 0;
+      this.registers.A = ((a << 1) | (a >> 7)) & 0xff;
+      this.flagH = false;
+      this.flagN = false;
+      this._xy(this.registers.A);
+      return 4;
+    };
+
+    // RLA (0x17)
+    this.opcodeHandlers[0x17] = () => {
+      const a = this.registers.A;
+      const carry = this.flagC ? 1 : 0;
+      this.flagC = (a & 0x80) !== 0;
+      this.registers.A = ((a << 1) | carry) & 0xff;
+      this.flagH = false;
+      this.flagN = false;
+      this._xy(this.registers.A);
+      return 4;
+    };
+
+    // RRCA (0x0F)
+    this.opcodeHandlers[0x0f] = () => {
+      const a = this.registers.A;
+      this.flagC = (a & 0x01) !== 0;
+      this.registers.A = ((a >> 1) | (a << 7)) & 0xff;
+      this.flagH = false;
+      this.flagN = false;
+      this._xy(this.registers.A);
+      return 4;
+    };
+
+    // RRA (0x1F)
+    this.opcodeHandlers[0x1f] = () => {
+      const a = this.registers.A;
+      const carry = this.flagC ? 0x80 : 0;
+      this.flagC = (a & 0x01) !== 0;
+      this.registers.A = ((a >> 1) | carry) & 0xff;
+      this.flagH = false;
+      this.flagN = false;
+      this._xy(this.registers.A);
+      return 4;
+    };
+
+    // EX DE, HL (0xEB)
+    this.opcodeHandlers[0xeb] = () => {
+      const temp = this.DE;
+      this.DE = this.HL;
+      this.HL = temp;
+      return 4;
+    };
+
+    // EX AF, AF' (0x08)
+    this.opcodeHandlers[0x08] = () => {
+      const tempA = this.registers.A;
+      const tempF = this.registers.F;
+      this.registers.A = this.registers.A_;
+      this.registers.F = this.registers.F_;
+      this.registers.A_ = tempA;
+      this.registers.F_ = tempF;
+      return 4;
+    };
+
+    // EX (SP), HL (0xE3)
+    this.opcodeHandlers[0xe3] = () => {
+      const low = this.readMemory(this.registers.SP);
+      const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+      const temp = (high << 8) | low;
+      this.writeMemory(this.registers.SP, this.registers.L);
+      this.writeMemory((this.registers.SP + 1) & 0xffff, this.registers.H);
+      this.HL = temp;
+      this.wz = temp;
+      return 19;
+    };
+
+    // EXX (0xD9)
+    this.opcodeHandlers[0xd9] = () => {
+      const tempB = this.registers.B;
+      const tempC = this.registers.C;
+      const tempD = this.registers.D;
+      const tempE = this.registers.E;
+      const tempH = this.registers.H;
+      const tempL = this.registers.L;
+      this.registers.B = this.registers.B_;
+      this.registers.C = this.registers.C_;
+      this.registers.D = this.registers.D_;
+      this.registers.E = this.registers.E_;
+      this.registers.H = this.registers.H_;
+      this.registers.L = this.registers.L_;
+      this.registers.B_ = tempB;
+      this.registers.C_ = tempC;
+      this.registers.D_ = tempD;
+      this.registers.E_ = tempE;
+      this.registers.H_ = tempH;
+      this.registers.L_ = tempL;
+      return 4;
+    };
+
+    // ADD HL, BC (0x09)
+    this.opcodeHandlers[0x09] = () => {
+      this.addHL(this.BC);
+      return 11;
+    };
+
+    // ADD HL, DE (0x19)
+    this.opcodeHandlers[0x19] = () => {
+      this.addHL(this.DE);
+      return 11;
+    };
+
+    // ADD HL, HL (0x29)
+    this.opcodeHandlers[0x29] = () => {
+      this.addHL(this.HL);
+      return 11;
+    };
+
+    // ADD HL, SP (0x39)
+    this.opcodeHandlers[0x39] = () => {
+      this.addHL(this.registers.SP);
+      return 11;
+    };
+
+    // PUSH AF (0xF5)
+    this.opcodeHandlers[0xf5] = () => {
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      this.writeMemory(this.registers.SP, this.registers.A);
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      this.writeMemory(this.registers.SP, this.registers.F);
+      return 11;
+    };
+
+    // POP AF (0xF1)
+    this.opcodeHandlers[0xf1] = () => {
+      this.registers.F = this.readMemory(this.registers.SP);
+      this.registers.SP = (this.registers.SP + 1) & 0xffff;
+      this.registers.A = this.readMemory(this.registers.SP);
+      this.registers.SP = (this.registers.SP + 1) & 0xffff;
+      return 10;
+    };
+
+    // INC BC (0x03)
+    this.opcodeHandlers[0x03] = () => {
+      this.BC = (this.BC + 1) & 0xffff;
+      return 6;
+    };
+
+    // INC DE (0x13)
+    this.opcodeHandlers[0x13] = () => {
+      this.DE = (this.DE + 1) & 0xffff;
+      return 6;
+    };
+
+    // INC HL (0x23)
+    this.opcodeHandlers[0x23] = () => {
+      this.HL = (this.HL + 1) & 0xffff;
+      return 6;
+    };
+
+    // INC SP (0x33)
+    this.opcodeHandlers[0x33] = () => {
+      this.registers.SP = (this.registers.SP + 1) & 0xffff;
+      return 6;
+    };
+
+    // DEC BC (0x0B)
+    this.opcodeHandlers[0x0b] = () => {
+      this.BC = (this.BC - 1) & 0xffff;
+      return 6;
+    };
+
+    // DEC DE (0x1B)
+    this.opcodeHandlers[0x1b] = () => {
+      this.DE = (this.DE - 1) & 0xffff;
+      return 6;
+    };
+
+    // DEC HL (0x2B)
+    this.opcodeHandlers[0x2b] = () => {
+      this.HL = (this.HL - 1) & 0xffff;
+      return 6;
+    };
+
+    // DEC SP (0x3B)
+    this.opcodeHandlers[0x3b] = () => {
+      this.registers.SP = (this.registers.SP - 1) & 0xffff;
+      return 6;
+    };
+
+    // LD SP, HL (0xF9)
+    this.opcodeHandlers[0xf9] = () => {
+      this.registers.SP = this.HL;
+      return 6;
+    };
+  }
+
+  // Extended instruction handlers - ALL must be fully implemented
+  executeCB() {
+    const opcode = this.readMemory(this.registers.PC);
+    this.registers.PC = (this.registers.PC + 1) & 0xffff;
+
+    // CB instructions (bit operations, rotates, shifts)
+    // Pattern: opcode = base | (register << 3) | register
+    // Register mapping: 0=B, 1=C, 2=D, 3=E, 4=H, 5=L, 6=(HL), 7=A
+
+    const regs = ["B", "C", "D", "E", "H", "L", null, "A"];
+    const reg = opcode & 0x07;
+    const base = opcode & 0xf8;
+
+    if (reg === 6) {
+      // (HL) operations - 15 cycles
+      switch (base) {
+        case 0x00: // RLC (HL)
+          return this.rlcMem(this.HL);
+        case 0x08: // RRC (HL)
+          return this.rrcMem(this.HL);
+        case 0x10: // RL (HL)
+          return this.rlMem(this.HL);
+        case 0x18: // RR (HL)
+          return this.rrMem(this.HL);
+        case 0x20: // SLA (HL)
+          return this.slaMem(this.HL);
+        case 0x28: // SRA (HL)
+          return this.sraMem(this.HL);
+        case 0x30: // SLL (HL) - undocumented
+          return this.sllMem(this.HL);
+        case 0x38: // SRL (HL)
+          return this.srlMem(this.HL);
+        case 0x40:
+        case 0x48:
+        case 0x50:
+        case 0x58:
+        case 0x60:
+        case 0x68:
+        case 0x70:
+        case 0x78: // BIT n, (HL)
+          return this.bitMem(this.HL, (base >> 3) & 0x07);
+        case 0x80:
+        case 0x88:
+        case 0x90:
+        case 0x98:
+        case 0xa0:
+        case 0xa8:
+        case 0xb0:
+        case 0xb8: // RES n, (HL)
+          return this.resMem(this.HL, (base >> 3) & 0x07);
+        case 0xc0:
+        case 0xc8:
+        case 0xd0:
+        case 0xd8:
+        case 0xe0:
+        case 0xe8:
+        case 0xf0:
+        case 0xf8: // SET n, (HL)
+          return this.setMem(this.HL, (base >> 3) & 0x07);
+        default:
+          if (!this.unimplementedOpcodes.has(0xcb00 | opcode)) {
+            this.unimplementedOpcodes.add(0xcb00 | opcode);
+            this.log("warn",
+              `Unimplemented CB opcode: 0xCB 0x${opcode
+                .toString(16)
+                .toUpperCase()
+                .padStart(2, "0")}`
+            );
+          }
+          return 8;
+      }
+    } else {
+      // Register operations - 8 cycles
+      const regName = regs[reg];
+      switch (base) {
+        case 0x00: // RLC r
+          return this.rlcReg(regName);
+        case 0x08: // RRC r
+          return this.rrcReg(regName);
+        case 0x10: // RL r
+          return this.rlReg(regName);
+        case 0x18: // RR r
+          return this.rrReg(regName);
+        case 0x20: // SLA r
+          return this.slaReg(regName);
+        case 0x28: // SRA r
+          return this.sraReg(regName);
+        case 0x30: // SLL r - undocumented
+          return this.sllReg(regName);
+        case 0x38: // SRL r
+          return this.srlReg(regName);
+        case 0x40:
+        case 0x48:
+        case 0x50:
+        case 0x58:
+        case 0x60:
+        case 0x68:
+        case 0x70:
+        case 0x78: // BIT n, r
+          return this.bitReg(regName, (base >> 3) & 0x07);
+        case 0x80:
+        case 0x88:
+        case 0x90:
+        case 0x98:
+        case 0xa0:
+        case 0xa8:
+        case 0xb0:
+        case 0xb8: // RES n, r
+          return this.resReg(regName, (base >> 3) & 0x07);
+        case 0xc0:
+        case 0xc8:
+        case 0xd0:
+        case 0xd8:
+        case 0xe0:
+        case 0xe8:
+        case 0xf0:
+        case 0xf8: // SET n, r
+          return this.setReg(regName, (base >> 3) & 0x07);
+        default:
+          if (!this.unimplementedOpcodes.has(0xcb00 | opcode)) {
+            this.unimplementedOpcodes.add(0xcb00 | opcode);
+            this.log("warn",
+              `Unimplemented CB opcode: 0xCB 0x${opcode
+                .toString(16)
+                .toUpperCase()
+                .padStart(2, "0")}`
+            );
+          }
+          return 8;
+      }
+    }
+  }
+
+  executeED() {
+    const opcode = this.readMemory(this.registers.PC);
+    this.registers.PC = (this.registers.PC + 1) & 0xffff;
+
+    // ED instructions (extended instructions, block operations, I/O)
+    switch (opcode) {
+      // Block Transfer Instructions
+      case 0xa0: // LDI
+        return this.ldi();
+      case 0xb0: // LDIR
+        return this.ldir();
+      case 0xa8: // LDD
+        return this.ldd();
+      case 0xb8: // LDDR
+        return this.lddr();
+
+      // Nibble Rotation Instructions
+      case 0x6f: // RLD
+        return this.rld();
+      case 0x67: // RRD
+        return this.rrd();
+
+      // Block Compare Instructions
+      case 0xa1: // CPI
+        return this.cpi();
+      case 0xb1: // CPIR
+        return this.cpir();
+      case 0xa9: // CPD
+        return this.cpd();
+      case 0xb9: // CPDR
+        return this.cpdr();
+
+      // Block Input Instructions
+      case 0xa2: // INI
+        return this.ini();
+      case 0xb2: // INIR
+        return this.inir();
+      case 0xaa: // IND
+        return this.ind();
+      case 0xba: // INDR
+        return this.indr();
+
+      // Block Output Instructions
+      case 0xa3: // OUTI
+        return this.outi();
+      case 0xb3: // OTIR
+        return this.otir();
+      case 0xab: // OUTD
+        return this.outd();
+      case 0xbb: // OTDR
+        return this.otdr();
+
+      // Extended Load Instructions
+      case 0x47: // LD I, A
+        this.registers.I = this.registers.A;
+        return 9;
+      case 0x4f: // LD R, A
+        this.registers.R = this.registers.A;
+        return 9;
+      case 0x57: // LD A, I
+        this.registers.A = this.registers.I;
+        this.flagZ = this.registers.A === 0;
+        this.flagS = (this.registers.A & 0x80) !== 0;
+        this.flagH = false;
+        this.flagPV = this.IFF2;
+        this.flagN = false;
+        this._xy(this.registers.A);
+        return 9;
+      case 0x5f: // LD A, R
+        this.registers.A = this.registers.R;
+        this.flagZ = this.registers.A === 0;
+        this.flagS = (this.registers.A & 0x80) !== 0;
+        this.flagH = false;
+        this.flagPV = this.IFF2;
+        this.flagN = false;
+        this._xy(this.registers.A);
+        return 9;
+
+      // 16-bit Load Instructions
+      case 0x4b: // LD BC, (nn)
+        return this.ldBCnn();
+      case 0x5b: // LD DE, (nn)
+        return this.ldDEnn();
+      case 0x6b: // LD HL, (nn) - alternative encoding
+        return this.ldHLnn();
+      case 0x7b: // LD SP, (nn)
+        return this.ldSPnn();
+      case 0x43: // LD (nn), BC
+        return this.ldnnBC();
+      case 0x53: // LD (nn), DE
+        return this.ldnnDE();
+      case 0x63: // LD (nn), HL - alternative encoding
+        return this.ldnnHL();
+      case 0x73: // LD (nn), SP
+        return this.ldnnSP();
+
+      // Extended Arithmetic
+      case 0x4a: // ADC HL, BC
+        return this.adcHL(this.BC);
+      case 0x5a: // ADC HL, DE
+        return this.adcHL(this.DE);
+      case 0x6a: // ADC HL, HL
+        return this.adcHL(this.HL);
+      case 0x7a: // ADC HL, SP
+        return this.adcHL(this.registers.SP);
+      case 0x42: // SBC HL, BC
+        return this.sbcHL(this.BC);
+      case 0x52: // SBC HL, DE
+        return this.sbcHL(this.DE);
+      case 0x62: // SBC HL, HL
+        return this.sbcHL(this.HL);
+      case 0x72: // SBC HL, SP
+        return this.sbcHL(this.registers.SP);
+
+      // NEG and its duplicates
+      case 0x44:
+      case 0x4c:
+      case 0x54:
+      case 0x5c:
+      case 0x64:
+      case 0x6c:
+      case 0x74:
+      case 0x7c:
+        return this.neg();
+
+      // I/O Instructions
+      case 0x40:
+      case 0x48:
+      case 0x50:
+      case 0x58:
+      case 0x60:
+      case 0x68:
+      case 0x70:
+      case 0x78: // IN r, (C)
+        return this.inrC((opcode >> 3) & 0x07);
+      case 0x41:
+      case 0x49:
+      case 0x51:
+      case 0x59:
+      case 0x61:
+      case 0x69:
+      case 0x71:
+      case 0x79: // OUT (C), r
+        return this.outCr((opcode >> 3) & 0x07);
+
+      // Return Instructions
+      case 0x4d: // RETI
+        return this.reti();
+      case 0x55:
+      case 0x5d:
+      case 0x65:
+      case 0x6d:
+      case 0x75:
+      case 0x7d:
+      case 0x45: // RETN
+        return this.retn();
+
+      // Interrupt Mode
+      case 0x4e:
+      case 0x66:
+      case 0x6e:
+      case 0x46: // IM 0
+        this.interruptMode = 0;
+        return 8;
+      case 0x76:
+      case 0x56: // IM 1
+        this.interruptMode = 1;
+        return 8;
+      case 0x7e:
+      case 0x5e: // IM 2
+        this.interruptMode = 2;
+        return 8;
+
+      // Every other ED opcode does nothing for 8 T-states (Young §3.3)
+      default:
+        return 8;
+    }
+  }
+
+  executeDD() {
+    const opcode = this.readMemory(this.registers.PC);
+    // Before another prefix or ED, DD is a 4-T-state no-op: leave PC on that byte, which starts
+    // the next step, and take no maskable interrupt before it (Young §3.6).
+    if (opcode === 0xdd || opcode === 0xfd || opcode === 0xed) {
+      this.afterPrefix = true;
+      return 4;
+    }
+    this.registers.PC = (this.registers.PC + 1) & 0xffff;
+    this.incrementR(); // the second opcode fetch
+
+    // DD instructions (IX register operations)
+    // Most DD instructions mirror HL instructions but use IX
+    // Special cases: DD CB d opcode - indexed CB operations
+    if (opcode === 0xcb) {
+      // DD CB d opcode - indexed CB operation
+      const disp = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      const cbOpcode = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      const addr = (this.IX + (disp & 0x80 ? disp - 256 : disp)) & 0xffff;
+      return this.executeIndexedCB(addr, cbOpcode);
+    }
+
+    // Standard DD instructions - delegate to helper
+    return this.executeIndexReg(opcode, "IX");
+  }
+
+  executeFD() {
+    const opcode = this.readMemory(this.registers.PC);
+    // Before another prefix or ED, FD is a 4-T-state no-op: leave PC on that byte, which starts
+    // the next step, and take no maskable interrupt before it (Young §3.6).
+    if (opcode === 0xdd || opcode === 0xfd || opcode === 0xed) {
+      this.afterPrefix = true;
+      return 4;
+    }
+    this.registers.PC = (this.registers.PC + 1) & 0xffff;
+    this.incrementR(); // the second opcode fetch
+
+    // FD instructions (IY register operations)
+    // Most FD instructions mirror HL instructions but use IY
+    // Special cases: FD CB d opcode - indexed CB operations
+    if (opcode === 0xcb) {
+      // FD CB d opcode - indexed CB operation
+      const disp = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      const cbOpcode = this.readMemory(this.registers.PC);
+      this.registers.PC = (this.registers.PC + 1) & 0xffff;
+      const addr = (this.IY + (disp & 0x80 ? disp - 256 : disp)) & 0xffff;
+      return this.executeIndexedCB(addr, cbOpcode);
+    }
+
+    // Standard FD instructions - delegate to helper
+    return this.executeIndexReg(opcode, "IY");
+  }
+
+  // Arithmetic methods
+  /**
+   * Add a value to the accumulator (A register) with flag updates
+   */
+  addA(value, withCarry = false) {
+    const a = this.registers.A;
+    const carry = withCarry && this.flagC ? 1 : 0;
+    const result = a + value + carry;
+
+    this.flagC = result > 0xff;
+    // Half-carry: carry out of bit 3 in the nibble sum
+    this.flagH = (a & 0x0f) + (value & 0x0f) + carry > 0x0f;
+    this.flagN = 0;
+    this.registers.A = result & 0xff;
+    this.flagZ = this.registers.A === 0;
+    this.flagS = (this.registers.A & 0x80) !== 0;
+    // Parity/Overflow: signed overflow
+    const signedA = a & 0x80 ? a - 256 : a;
+    const signedValue = value & 0x80 ? value - 256 : value;
+    const signedResult = signedA + signedValue + carry;
+    this.flagPV = signedResult < -128 || signedResult > 127;
+    this._xy(this.registers.A);
+
+    return 4;
+  }
+
+  /**
+   * Subtract a value from the accumulator with flag updates
+   */
+  subA(value, compare = false) {
+    const a = this.registers.A;
+    const result = a - value;
+
+    this.flagC = result < 0;
+    this.flagH = (a & 0x0f) - (value & 0x0f) < 0;
+    this.flagN = 1;
+
+    if (!compare) {
+      this.registers.A = result & 0xff;
+    }
+
+    const finalResult = result & 0xff;
+    this.flagZ = finalResult === 0;
+    this.flagS = (finalResult & 0x80) !== 0;
+    this.flagPV = ((a ^ value) & (a ^ finalResult) & 0x80) !== 0;
+    // CP is the X/Y exception: bits 3/5 come from the operand
+    this._xy(compare ? value : finalResult);
+
+    return 4;
+  }
+
+  /**
+   * Increment a register with flag updates (except carry)
+   */
+  incReg(reg) {
+    const value = this.registers[reg];
+    const result = (value + 1) & 0xff;
+
+    this.registers[reg] = result;
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagH = (value & 0x0f) === 0x0f;
+    this.flagPV = value === 0x7f;
+    this.flagN = 0;
+    this._xy(result);
+
+    return 4;
+  }
+
+  /**
+   * Decrement a register with flag updates (except carry)
+   */
+  decReg(reg) {
+    const value = this.registers[reg];
+    const result = (value - 1) & 0xff;
+
+    this.registers[reg] = result;
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagH = (value & 0x0f) === 0x00;
+    this.flagPV = value === 0x80;
+    this.flagN = 1;
+    this._xy(result);
+
+    return 4;
+  }
+
+  /**
+   * Add with carry (ADC)
+   */
+  adcA(value) {
+    return this.addA(value, true);
+  }
+
+  /**
+   * Subtract with carry (SBC)
+   */
+  sbcA(value) {
+    const a = this.registers.A;
+    const carry = this.flagC ? 1 : 0;
+    const result = a - value - carry;
+
+    this.flagC = result < 0;
+    this.flagH = (a & 0x0f) - (value & 0x0f) - carry < 0;
+    this.flagN = 1;
+
+    this.registers.A = result & 0xff;
+    const finalResult = result & 0xff;
+    this.flagZ = finalResult === 0;
+    this.flagS = (finalResult & 0x80) !== 0;
+    this.flagPV = ((a ^ value) & (a ^ finalResult) & 0x80) !== 0;
+    this._xy(finalResult);
+
+    return 4;
+  }
+
+  /**
+   * AND operation
+   */
+  andA(value) {
+    this.registers.A = this.registers.A & value;
+    this.flagZ = this.registers.A === 0;
+    this.flagS = (this.registers.A & 0x80) !== 0;
+    this.flagH = true;
+    this.flagPV = this.parity(this.registers.A);
+    this.flagN = 0;
+    this.flagC = false;
+    this._xy(this.registers.A);
+    return 4;
+  }
+
+  /**
+   * OR operation
+   */
+  orA(value) {
+    this.registers.A = this.registers.A | value;
+    this.flagZ = this.registers.A === 0;
+    this.flagS = (this.registers.A & 0x80) !== 0;
+    this.flagH = false;
+    this.flagPV = this.parity(this.registers.A);
+    this.flagN = 0;
+    this.flagC = false;
+    this._xy(this.registers.A);
+    return 4;
+  }
+
+  /**
+   * XOR operation
+   */
+  xorA(value) {
+    this.registers.A = this.registers.A ^ value;
+    this.flagZ = this.registers.A === 0;
+    this.flagS = (this.registers.A & 0x80) !== 0;
+    this.flagH = false;
+    this.flagPV = this.parity(this.registers.A);
+    this.flagN = 0;
+    this.flagC = false;
+    this._xy(this.registers.A);
+    return 4;
+  }
+
+  /**
+   * Calculate parity (even parity)
+   */
+  parity(value) {
+    let p = 0;
+    for (let i = 0; i < 8; i++) {
+      if (value & (1 << i)) p++;
+    }
+    return (p & 1) === 0 ? 1 : 0;
+  }
+
+  /**
+   * Add 16-bit value to HL
+   */
+  addHL(value) {
+    const hl = this.HL;
+    const result = hl + value;
+    this.flagC = result > 0xffff;
+    this.flagH = (hl & 0x0fff) + (value & 0x0fff) > 0x0fff;
+    this.flagN = false;
+    this.HL = result & 0xffff;
+    this.wz = (hl + 1) & 0xffff;
+    this._xy(this.HL >> 8); // 16-bit ops take X/Y from the high byte
+    return 4;
+  }
+
+  // CB prefix helper methods
+  rlcReg(reg) {
+    const value = this.registers[reg];
+    this.flagC = (value & 0x80) !== 0;
+    this.registers[reg] = ((value << 1) | (value >> 7)) & 0xff;
+    this.flagZ = this.registers[reg] === 0;
+    this.flagS = (this.registers[reg] & 0x80) !== 0;
+    this.flagPV = this.parity(this.registers[reg]);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(this.registers[reg]);
+    return 8;
+  }
+
+  rlcMem(addr) {
+    const value = this.readMemory(addr);
+    this.flagC = (value & 0x80) !== 0;
+    const result = ((value << 1) | (value >> 7)) & 0xff;
+    this.writeMemory(addr, result);
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagPV = this.parity(result);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(result);
+    return 15;
+  }
+
+  rrcReg(reg) {
+    const value = this.registers[reg];
+    this.flagC = (value & 0x01) !== 0;
+    this.registers[reg] = ((value >> 1) | (value << 7)) & 0xff;
+    this.flagZ = this.registers[reg] === 0;
+    this.flagS = (this.registers[reg] & 0x80) !== 0;
+    this.flagPV = this.parity(this.registers[reg]);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(this.registers[reg]);
+    return 8;
+  }
+
+  rrcMem(addr) {
+    const value = this.readMemory(addr);
+    this.flagC = (value & 0x01) !== 0;
+    const result = ((value >> 1) | (value << 7)) & 0xff;
+    this.writeMemory(addr, result);
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagPV = this.parity(result);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(result);
+    return 15;
+  }
+
+  rlReg(reg) {
+    const value = this.registers[reg];
+    const carry = this.flagC ? 1 : 0;
+    this.flagC = (value & 0x80) !== 0;
+    this.registers[reg] = ((value << 1) | carry) & 0xff;
+    this.flagZ = this.registers[reg] === 0;
+    this.flagS = (this.registers[reg] & 0x80) !== 0;
+    this.flagPV = this.parity(this.registers[reg]);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(this.registers[reg]);
+    return 8;
+  }
+
+  rlMem(addr) {
+    const value = this.readMemory(addr);
+    const carry = this.flagC ? 1 : 0;
+    this.flagC = (value & 0x80) !== 0;
+    const result = ((value << 1) | carry) & 0xff;
+    this.writeMemory(addr, result);
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagPV = this.parity(result);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(result);
+    return 15;
+  }
+
+  rrReg(reg) {
+    const value = this.registers[reg];
+    const carry = this.flagC ? 0x80 : 0;
+    this.flagC = (value & 0x01) !== 0;
+    this.registers[reg] = ((value >> 1) | carry) & 0xff;
+    this.flagZ = this.registers[reg] === 0;
+    this.flagS = (this.registers[reg] & 0x80) !== 0;
+    this.flagPV = this.parity(this.registers[reg]);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(this.registers[reg]);
+    return 8;
+  }
+
+  rrMem(addr) {
+    const value = this.readMemory(addr);
+    const carry = this.flagC ? 0x80 : 0;
+    this.flagC = (value & 0x01) !== 0;
+    const result = ((value >> 1) | carry) & 0xff;
+    this.writeMemory(addr, result);
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagPV = this.parity(result);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(result);
+    return 15;
+  }
+
+  slaReg(reg) {
+    const value = this.registers[reg];
+    this.flagC = (value & 0x80) !== 0;
+    this.registers[reg] = (value << 1) & 0xff;
+    this.flagZ = this.registers[reg] === 0;
+    this.flagS = (this.registers[reg] & 0x80) !== 0;
+    this.flagPV = this.parity(this.registers[reg]);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(this.registers[reg]);
+    return 8;
+  }
+
+  slaMem(addr) {
+    const value = this.readMemory(addr);
+    this.flagC = (value & 0x80) !== 0;
+    const result = (value << 1) & 0xff;
+    this.writeMemory(addr, result);
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagPV = this.parity(result);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(result);
+    return 15;
+  }
+
+  sraReg(reg) {
+    const value = this.registers[reg];
+    this.flagC = (value & 0x01) !== 0;
+    this.registers[reg] = ((value >> 1) | (value & 0x80)) & 0xff;
+    this.flagZ = this.registers[reg] === 0;
+    this.flagS = (this.registers[reg] & 0x80) !== 0;
+    this.flagPV = this.parity(this.registers[reg]);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(this.registers[reg]);
+    return 8;
+  }
+
+  sraMem(addr) {
+    const value = this.readMemory(addr);
+    this.flagC = (value & 0x01) !== 0;
+    const result = ((value >> 1) | (value & 0x80)) & 0xff;
+    this.writeMemory(addr, result);
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagPV = this.parity(result);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(result);
+    return 15;
+  }
+
+  sllReg(reg) {
+    const value = this.registers[reg];
+    this.flagC = (value & 0x80) !== 0;
+    this.registers[reg] = ((value << 1) | 1) & 0xff;
+    this.flagZ = this.registers[reg] === 0;
+    this.flagS = (this.registers[reg] & 0x80) !== 0;
+    this.flagPV = this.parity(this.registers[reg]);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(this.registers[reg]);
+    return 8;
+  }
+
+  sllMem(addr) {
+    const value = this.readMemory(addr);
+    this.flagC = (value & 0x80) !== 0;
+    const result = ((value << 1) | 1) & 0xff;
+    this.writeMemory(addr, result);
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagPV = this.parity(result);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(result);
+    return 15;
+  }
+
+  srlReg(reg) {
+    const value = this.registers[reg];
+    this.flagC = (value & 0x01) !== 0;
+    this.registers[reg] = (value >> 1) & 0xff;
+    this.flagZ = this.registers[reg] === 0;
+    this.flagS = false;
+    this.flagPV = this.parity(this.registers[reg]);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(this.registers[reg]);
+    return 8;
+  }
+
+  srlMem(addr) {
+    const value = this.readMemory(addr);
+    this.flagC = (value & 0x01) !== 0;
+    const result = (value >> 1) & 0xff;
+    this.writeMemory(addr, result);
+    this.flagZ = result === 0;
+    this.flagS = false;
+    this.flagPV = this.parity(result);
+    this.flagH = false;
+    this.flagN = false;
+    this._xy(result);
+    return 15;
+  }
+
+  bitReg(reg, bit) {
+    const value = this.registers[reg];
+    const bitValue = (value >> bit) & 1;
+    this.flagZ = bitValue === 0;
+    this.flagS = bit === 7 ? bitValue : false;
+    this.flagH = true;
+    this.flagPV = bitValue === 0;
+    this.flagN = false;
+    this._xy(value);
+    return 8;
+  }
+
+  bitMem(addr, bit) {
+    const value = this.readMemory(addr);
+    const bitValue = (value >> bit) & 1;
+    this.flagZ = bitValue === 0;
+    this.flagS = bit === 7 ? bitValue : false;
+    this.flagH = true;
+    this.flagPV = bitValue === 0;
+    this.flagN = false;
+    // BIT n,(HL) exposes MEMPTR's high byte; the DD/FD CB caller sets
+    // wz = IX+d first, which makes the indexed form come out right too.
+    this._xy(this.wz >> 8);
+    return 12;
+  }
+
+  resReg(reg, bit) {
+    this.registers[reg] = this.registers[reg] & ~(1 << bit);
+    return 8;
+  }
+
+  resMem(addr, bit) {
+    const value = this.readMemory(addr);
+    this.writeMemory(addr, value & ~(1 << bit));
+    return 15;
+  }
+
+  setReg(reg, bit) {
+    this.registers[reg] = this.registers[reg] | (1 << bit);
+    return 8;
+  }
+
+  setMem(addr, bit) {
+    const value = this.readMemory(addr);
+    this.writeMemory(addr, value | (1 << bit));
+    return 15;
+  }
+
+  // DD/FD prefix helper methods
+  executeIndexReg(opcode, reg) {
+    // Most DD/FD instructions are identical to HL instructions but use IX/IY
+    // Special handling for indexed operations
+    const isIX = reg === "IX";
+    const indexReg = isIX ? this.IX : this.IY;
+
+    switch (opcode) {
+      // LD IX/IY, nn (0x21)
+      case 0x21: {
+        const low = this.readMemory(this.registers.PC);
+        const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+        this.registers.PC = (this.registers.PC + 2) & 0xffff;
+        if (isIX) {
+          this.IX = (high << 8) | low;
+        } else {
+          this.IY = (high << 8) | low;
+        }
+        return 14;
+      }
+
+      // ADD IX/IY, BC (0x09)
+      case 0x09:
+        return this.addIndexReg(indexReg, this.BC, isIX);
+      // ADD IX/IY, DE (0x19)
+      case 0x19:
+        return this.addIndexReg(indexReg, this.DE, isIX);
+      // ADD IX/IY, IX/IY (0x29)
+      case 0x29:
+        return this.addIndexReg(indexReg, indexReg, isIX);
+      // ADD IX/IY, SP (0x39)
+      case 0x39:
+        return this.addIndexReg(indexReg, this.registers.SP, isIX);
+
+      // INC IX/IY (0x23)
+      case 0x23:
+        if (isIX) {
+          this.IX = (this.IX + 1) & 0xffff;
+        } else {
+          this.IY = (this.IY + 1) & 0xffff;
+        }
+        return 10;
+
+      // DEC IX/IY (0x2B)
+      case 0x2b:
+        if (isIX) {
+          this.IX = (this.IX - 1) & 0xffff;
+        } else {
+          this.IY = (this.IY - 1) & 0xffff;
+        }
+        return 10;
+
+      // PUSH IX/IY (0xE5)
+      case 0xe5: {
+        const high = isIX ? this.registers.IXH : this.registers.IYH;
+        const low = isIX ? this.registers.IXL : this.registers.IYL;
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, high);
+        this.registers.SP = (this.registers.SP - 1) & 0xffff;
+        this.writeMemory(this.registers.SP, low);
+        return 15;
+      }
+
+      // POP IX/IY (0xE1)
+      case 0xe1: {
+        const low = this.readMemory(this.registers.SP);
+        const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+        this.registers.SP = (this.registers.SP + 2) & 0xffff;
+        if (isIX) {
+          this.registers.IXL = low;
+          this.registers.IXH = high;
+        } else {
+          this.registers.IYL = low;
+          this.registers.IYH = high;
+        }
+        return 14;
+      }
+
+      // LD (nn), IX/IY (0x22)
+      case 0x22: {
+        const low = this.readMemory(this.registers.PC);
+        const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+        this.registers.PC = (this.registers.PC + 2) & 0xffff;
+        const addr = (high << 8) | low;
+        this.wz = (addr + 1) & 0xffff;
+        const regLow = isIX ? this.registers.IXL : this.registers.IYL;
+        const regHigh = isIX ? this.registers.IXH : this.registers.IYH;
+        this.writeMemory(addr, regLow);
+        this.writeMemory((addr + 1) & 0xffff, regHigh);
+        return 20;
+      }
+
+      // LD IX/IY, (nn) (0x2A)
+      case 0x2a: {
+        const low = this.readMemory(this.registers.PC);
+        const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+        this.registers.PC = (this.registers.PC + 2) & 0xffff;
+        const addr = (high << 8) | low;
+        this.wz = (addr + 1) & 0xffff;
+        const regLow = this.readMemory(addr);
+        const regHigh = this.readMemory((addr + 1) & 0xffff);
+        if (isIX) {
+          this.registers.IXL = regLow;
+          this.registers.IXH = regHigh;
+        } else {
+          this.registers.IYL = regLow;
+          this.registers.IYH = regHigh;
+        }
+        return 20;
+      }
+
+      // JP (IX/IY) (0xE9)
+      case 0xe9:
+        this.registers.PC = indexReg;
+        return 8;
+
+      // LD SP, IX/IY (0xF9)
+      case 0xf9:
+        this.registers.SP = indexReg;
+        return 10;
+
+      default: {
+        // Opcodes whose (HL) operand becomes (IX+d)/(IY+d). Unlike the HL
+        // forms, these consume a signed displacement byte, and register
+        // names in the opcode keep meaning the REAL registers (H stays H).
+        const indexedAddr = () => {
+          const disp = this.readMemory(this.registers.PC);
+          this.registers.PC = (this.registers.PC + 1) & 0xffff;
+          return (this.wz = (indexReg + (disp & 0x80 ? disp - 256 : disp)) & 0xffff);
+        };
+        const regNames = ["B", "C", "D", "E", "H", "L", null, "A"];
+
+        // LD r,(IX+d): 01 rrr 110, excluding HALT's slot
+        if ((opcode & 0xc7) === 0x46 && opcode !== 0x76) {
+          const dest = regNames[(opcode >> 3) & 0x07];
+          this.registers[dest] = this.readMemory(indexedAddr());
+          return 19;
+        }
+
+        // LD (IX+d),r: 01 110 rrr, excluding HALT
+        if ((opcode & 0xf8) === 0x70 && opcode !== 0x76) {
+          const src = regNames[opcode & 0x07];
+          this.writeMemory(indexedAddr(), this.registers[src]);
+          return 19;
+        }
+
+        switch (opcode) {
+          case 0x34: {
+            // INC (IX+d)
+            const addr = indexedAddr();
+            const value = this.readMemory(addr);
+            const result = (value + 1) & 0xff;
+            this.writeMemory(addr, result);
+            this.flagZ = result === 0;
+            this.flagS = (result & 0x80) !== 0;
+            this.flagH = (value & 0x0f) === 0x0f;
+            this.flagPV = value === 0x7f;
+            this.flagN = 0;
+            this._xy(result);
+            return 23;
+          }
+          case 0x35: {
+            // DEC (IX+d)
+            const addr = indexedAddr();
+            const value = this.readMemory(addr);
+            const result = (value - 1) & 0xff;
+            this.writeMemory(addr, result);
+            this.flagZ = result === 0;
+            this.flagS = (result & 0x80) !== 0;
+            this.flagH = (value & 0x0f) === 0x00;
+            this.flagPV = value === 0x80;
+            this.flagN = 1;
+            this._xy(result);
+            return 23;
+          }
+          case 0x36: {
+            // LD (IX+d),n — displacement byte precedes the immediate
+            const addr = indexedAddr();
+            const value = this.readMemory(this.registers.PC);
+            this.registers.PC = (this.registers.PC + 1) & 0xffff;
+            this.writeMemory(addr, value);
+            return 19;
+          }
+          case 0x86:
+            this.addA(this.readMemory(indexedAddr()));
+            return 19;
+          case 0x8e:
+            this.adcA(this.readMemory(indexedAddr()));
+            return 19;
+          case 0x96:
+            this.subA(this.readMemory(indexedAddr()));
+            return 19;
+          case 0x9e:
+            this.sbcA(this.readMemory(indexedAddr()));
+            return 19;
+          case 0xa6:
+            this.andA(this.readMemory(indexedAddr()));
+            return 19;
+          case 0xae:
+            this.xorA(this.readMemory(indexedAddr()));
+            return 19;
+          case 0xb6:
+            this.orA(this.readMemory(indexedAddr()));
+            return 19;
+          case 0xbe:
+            this.subA(this.readMemory(indexedAddr()), true);
+            return 19;
+        }
+
+        // Remaining DD/FD opcodes mirror their HL forms with IX/IY
+        // substituted and take no displacement (INC IXH, ADD A,IXL, ...):
+        // the HL-swap delegation is faithful for these.
+        if (this.opcodeHandlers[opcode]) {
+          // EX DE,HL and EXX ignore the prefix
+          if (opcode === 0xeb || opcode === 0xd9) {
+            return this.opcodeHandlers[opcode].call(this) + 4;
+          }
+          const tempHL = this.HL;
+          this.HL = indexReg;
+          const cycles = this.opcodeHandlers[opcode].call(this);
+          if (isIX) {
+            this.IX = this.HL;
+          } else {
+            this.IY = this.HL;
+          }
+          this.HL = tempHL;
+          return cycles + 4;
+        }
+
+        return this.reportUnimplemented(opcode, isIX ? "0xDD " : "0xFD ");
+      }
+    }
+  }
+
+  addIndexReg(indexReg, value, isIX) {
+    const result = indexReg + value;
+    this.flagC = result > 0xffff;
+    this.flagH = (indexReg & 0x0fff) + (value & 0x0fff) > 0x0fff;
+    this.flagN = false;
+    if (isIX) {
+      this.IX = result & 0xffff;
+    } else {
+      this.IY = result & 0xffff;
+    }
+    this.wz = (indexReg + 1) & 0xffff;
+    this._xy((result & 0xffff) >> 8);
+    return 15;
+  }
+
+  executeIndexedCB(addr, cbOpcode) {
+    const reg = cbOpcode & 0x07;
+    const base = cbOpcode & 0xf8;
+    this.wz = addr & 0xffff; // MEMPTR = IX+d (feeds BIT's X/Y)
+
+    // BIT only reads: 20 T-states, never touches a register
+    if (base >= 0x40 && base <= 0x78) {
+      this.bitMem(addr, (base >> 3) & 0x07);
+      return 20;
+    }
+
+    switch (base) {
+      case 0x00:
+        this.rlcMem(addr);
+        break;
+      case 0x08:
+        this.rrcMem(addr);
+        break;
+      case 0x10:
+        this.rlMem(addr);
+        break;
+      case 0x18:
+        this.rrMem(addr);
+        break;
+      case 0x20:
+        this.slaMem(addr);
+        break;
+      case 0x28:
+        this.sraMem(addr);
+        break;
+      case 0x30:
+        this.sllMem(addr);
+        break;
+      case 0x38:
+        this.srlMem(addr);
+        break;
+      default:
+        // 0x80-0xF8: RES/SET
+        if (base & 0x40) {
+          this.setMem(addr, (base >> 3) & 0x07);
+        } else {
+          this.resMem(addr, (base >> 3) & 0x07);
+        }
+        break;
+    }
+
+    // Undocumented: every writing DD/FD CB form also copies the result
+    // into the register named by the low 3 bits (110 = memory only).
+    if (reg !== 6) {
+      this.registers[INDEXED_CB_COPY_REGS[reg]] = this.readMemory(addr);
+    }
+    return 23;
+  }
+
+  // Block Transfer Instructions
+  /**
+   * LDI - Load and Increment
+   * Copies byte from (HL) to (DE), increments HL and DE, decrements BC
+   * Flags: H=0, N=0, PV=1 if BC-1 != 0, else 0
+   */
+  ldi() {
+    const value = this.readMemory(this.HL);
+    this.writeMemory(this.DE, value);
+    this.HL = (this.HL + 1) & 0xffff;
+    this.DE = (this.DE + 1) & 0xffff;
+    this.BC = (this.BC - 1) & 0xffff;
+
+    // Flag updates
+    this.flagH = false;
+    this.flagN = false;
+    this.flagPV = this.BC !== 0;
+    this._xyBlock((value + this.registers.A) & 0xff);
+
+    return 16;
+  }
+
+  /**
+   * LDIR - Load, Increment, Repeat
+   * Repeats LDI until BC = 0
+   */
+  ldir() {
+    const cycles = this.ldi();
+    if (this.BC !== 0) {
+      // Repeat: decrement PC by 2 to re-execute instruction
+      this.registers.PC = (this.registers.PC - 2) & 0xffff;
+      this.wz = (this.registers.PC + 1) & 0xffff;
+      return cycles + 5; // Extra cycles for repeat
+    }
+    return cycles;
+  }
+
+  /**
+   * LDD - Load and Decrement
+   * Copies byte from (HL) to (DE), decrements HL and DE, decrements BC
+   */
+  ldd() {
+    const value = this.readMemory(this.HL);
+    this.writeMemory(this.DE, value);
+    this.HL = (this.HL - 1) & 0xffff;
+    this.DE = (this.DE - 1) & 0xffff;
+    this.BC = (this.BC - 1) & 0xffff;
+
+    // Flag updates
+    this.flagH = false;
+    this.flagN = false;
+    this.flagPV = this.BC !== 0;
+    this._xyBlock((value + this.registers.A) & 0xff);
+
+    return 16;
+  }
+
+  /**
+   * LDDR - Load, Decrement, Repeat
+   * Repeats LDD until BC = 0
+   */
+  lddr() {
+    const cycles = this.ldd();
+    if (this.BC !== 0) {
+      this.registers.PC = (this.registers.PC - 2) & 0xffff;
+      this.wz = (this.registers.PC + 1) & 0xffff;
+      return cycles + 5;
+    }
+    return cycles;
+  }
+
+  // Block Compare Instructions
+  /**
+   * CPI - Compare and Increment
+   * Compares A with (HL), increments HL, decrements BC
+   * Flags: Z=1 if A==(HL), H from subtraction, N=1, PV=1 if BC-1 != 0
+   */
+  cpi() {
+    const value = this.readMemory(this.HL);
+    const a = this.registers.A;
+    const result = (a - value) & 0xff;
+
+    this.HL = (this.HL + 1) & 0xffff;
+    this.BC = (this.BC - 1) & 0xffff;
+    this.wz = (this.wz + 1) & 0xffff;
+
+    // Flag updates
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagH = (a & 0x0f) - (value & 0x0f) < 0;
+    this.flagPV = this.BC !== 0;
+    this.flagN = 1;
+    this._xyBlock((result - (this.flagH ? 1 : 0)) & 0xff);
+
+    return 16;
+  }
+
+  /**
+   * CPIR - Compare, Increment, Repeat
+   * Repeats CPI until BC = 0 or match found (Z=1)
+   */
+  cpir() {
+    const cycles = this.cpi();
+    if (this.BC !== 0 && !this.flagZ) {
+      this.registers.PC = (this.registers.PC - 2) & 0xffff;
+      this.wz = (this.registers.PC + 1) & 0xffff;
+      return cycles + 5;
+    }
+    return cycles;
+  }
+
+  /**
+   * CPD - Compare and Decrement
+   * Compares A with (HL), decrements HL, decrements BC
+   */
+  cpd() {
+    const value = this.readMemory(this.HL);
+    const a = this.registers.A;
+    const result = (a - value) & 0xff;
+
+    this.HL = (this.HL - 1) & 0xffff;
+    this.BC = (this.BC - 1) & 0xffff;
+    this.wz = (this.wz - 1) & 0xffff;
+
+    // Flag updates
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this.flagH = (a & 0x0f) - (value & 0x0f) < 0;
+    this.flagPV = this.BC !== 0;
+    this.flagN = 1;
+    this._xyBlock((result - (this.flagH ? 1 : 0)) & 0xff);
+
+    return 16;
+  }
+
+  /**
+   * CPDR - Compare, Decrement, Repeat
+   * Repeats CPD until BC = 0 or match found (Z=1)
+   */
+  cpdr() {
+    const cycles = this.cpd();
+    if (this.BC !== 0 && !this.flagZ) {
+      this.registers.PC = (this.registers.PC - 2) & 0xffff;
+      this.wz = (this.registers.PC + 1) & 0xffff;
+      return cycles + 5;
+    }
+    return cycles;
+  }
+
+  // Extended Load Instructions
+  /**
+   * LD BC, (nn) - Load BC from memory address
+   */
+  ldBCnn() {
+    const low = this.readMemory(this.registers.PC);
+    const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+    this.registers.PC = (this.registers.PC + 2) & 0xffff;
+    const addr = (high << 8) | low;
+    this.wz = (addr + 1) & 0xffff;
+    const valueLow = this.readMemory(addr);
+    const valueHigh = this.readMemory((addr + 1) & 0xffff);
+    this.BC = (valueHigh << 8) | valueLow;
+    return 20;
+  }
+
+  /**
+   * LD DE, (nn) - Load DE from memory address
+   */
+  ldDEnn() {
+    const low = this.readMemory(this.registers.PC);
+    const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+    this.registers.PC = (this.registers.PC + 2) & 0xffff;
+    const addr = (high << 8) | low;
+    this.wz = (addr + 1) & 0xffff;
+    const valueLow = this.readMemory(addr);
+    const valueHigh = this.readMemory((addr + 1) & 0xffff);
+    this.DE = (valueHigh << 8) | valueLow;
+    return 20;
+  }
+
+  /**
+   * LD HL, (nn) - Load HL from memory address
+   */
+  ldHLnn() {
+    const low = this.readMemory(this.registers.PC);
+    const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+    this.registers.PC = (this.registers.PC + 2) & 0xffff;
+    const addr = (high << 8) | low;
+    this.wz = (addr + 1) & 0xffff;
+    const valueLow = this.readMemory(addr);
+    const valueHigh = this.readMemory((addr + 1) & 0xffff);
+    this.HL = (valueHigh << 8) | valueLow;
+    return 20;
+  }
+
+  /**
+   * LD SP, (nn) - Load SP from memory address
+   */
+  ldSPnn() {
+    const low = this.readMemory(this.registers.PC);
+    const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+    this.registers.PC = (this.registers.PC + 2) & 0xffff;
+    const addr = (high << 8) | low;
+    this.wz = (addr + 1) & 0xffff;
+    const valueLow = this.readMemory(addr);
+    const valueHigh = this.readMemory((addr + 1) & 0xffff);
+    this.registers.SP = (valueHigh << 8) | valueLow;
+    return 20;
+  }
+
+  /**
+   * LD (nn), BC - Store BC to memory address
+   */
+  ldnnBC() {
+    const low = this.readMemory(this.registers.PC);
+    const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+    this.registers.PC = (this.registers.PC + 2) & 0xffff;
+    const addr = (high << 8) | low;
+    this.wz = (addr + 1) & 0xffff;
+    this.writeMemory(addr, this.registers.C);
+    this.writeMemory((addr + 1) & 0xffff, this.registers.B);
+    return 20;
+  }
+
+  /**
+   * LD (nn), DE - Store DE to memory address
+   */
+  ldnnDE() {
+    const low = this.readMemory(this.registers.PC);
+    const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+    this.registers.PC = (this.registers.PC + 2) & 0xffff;
+    const addr = (high << 8) | low;
+    this.wz = (addr + 1) & 0xffff;
+    this.writeMemory(addr, this.registers.E);
+    this.writeMemory((addr + 1) & 0xffff, this.registers.D);
+    return 20;
+  }
+
+  /**
+   * LD (nn), HL - Store HL to memory address
+   */
+  ldnnHL() {
+    const low = this.readMemory(this.registers.PC);
+    const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+    this.registers.PC = (this.registers.PC + 2) & 0xffff;
+    const addr = (high << 8) | low;
+    this.wz = (addr + 1) & 0xffff;
+    this.writeMemory(addr, this.registers.L);
+    this.writeMemory((addr + 1) & 0xffff, this.registers.H);
+    return 20;
+  }
+
+  /**
+   * LD (nn), SP - Store SP to memory address
+   */
+  ldnnSP() {
+    const low = this.readMemory(this.registers.PC);
+    const high = this.readMemory((this.registers.PC + 1) & 0xffff);
+    this.registers.PC = (this.registers.PC + 2) & 0xffff;
+    const addr = (high << 8) | low;
+    this.wz = (addr + 1) & 0xffff;
+    this.writeMemory(addr, this.registers.SP & 0xff);
+    this.writeMemory((addr + 1) & 0xffff, (this.registers.SP >> 8) & 0xff);
+    return 20;
+  }
+
+  // Extended Arithmetic Instructions
+  /**
+   * ADC HL, rr - Add with carry to HL
+   */
+  adcHL(value) {
+    const hl = this.HL;
+    const carry = this.flagC ? 1 : 0;
+    const result = hl + value + carry;
+
+    this.flagC = result > 0xffff;
+    this.flagH = (hl & 0x0fff) + (value & 0x0fff) + carry > 0x0fff;
+    this.flagN = false;
+    this.flagPV = ((hl ^ value ^ 0xffff) & (hl ^ result) & 0x8000) !== 0;
+    this.HL = result & 0xffff;
+    this.flagS = (this.HL & 0x8000) !== 0;
+    this.flagZ = this.HL === 0;
+    this.wz = (hl + 1) & 0xffff;
+    this._xy(this.HL >> 8);
+
+    return 15;
+  }
+
+  /**
+   * SBC HL, rr - Subtract with borrow from HL
+   */
+  sbcHL(value) {
+    const hl = this.HL;
+    const borrow = this.flagC ? 1 : 0;
+    const result = hl - value - borrow;
+
+    this.flagC = result < 0;
+    this.flagH = (hl & 0x0fff) - (value & 0x0fff) - borrow < 0;
+    this.flagN = true;
+    this.flagPV = ((hl ^ value) & (hl ^ result) & 0x8000) !== 0;
+    this.HL = result & 0xffff;
+    this.flagS = (this.HL & 0x8000) !== 0;
+    this.flagZ = this.HL === 0;
+    this.wz = (hl + 1) & 0xffff;
+    this._xy(this.HL >> 8);
+
+    return 15;
+  }
+
+  /**
+   * NEG - Negate accumulator (two's complement)
+   */
+  neg() {
+    const a = this.registers.A;
+    const result = (0 - a) & 0xff;
+
+    this.registers.A = result;
+    this.flagC = a !== 0;
+    this.flagH = (a & 0x0f) !== 0;
+    this.flagN = true;
+    this.flagPV = a === 0x80;
+    this.flagZ = result === 0;
+    this.flagS = (result & 0x80) !== 0;
+    this._xy(result);
+
+    return 8;
+  }
+
+  // Extended I/O Instructions
+  /**
+   * IN r, (C) - Input from port C to register
+   * Register mapping: 0=B, 1=C, 2=D, 3=E, 4=H, 5=L, 6=(HL), 7=A
+   */
+  inrC(regIndex) {
+    this.wz = (this.BC + 1) & 0xffff;
+    const port = this.registers.C;
+    const value = this.readPort(port);
+
+    const regs = ["B", "C", "D", "E", "H", "L", null, "A"];
+    if (regIndex !== 6) this.registers[regs[regIndex]] = value; // 6 is IN F,(C): flags only
+
+    // Flag updates
+    this.flagZ = value === 0;
+    this.flagS = (value & 0x80) !== 0;
+    this.flagH = false;
+    this.flagPV = this.parity(value);
+    this.flagN = false;
+    this._xy(value);
+
+    return 12;
+  }
+
+  /**
+   * OUT (C), r - Output register to port C
+   */
+  outCr(regIndex) {
+    this.wz = (this.BC + 1) & 0xffff;
+    const port = this.registers.C;
+    const regs = ["B", "C", "D", "E", "H", "L", null, "A"];
+    // 6 is OUT (C),0; an NMOS Z80, as in the Model I and III, sends 0 (CMOS parts send FFH)
+    const value = regIndex === 6 ? 0 : this.registers[regs[regIndex]];
+    this.writePort(port, value);
+    return 12;
+  }
+
+  /**
+   * Block I/O flags (Young §4.3): S, Z, 5, 3 from B after it counts down; N from bit 7 of the
+   * byte moved; H and C from the carry out of k; P/V the parity of (k AND 7) XOR B.
+   */
+  _blockIOFlags(value, k) {
+    const b = this.registers.B;
+    this.flagS = (b & 0x80) !== 0;
+    this.flagZ = b === 0;
+    this._xy(b);
+    this.flagN = (value & 0x80) !== 0;
+    this.flagH = k > 0xff;
+    this.flagC = k > 0xff;
+    this.flagPV = this.parity((k & 7) ^ b);
+  }
+
+  /**
+   * INI - Input and Increment
+   * Inputs from port C to (HL), increments HL, decrements B
+   */
+  ini() {
+    this.wz = (this.BC + 1) & 0xffff;
+    const port = this.registers.C;
+    const value = this.readPort(port);
+    this.writeMemory(this.HL, value);
+    this.HL = (this.HL + 1) & 0xffff;
+    this.registers.B = (this.registers.B - 1) & 0xff;
+
+    // Flag updates
+    this._blockIOFlags(value, value + ((port + 1) & 0xff));
+
+    return 16;
+  }
+
+  /**
+   * INIR - Input, Increment, Repeat
+   * Repeats INI until B = 0
+   */
+  inir() {
+    const cycles = this.ini();
+    if (this.registers.B !== 0) {
+      this.registers.PC = (this.registers.PC - 2) & 0xffff;
+      return cycles + 5;
+    }
+    return cycles;
+  }
+
+  /**
+   * IND - Input and Decrement
+   */
+  ind() {
+    this.wz = (this.BC - 1) & 0xffff;
+    const port = this.registers.C;
+    const value = this.readPort(port);
+    this.writeMemory(this.HL, value);
+    this.HL = (this.HL - 1) & 0xffff;
+    this.registers.B = (this.registers.B - 1) & 0xff;
+
+    this._blockIOFlags(value, value + ((port - 1) & 0xff));
+
+    return 16;
+  }
+
+  /**
+   * INDR - Input, Decrement, Repeat
+   */
+  indr() {
+    const cycles = this.ind();
+    if (this.registers.B !== 0) {
+      this.registers.PC = (this.registers.PC - 2) & 0xffff;
+      return cycles + 5;
+    }
+    return cycles;
+  }
+
+  /**
+   * OUTI - Output and Increment
+   */
+  outi() {
+    const port = this.registers.C;
+    const value = this.readMemory(this.HL);
+    this.writePort(port, value);
+    this.HL = (this.HL + 1) & 0xffff;
+    this.registers.B = (this.registers.B - 1) & 0xff;
+    this.wz = (this.BC + 1) & 0xffff;
+
+    this._blockIOFlags(value, value + this.registers.L);
+
+    return 16;
+  }
+
+  /**
+   * OTIR - Output, Increment, Repeat
+   */
+  otir() {
+    const cycles = this.outi();
+    if (this.registers.B !== 0) {
+      this.registers.PC = (this.registers.PC - 2) & 0xffff;
+      return cycles + 5;
+    }
+    return cycles;
+  }
+
+  /**
+   * OUTD - Output and Decrement
+   */
+  outd() {
+    const port = this.registers.C;
+    const value = this.readMemory(this.HL);
+    this.writePort(port, value);
+    this.HL = (this.HL - 1) & 0xffff;
+    this.registers.B = (this.registers.B - 1) & 0xff;
+    this.wz = (this.BC - 1) & 0xffff;
+
+    this._blockIOFlags(value, value + this.registers.L);
+
+    return 16;
+  }
+
+  /**
+   * OTDR - Output, Decrement, Repeat
+   */
+  otdr() {
+    const cycles = this.outd();
+    if (this.registers.B !== 0) {
+      this.registers.PC = (this.registers.PC - 2) & 0xffff;
+      return cycles + 5;
+    }
+    return cycles;
+  }
+
+  // Interrupt Handling Instructions
+  /**
+   * RETI - Return from Interrupt
+   * Same as RET but signals interrupt controller
+   */
+  reti() {
+    const low = this.readMemory(this.registers.SP);
+    const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+    this.registers.SP = (this.registers.SP + 2) & 0xffff;
+    this.registers.PC = (high << 8) | low;
+    this.wz = this.registers.PC;
+    // IFF2 is copied to IFF1 on RETI
+    this.IFF1 = this.IFF2;
+    return 14;
+  }
+
+  /**
+   * RETN - Return from Non-Maskable Interrupt
+   * Same as RET but restores IFF1 from IFF2
+   */
+  retn() {
+    const low = this.readMemory(this.registers.SP);
+    const high = this.readMemory((this.registers.SP + 1) & 0xffff);
+    this.registers.SP = (this.registers.SP + 2) & 0xffff;
+    this.registers.PC = (high << 8) | low;
+    this.wz = this.registers.PC;
+    // IFF2 is copied to IFF1 on RETN
+    this.IFF1 = this.IFF2;
+    return 14;
+  }
+
+  /**
+   * RLD - Rotate the three low nibbles left: A.low -> (HL).low,
+   * (HL).low -> (HL).high, (HL).high -> A.low. C is unaffected.
+   */
+  rld() {
+    const value = this.readMemory(this.HL);
+    this.writeMemory(
+      this.HL,
+      ((value << 4) & 0xf0) | (this.registers.A & 0x0f)
+    );
+    this.registers.A = (this.registers.A & 0xf0) | (value >> 4);
+    this.wz = (this.HL + 1) & 0xffff;
+    this._nibbleRotateFlags();
+    return 18;
+  }
+
+  /**
+   * RRD - Rotate the three low nibbles right: A.low -> (HL).high,
+   * (HL).high -> (HL).low, (HL).low -> A.low. C is unaffected.
+   */
+  rrd() {
+    const value = this.readMemory(this.HL);
+    this.writeMemory(
+      this.HL,
+      ((this.registers.A & 0x0f) << 4) | (value >> 4)
+    );
+    this.registers.A = (this.registers.A & 0xf0) | (value & 0x0f);
+    this.wz = (this.HL + 1) & 0xffff;
+    this._nibbleRotateFlags();
+    return 18;
+  }
+
+  _nibbleRotateFlags() {
+    const a = this.registers.A;
+    this.flagS = (a & 0x80) !== 0;
+    this.flagZ = a === 0;
+    this.flagH = false;
+    this.flagPV = this.parity(a);
+    this.flagN = false;
+    this._xy(a);
+  }
+}