use crate::verbose_println;
use std::ops::{BitAnd, BitOr, BitXor};

use super::{as_signed, res, set, swap_nibbles, Flags, Reg8, SplitRegister, CPU};

impl CPU {
    #[allow(dead_code)]
    pub fn run_opcode(&mut self, opcode: u8) {
        match opcode {
            0x00 => {
                // noop
            }
            0x01 => self.reg.bc = self.ld_immediate_word(),
            0x02 => self.memory.set(self.reg.bc, self.reg.get_8(Reg8::A)),
            0x03 => self.reg.bc = self.inc_pair(self.reg.bc),
            0x04 => self.inc(Reg8::B),
            0x05 => self.dec(Reg8::B),
            0x06 => {
                let byte = self.ld_immediate_byte();
                self.reg.set_8(Reg8::B, byte);
            }
            0x07 => {
                let val = self.rlc(self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0x08 => {
                let addr = self.ld_immediate_word();
                self.memory.set(addr, self.reg.sp.get_low());
                self.memory
                    .set(addr.wrapping_add(0x1), self.reg.sp.get_high());
            }
            0x09 => self.reg.hl = self.add_u16s(self.reg.hl, self.reg.bc),
            0x0A => self.reg.set_8(Reg8::A, self.memory.get(self.reg.bc)),
            0x0B => self.reg.bc = self.dec_pair(self.reg.bc),
            0x0C => self.inc(Reg8::C),
            0x0D => self.dec(Reg8::C),
            0x0E => {
                let byte = self.ld_immediate_byte();
                self.reg.set_8(Reg8::C, byte);
            }
            0x0F => {
                let val = self.rrc(self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0x10 => {
                // stop
                panic!("stop instruction");
            }
            0x11 => self.reg.de = self.ld_immediate_word(),
            0x12 => self.memory.set(self.reg.de, self.reg.get_8(Reg8::A)),
            0x13 => self.reg.de = self.inc_pair(self.reg.de),
            0x14 => self.inc(Reg8::D),
            0x15 => self.dec(Reg8::D),
            0x16 => {
                let byte = self.ld_immediate_byte();
                self.reg.set_8(Reg8::D, byte);
            }
            0x17 => {
                let val = self.rl(self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0x18 => {
                let jump = as_signed(self.ld_immediate_byte());
                self.jr(jump);
            }
            0x19 => self.reg.hl = self.add_u16s(self.reg.hl, self.reg.de),
            0x1A => self.reg.set_8(Reg8::A, self.memory.get(self.reg.de)),
            0x1B => self.reg.de = self.dec_pair(self.reg.de),
            0x1C => self.inc(Reg8::E),
            0x1D => self.dec(Reg8::E),
            0x1E => {
                let byte = self.ld_immediate_byte();
                self.reg.set_8(Reg8::E, byte);
            }
            0x1F => {
                let val = self.rr(self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0x20 => {
                let jump = as_signed(self.ld_immediate_byte());
                if !self.is_flag(Flags::Zero) {
                    self.jr(jump);
                }
            }
            0x21 => self.reg.hl = self.ld_immediate_word(),
            0x22 => {
                self.memory.set(self.reg.hl, self.reg.get_8(Reg8::A));
                self.reg.hl = self.inc_pair(self.reg.hl);
            }
            0x23 => self.reg.hl = self.inc_pair(self.reg.hl),
            0x24 => self.inc(Reg8::H),
            0x25 => self.dec(Reg8::H),
            0x26 => {
                let byte = self.ld_immediate_byte();
                self.reg.set_8(Reg8::H, byte);
            }
            0x27 => {
                let mut a = self.reg.get_8(Reg8::A);
                if !self.is_flag(Flags::NSubtract) {
                    // after an addition, adjust if (half-)carry occurred or if result is out of bounds
                    if self.is_flag(Flags::Carry) || a > 0x99 {
                        a += 0x60;
                        self.set_flag(Flags::Carry);
                    }
                    if self.is_flag(Flags::HalfCarry) || (a & 0x0f) > 0x09 {
                        a += 0x6;
                    }
                } else {
                    // after a subtraction, only adjust if (half-)carry occurred
                    if self.is_flag(Flags::Carry) {
                        a -= 0x60;
                    }
                    if self.is_flag(Flags::HalfCarry) {
                        a -= 0x6;
                    }
                }
                // these flags are always updated
                self.set_or_clear_flag(Flags::Zero, a == 0);
                self.clear_flag(Flags::HalfCarry);
                self.reg.set_8(Reg8::A, a);
            }
            0x28 => {
                let jump = as_signed(self.ld_immediate_byte());
                if self.is_flag(Flags::Zero) {
                    self.jr(jump);
                }
            }
            0x29 => self.reg.hl = self.add_u16s(self.reg.hl, self.reg.hl),
            0x2A => {
                self.reg.set_8(Reg8::A, self.memory.get(self.reg.hl));
                self.reg.hl = self.inc_pair(self.reg.hl);
            }
            0x2B => self.reg.hl = self.dec_pair(self.reg.hl),
            0x2C => self.inc(Reg8::L),
            0x2D => self.dec(Reg8::L),
            0x2E => {
                let byte = self.ld_immediate_byte();
                self.reg.set_8(Reg8::L, byte);
            }
            0x2F => {
                let val = !self.reg.get_8(Reg8::A);
                self.reg.set_8(Reg8::A, val);
                self.set_flag(Flags::NSubtract);
                self.set_flag(Flags::HalfCarry);
            }
            0x30 => {
                let jump = as_signed(self.ld_immediate_byte());
                if !self.is_flag(Flags::Carry) {
                    self.jr(jump);
                }
            }
            0x31 => self.reg.sp = self.ld_immediate_word(),
            0x32 => {
                self.memory.set(self.reg.hl, self.reg.get_8(Reg8::A));
                self.reg.hl = self.dec_pair(self.reg.hl);
            }
            0x33 => self.reg.sp = self.inc_pair(self.reg.sp),
            0x34 => {
                let val = self.inc_raw(self.memory.get(self.reg.hl));
                self.memory.set(self.reg.hl, val);
            }
            0x35 => {
                let val = self.dec_raw(self.memory.get(self.reg.hl));
                self.memory.set(self.reg.hl, val);
            }
            0x36 => {
                let byte = self.ld_immediate_byte();
                self.memory.set(self.reg.hl, byte);
            }
            0x37 => {
                self.clear_flag(Flags::NSubtract);
                self.clear_flag(Flags::HalfCarry);
                self.set_flag(Flags::Carry);
            }
            0x38 => {
                let jump = as_signed(self.ld_immediate_byte());
                if self.is_flag(Flags::Carry) {
                    self.jr(jump);
                }
            }
            0x39 => self.reg.hl = self.add_u16s(self.reg.hl, self.reg.sp),
            0x3A => {
                self.reg.set_8(Reg8::A, self.memory.get(self.reg.hl));
                self.reg.hl = self.dec_pair(self.reg.hl);
            }
            0x3B => self.reg.sp = self.dec_pair(self.reg.sp),
            0x3C => self.inc(Reg8::A),
            0x3D => self.dec(Reg8::A),
            0x3E => {
                let byte = self.ld_immediate_byte();
                self.reg.set_8(Reg8::A, byte);
            }
            0x3F => {
                self.clear_flag(Flags::NSubtract);
                self.clear_flag(Flags::HalfCarry);
                self.set_or_clear_flag(Flags::Carry, !self.is_flag(Flags::Carry));
            }
            0x40 => self.reg.set_8(Reg8::B, self.reg.get_8(Reg8::B)),
            0x41 => self.reg.set_8(Reg8::B, self.reg.get_8(Reg8::C)),
            0x42 => self.reg.set_8(Reg8::B, self.reg.get_8(Reg8::D)),
            0x43 => self.reg.set_8(Reg8::B, self.reg.get_8(Reg8::E)),
            0x44 => self.reg.set_8(Reg8::B, self.reg.get_8(Reg8::H)),
            0x45 => self.reg.set_8(Reg8::B, self.reg.get_8(Reg8::L)),
            0x46 => self.reg.set_8(Reg8::B, self.memory.get(self.reg.hl)),
            0x47 => self.reg.set_8(Reg8::B, self.reg.get_8(Reg8::A)),
            0x48 => self.reg.set_8(Reg8::C, self.reg.get_8(Reg8::B)),
            0x49 => self.reg.set_8(Reg8::C, self.reg.get_8(Reg8::C)),
            0x4A => self.reg.set_8(Reg8::C, self.reg.get_8(Reg8::D)),
            0x4B => self.reg.set_8(Reg8::C, self.reg.get_8(Reg8::E)),
            0x4C => self.reg.set_8(Reg8::C, self.reg.get_8(Reg8::H)),
            0x4D => self.reg.set_8(Reg8::C, self.reg.get_8(Reg8::L)),
            0x4E => self.reg.set_8(Reg8::C, self.memory.get(self.reg.hl)),
            0x4F => self.reg.set_8(Reg8::C, self.reg.get_8(Reg8::A)),
            0x50 => self.reg.set_8(Reg8::D, self.reg.get_8(Reg8::B)),
            0x51 => self.reg.set_8(Reg8::D, self.reg.get_8(Reg8::C)),
            0x52 => self.reg.set_8(Reg8::D, self.reg.get_8(Reg8::D)),
            0x53 => self.reg.set_8(Reg8::D, self.reg.get_8(Reg8::E)),
            0x54 => self.reg.set_8(Reg8::D, self.reg.get_8(Reg8::H)),
            0x55 => self.reg.set_8(Reg8::D, self.reg.get_8(Reg8::L)),
            0x56 => self.reg.set_8(Reg8::D, self.memory.get(self.reg.hl)),
            0x57 => self.reg.set_8(Reg8::D, self.reg.get_8(Reg8::A)),
            0x58 => self.reg.set_8(Reg8::E, self.reg.get_8(Reg8::B)),
            0x59 => self.reg.set_8(Reg8::E, self.reg.get_8(Reg8::C)),
            0x5A => self.reg.set_8(Reg8::E, self.reg.get_8(Reg8::D)),
            0x5B => self.reg.set_8(Reg8::E, self.reg.get_8(Reg8::E)),
            0x5C => self.reg.set_8(Reg8::E, self.reg.get_8(Reg8::H)),
            0x5D => self.reg.set_8(Reg8::E, self.reg.get_8(Reg8::L)),
            0x5E => self.reg.set_8(Reg8::E, self.memory.get(self.reg.hl)),
            0x5F => self.reg.set_8(Reg8::E, self.reg.get_8(Reg8::A)),
            0x60 => self.reg.set_8(Reg8::H, self.reg.get_8(Reg8::B)),
            0x61 => self.reg.set_8(Reg8::H, self.reg.get_8(Reg8::C)),
            0x62 => self.reg.set_8(Reg8::H, self.reg.get_8(Reg8::D)),
            0x63 => self.reg.set_8(Reg8::H, self.reg.get_8(Reg8::E)),
            0x64 => self.reg.set_8(Reg8::H, self.reg.get_8(Reg8::H)),
            0x65 => self.reg.set_8(Reg8::H, self.reg.get_8(Reg8::L)),
            0x66 => self.reg.set_8(Reg8::H, self.memory.get(self.reg.hl)),
            0x67 => self.reg.set_8(Reg8::H, self.reg.get_8(Reg8::A)),
            0x68 => self.reg.set_8(Reg8::L, self.reg.get_8(Reg8::B)),
            0x69 => self.reg.set_8(Reg8::L, self.reg.get_8(Reg8::C)),
            0x6A => self.reg.set_8(Reg8::L, self.reg.get_8(Reg8::D)),
            0x6B => self.reg.set_8(Reg8::L, self.reg.get_8(Reg8::E)),
            0x6C => self.reg.set_8(Reg8::L, self.reg.get_8(Reg8::H)),
            0x6D => self.reg.set_8(Reg8::L, self.reg.get_8(Reg8::L)),
            0x6E => self.reg.set_8(Reg8::L, self.memory.get(self.reg.hl)),
            0x6F => self.reg.set_8(Reg8::L, self.reg.get_8(Reg8::A)),
            0x70 => self.memory.set(self.reg.hl, self.reg.get_8(Reg8::B)),
            0x71 => self.memory.set(self.reg.hl, self.reg.get_8(Reg8::C)),
            0x72 => self.memory.set(self.reg.hl, self.reg.get_8(Reg8::D)),
            0x73 => self.memory.set(self.reg.hl, self.reg.get_8(Reg8::E)),
            0x74 => self.memory.set(self.reg.hl, self.reg.get_8(Reg8::H)),
            0x75 => self.memory.set(self.reg.hl, self.reg.get_8(Reg8::L)),
            0x76 => panic!("halt"),
            0x77 => self.memory.set(self.reg.hl, self.reg.get_8(Reg8::A)),
            0x78 => self.reg.set_8(Reg8::A, self.reg.get_8(Reg8::B)),
            0x79 => self.reg.set_8(Reg8::A, self.reg.get_8(Reg8::C)),
            0x7A => self.reg.set_8(Reg8::A, self.reg.get_8(Reg8::D)),
            0x7B => self.reg.set_8(Reg8::A, self.reg.get_8(Reg8::E)),
            0x7C => self.reg.set_8(Reg8::A, self.reg.get_8(Reg8::H)),
            0x7D => self.reg.set_8(Reg8::A, self.reg.get_8(Reg8::L)),
            0x7E => self.reg.set_8(Reg8::A, self.memory.get(self.reg.hl)),
            0x7F => self.reg.set_8(Reg8::A, self.reg.get_8(Reg8::A)),
            0x80 => {
                let val = self.add(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::B));
                self.reg.set_8(Reg8::A, val);
            }
            0x81 => {
                let val = self.add(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::C));
                self.reg.set_8(Reg8::A, val);
            }
            0x82 => {
                let val = self.add(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::D));
                self.reg.set_8(Reg8::A, val);
            }
            0x83 => {
                let val = self.add(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::E));
                self.reg.set_8(Reg8::A, val);
            }
            0x84 => {
                let val = self.add(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::H));
                self.reg.set_8(Reg8::A, val);
            }
            0x85 => {
                let val = self.add(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::L));
                self.reg.set_8(Reg8::A, val);
            }
            0x86 => {
                let val = self.add(self.reg.get_8(Reg8::A), self.memory.get(self.reg.hl));
                self.reg.set_8(Reg8::A, val);
            }
            0x87 => {
                let val = self.add(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0x88 => {
                let val = self.adc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::B));
                self.reg.set_8(Reg8::A, val);
            }
            0x89 => {
                let val = self.adc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::C));
                self.reg.set_8(Reg8::A, val);
            }
            0x8A => {
                let val = self.adc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::D));
                self.reg.set_8(Reg8::A, val);
            }
            0x8B => {
                let val = self.adc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::E));
                self.reg.set_8(Reg8::A, val);
            }
            0x8C => {
                let val = self.adc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::H));
                self.reg.set_8(Reg8::A, val);
            }
            0x8D => {
                let val = self.adc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::L));
                self.reg.set_8(Reg8::A, val);
            }
            0x8E => {
                let val = self.adc(self.reg.get_8(Reg8::A), self.memory.get(self.reg.hl));
                self.reg.set_8(Reg8::A, val);
            }
            0x8F => {
                let val = self.adc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0x90 => {
                let val = self.sub(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::B));
                self.reg.set_8(Reg8::A, val);
            }
            0x91 => {
                let val = self.sub(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::C));
                self.reg.set_8(Reg8::A, val);
            }
            0x92 => {
                let val = self.sub(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::D));
                self.reg.set_8(Reg8::A, val);
            }
            0x93 => {
                let val = self.sub(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::E));
                self.reg.set_8(Reg8::A, val);
            }
            0x94 => {
                let val = self.sub(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::H));
                self.reg.set_8(Reg8::A, val);
            }
            0x95 => {
                let val = self.sub(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::L));
                self.reg.set_8(Reg8::A, val);
            }
            0x96 => {
                let val = self.sub(self.reg.get_8(Reg8::A), self.memory.get(self.reg.hl));
                self.reg.set_8(Reg8::A, val);
            }
            0x97 => {
                let val = self.sub(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0x98 => {
                let val = self.sbc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::B));
                self.reg.set_8(Reg8::A, val);
            }
            0x99 => {
                let val = self.sbc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::C));
                self.reg.set_8(Reg8::A, val);
            }
            0x9A => {
                let val = self.sbc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::D));
                self.reg.set_8(Reg8::A, val);
            }
            0x9B => {
                let val = self.sbc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::E));
                self.reg.set_8(Reg8::A, val);
            }
            0x9C => {
                let val = self.sbc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::H));
                self.reg.set_8(Reg8::A, val);
            }
            0x9D => {
                let val = self.sbc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::L));
                self.reg.set_8(Reg8::A, val);
            }
            0x9E => {
                let val = self.sbc(self.reg.get_8(Reg8::A), self.memory.get(self.reg.hl));
                self.reg.set_8(Reg8::A, val);
            }
            0x9F => {
                let val = self.sbc(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0xA0 => {
                let val = self.and(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::B));
                self.reg.set_8(Reg8::A, val);
            }
            0xA1 => {
                let val = self.and(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::C));
                self.reg.set_8(Reg8::A, val);
            }
            0xA2 => {
                let val = self.and(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::D));
                self.reg.set_8(Reg8::A, val);
            }
            0xA3 => {
                let val = self.and(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::E));
                self.reg.set_8(Reg8::A, val);
            }
            0xA4 => {
                let val = self.and(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::H));
                self.reg.set_8(Reg8::A, val);
            }
            0xA5 => {
                let val = self.and(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::L));
                self.reg.set_8(Reg8::A, val);
            }
            0xA6 => {
                let val = self.and(self.reg.get_8(Reg8::A), self.memory.get(self.reg.hl));
                self.reg.set_8(Reg8::A, val);
            }
            0xA7 => {
                let val = self.and(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0xA8 => {
                let val = self.xor(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::B));
                self.reg.set_8(Reg8::A, val);
            }
            0xA9 => {
                let val = self.xor(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::C));
                self.reg.set_8(Reg8::A, val);
            }
            0xAA => {
                let val = self.xor(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::D));
                self.reg.set_8(Reg8::A, val);
            }
            0xAB => {
                let val = self.xor(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::E));
                self.reg.set_8(Reg8::A, val);
            }
            0xAC => {
                let val = self.xor(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::H));
                self.reg.set_8(Reg8::A, val);
            }
            0xAD => {
                let val = self.xor(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::L));
                self.reg.set_8(Reg8::A, val);
            }
            0xAE => {
                let val = self.xor(self.reg.get_8(Reg8::A), self.memory.get(self.reg.hl));
                self.reg.set_8(Reg8::A, val);
            }
            0xAF => {
                let val = self.xor(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0xB0 => {
                let val = self.or(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::B));
                self.reg.set_8(Reg8::A, val);
            }
            0xB1 => {
                let val = self.or(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::C));
                self.reg.set_8(Reg8::A, val);
            }
            0xB2 => {
                let val = self.or(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::D));
                self.reg.set_8(Reg8::A, val);
            }
            0xB3 => {
                let val = self.or(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::E));
                self.reg.set_8(Reg8::A, val);
            }
            0xB4 => {
                let val = self.or(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::H));
                self.reg.set_8(Reg8::A, val);
            }
            0xB5 => {
                let val = self.or(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::L));
                self.reg.set_8(Reg8::A, val);
            }
            0xB6 => {
                let val = self.or(self.reg.get_8(Reg8::A), self.memory.get(self.reg.hl));
                self.reg.set_8(Reg8::A, val);
            }
            0xB7 => {
                let val = self.or(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::A));
                self.reg.set_8(Reg8::A, val);
            }
            0xB8 => self.cp(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::B)),
            0xB9 => self.cp(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::C)),
            0xBA => self.cp(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::D)),
            0xBB => self.cp(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::E)),
            0xBC => self.cp(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::H)),
            0xBD => self.cp(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::L)),
            0xBE => self.cp(self.reg.get_8(Reg8::A), self.memory.get(self.reg.hl)),
            0xBF => self.cp(self.reg.get_8(Reg8::A), self.reg.get_8(Reg8::A)),

            _ => {
                undefined(opcode);
            }
        }
    }

    // fn cb_subop(&mut self, subop: u8) {
    //     match subop {
    //         0x00 => unsafe { self.state.bc.as_u8s.left = self.rlc(self.state.bc.as_u8s.left) },
    //         0x01 => unsafe { self.state.bc.as_u8s.right = self.rlc(self.state.bc.as_u8s.right) },
    //         0x02 => unsafe { self.state.de.as_u8s.left = self.rlc(self.state.de.as_u8s.left) },
    //         0x03 => unsafe { self.state.de.as_u8s.right = self.rlc(self.state.de.as_u8s.right) },
    //         0x04 => unsafe { self.state.hl.as_u8s.left = self.rlc(self.state.hl.as_u8s.left) },
    //         0x05 => unsafe { self.state.hl.as_u8s.right = self.rlc(self.state.hl.as_u8s.right) },
    //         0x06 => unsafe {
    //             let rotated = self.rlc(self.memory.get(self.state.hl.as_u16));
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x07 => unsafe { self.state.af.as_u8s.left = self.rlc(self.state.af.as_u8s.left) },
    //         0x08 => unsafe { self.state.bc.as_u8s.left = self.rrc(self.state.bc.as_u8s.left) },
    //         0x09 => unsafe { self.state.bc.as_u8s.right = self.rrc(self.state.bc.as_u8s.right) },
    //         0x0A => unsafe { self.state.de.as_u8s.left = self.rrc(self.state.de.as_u8s.left) },
    //         0x0B => unsafe { self.state.de.as_u8s.right = self.rrc(self.state.de.as_u8s.right) },
    //         0x0C => unsafe { self.state.hl.as_u8s.left = self.rrc(self.state.hl.as_u8s.left) },
    //         0x0D => unsafe { self.state.hl.as_u8s.right = self.rrc(self.state.hl.as_u8s.right) },
    //         0x0E => unsafe {
    //             let rotated = self.rrc(self.memory.get(self.state.hl.as_u16));
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x0F => unsafe { self.state.af.as_u8s.left = self.rrc(self.state.af.as_u8s.left) },
    //         0x10 => unsafe { self.state.bc.as_u8s.left = self.rl(self.state.bc.as_u8s.left) },
    //         0x11 => unsafe { self.state.bc.as_u8s.right = self.rl(self.state.bc.as_u8s.right) },
    //         0x12 => unsafe { self.state.de.as_u8s.left = self.rl(self.state.de.as_u8s.left) },
    //         0x13 => unsafe { self.state.de.as_u8s.right = self.rl(self.state.de.as_u8s.right) },
    //         0x14 => unsafe { self.state.hl.as_u8s.left = self.rl(self.state.hl.as_u8s.left) },
    //         0x15 => unsafe { self.state.hl.as_u8s.right = self.rl(self.state.hl.as_u8s.right) },
    //         0x16 => unsafe {
    //             let rotated = self.rl(self.memory.get(self.state.hl.as_u16));
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x17 => unsafe { self.state.af.as_u8s.left = self.rl(self.state.af.as_u8s.left) },
    //         0x18 => unsafe { self.state.bc.as_u8s.left = self.rr(self.state.bc.as_u8s.left) },
    //         0x19 => unsafe { self.state.bc.as_u8s.right = self.rr(self.state.bc.as_u8s.right) },
    //         0x1A => unsafe { self.state.de.as_u8s.left = self.rr(self.state.de.as_u8s.left) },
    //         0x1B => unsafe { self.state.de.as_u8s.right = self.rr(self.state.de.as_u8s.right) },
    //         0x1C => unsafe { self.state.hl.as_u8s.left = self.rr(self.state.hl.as_u8s.left) },
    //         0x1D => unsafe { self.state.hl.as_u8s.right = self.rr(self.state.hl.as_u8s.right) },
    //         0x1E => unsafe {
    //             let rotated = self.rr(self.memory.get(self.state.hl.as_u16));
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x1F => unsafe { self.state.af.as_u8s.left = self.rr(self.state.af.as_u8s.left) },
    //         0x20 => unsafe { self.state.bc.as_u8s.left = self.sla(self.state.bc.as_u8s.left) },
    //         0x21 => unsafe { self.state.bc.as_u8s.right = self.sla(self.state.bc.as_u8s.right) },
    //         0x22 => unsafe { self.state.de.as_u8s.left = self.sla(self.state.de.as_u8s.left) },
    //         0x23 => unsafe { self.state.de.as_u8s.right = self.sla(self.state.de.as_u8s.right) },
    //         0x24 => unsafe { self.state.hl.as_u8s.left = self.sla(self.state.hl.as_u8s.left) },
    //         0x25 => unsafe { self.state.hl.as_u8s.right = self.sla(self.state.hl.as_u8s.right) },
    //         0x26 => unsafe {
    //             let rotated = self.sla(self.memory.get(self.state.hl.as_u16));
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x27 => unsafe { self.state.af.as_u8s.left = self.sla(self.state.af.as_u8s.left) },
    //         0x28 => unsafe { self.state.bc.as_u8s.left = self.sra(self.state.bc.as_u8s.left) },
    //         0x29 => unsafe { self.state.bc.as_u8s.right = self.sra(self.state.bc.as_u8s.right) },
    //         0x2A => unsafe { self.state.de.as_u8s.left = self.sra(self.state.de.as_u8s.left) },
    //         0x2B => unsafe { self.state.de.as_u8s.right = self.sra(self.state.de.as_u8s.right) },
    //         0x2C => unsafe { self.state.hl.as_u8s.left = self.sra(self.state.hl.as_u8s.left) },
    //         0x2D => unsafe { self.state.hl.as_u8s.right = self.sra(self.state.hl.as_u8s.right) },
    //         0x2E => unsafe {
    //             let rotated = self.sra(self.memory.get(self.state.hl.as_u16));
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x2F => unsafe { self.state.af.as_u8s.left = self.sra(self.state.af.as_u8s.left) },
    //         0x30 => unsafe { self.state.bc.as_u8s.left = swap_nibbles(self.state.bc.as_u8s.left) },
    //         0x31 => unsafe {
    //             self.state.bc.as_u8s.right = swap_nibbles(self.state.bc.as_u8s.right)
    //         },
    //         0x32 => unsafe { self.state.de.as_u8s.left = swap_nibbles(self.state.de.as_u8s.left) },
    //         0x33 => unsafe {
    //             self.state.de.as_u8s.right = swap_nibbles(self.state.de.as_u8s.right)
    //         },
    //         0x34 => unsafe { self.state.hl.as_u8s.left = swap_nibbles(self.state.hl.as_u8s.left) },
    //         0x35 => unsafe {
    //             self.state.hl.as_u8s.right = swap_nibbles(self.state.hl.as_u8s.right)
    //         },
    //         0x36 => unsafe {
    //             let rotated = swap_nibbles(self.memory.get(self.state.hl.as_u16));
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x37 => unsafe { self.state.af.as_u8s.left = swap_nibbles(self.state.af.as_u8s.left) },
    //         0x38 => unsafe { self.state.bc.as_u8s.left = self.srl(self.state.bc.as_u8s.left) },
    //         0x39 => unsafe { self.state.bc.as_u8s.right = self.srl(self.state.bc.as_u8s.right) },
    //         0x3A => unsafe { self.state.de.as_u8s.left = self.srl(self.state.de.as_u8s.left) },
    //         0x3B => unsafe { self.state.de.as_u8s.right = self.srl(self.state.de.as_u8s.right) },
    //         0x3C => unsafe { self.state.hl.as_u8s.left = self.srl(self.state.hl.as_u8s.left) },
    //         0x3D => unsafe { self.state.hl.as_u8s.right = self.srl(self.state.hl.as_u8s.right) },
    //         0x3E => unsafe {
    //             let rotated = self.srl(self.memory.get(self.state.hl.as_u16));
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x3F => unsafe { self.state.af.as_u8s.left = self.srl(self.state.af.as_u8s.left) },
    //         0x40 => unsafe { self.bit(self.state.bc.as_u8s.left, 0) },
    //         0x41 => unsafe { self.bit(self.state.bc.as_u8s.right, 0) },
    //         0x42 => unsafe { self.bit(self.state.de.as_u8s.left, 0) },
    //         0x43 => unsafe { self.bit(self.state.de.as_u8s.right, 0) },
    //         0x44 => unsafe { self.bit(self.state.hl.as_u8s.left, 0) },
    //         0x45 => unsafe { self.bit(self.state.hl.as_u8s.right, 0) },
    //         0x46 => unsafe {
    //             self.bit(self.memory.get(self.state.hl.as_u16), 0);
    //         },
    //         0x47 => unsafe { self.bit(self.state.af.as_u8s.left, 1) },
    //         0x48 => unsafe { self.bit(self.state.bc.as_u8s.left, 1) },
    //         0x49 => unsafe { self.bit(self.state.bc.as_u8s.right, 1) },
    //         0x4A => unsafe { self.bit(self.state.de.as_u8s.left, 1) },
    //         0x4B => unsafe { self.bit(self.state.de.as_u8s.right, 1) },
    //         0x4C => unsafe { self.bit(self.state.hl.as_u8s.left, 1) },
    //         0x4D => unsafe { self.bit(self.state.hl.as_u8s.right, 1) },
    //         0x4E => unsafe {
    //             self.bit(self.memory.get(self.state.hl.as_u16), 1);
    //         },
    //         0x4F => unsafe { self.bit(self.state.af.as_u8s.left, 1) },
    //         0x50 => unsafe { self.bit(self.state.bc.as_u8s.left, 2) },
    //         0x51 => unsafe { self.bit(self.state.bc.as_u8s.right, 2) },
    //         0x52 => unsafe { self.bit(self.state.de.as_u8s.left, 2) },
    //         0x53 => unsafe { self.bit(self.state.de.as_u8s.right, 2) },
    //         0x54 => unsafe { self.bit(self.state.hl.as_u8s.left, 2) },
    //         0x55 => unsafe { self.bit(self.state.hl.as_u8s.right, 2) },
    //         0x56 => unsafe {
    //             self.bit(self.memory.get(self.state.hl.as_u16), 2);
    //         },
    //         0x57 => unsafe { self.bit(self.state.af.as_u8s.left, 3) },
    //         0x58 => unsafe { self.bit(self.state.bc.as_u8s.left, 3) },
    //         0x59 => unsafe { self.bit(self.state.bc.as_u8s.right, 3) },
    //         0x5A => unsafe { self.bit(self.state.de.as_u8s.left, 3) },
    //         0x5B => unsafe { self.bit(self.state.de.as_u8s.right, 3) },
    //         0x5C => unsafe { self.bit(self.state.hl.as_u8s.left, 3) },
    //         0x5D => unsafe { self.bit(self.state.hl.as_u8s.right, 3) },
    //         0x5E => unsafe {
    //             self.bit(self.memory.get(self.state.hl.as_u16), 3);
    //         },
    //         0x5F => unsafe { self.bit(self.state.af.as_u8s.left, 3) },
    //         0x60 => unsafe { self.bit(self.state.bc.as_u8s.left, 4) },
    //         0x61 => unsafe { self.bit(self.state.bc.as_u8s.right, 4) },
    //         0x62 => unsafe { self.bit(self.state.de.as_u8s.left, 4) },
    //         0x63 => unsafe { self.bit(self.state.de.as_u8s.right, 4) },
    //         0x64 => unsafe { self.bit(self.state.hl.as_u8s.left, 4) },
    //         0x65 => unsafe { self.bit(self.state.hl.as_u8s.right, 4) },
    //         0x66 => unsafe {
    //             self.bit(self.memory.get(self.state.hl.as_u16), 4);
    //         },
    //         0x67 => unsafe { self.bit(self.state.af.as_u8s.left, 5) },
    //         0x68 => unsafe { self.bit(self.state.bc.as_u8s.left, 5) },
    //         0x69 => unsafe { self.bit(self.state.bc.as_u8s.right, 5) },
    //         0x6A => unsafe { self.bit(self.state.de.as_u8s.left, 5) },
    //         0x6B => unsafe { self.bit(self.state.de.as_u8s.right, 5) },
    //         0x6C => unsafe { self.bit(self.state.hl.as_u8s.left, 5) },
    //         0x6D => unsafe { self.bit(self.state.hl.as_u8s.right, 5) },
    //         0x6E => unsafe {
    //             self.bit(self.memory.get(self.state.hl.as_u16), 5);
    //         },
    //         0x6F => unsafe { self.bit(self.state.af.as_u8s.left, 5) },
    //         0x70 => unsafe { self.bit(self.state.bc.as_u8s.left, 6) },
    //         0x71 => unsafe { self.bit(self.state.bc.as_u8s.right, 6) },
    //         0x72 => unsafe { self.bit(self.state.de.as_u8s.left, 6) },
    //         0x73 => unsafe { self.bit(self.state.de.as_u8s.right, 6) },
    //         0x74 => unsafe { self.bit(self.state.hl.as_u8s.left, 6) },
    //         0x75 => unsafe { self.bit(self.state.hl.as_u8s.right, 6) },
    //         0x76 => unsafe {
    //             self.bit(self.memory.get(self.state.hl.as_u16), 6);
    //         },
    //         0x77 => unsafe { self.bit(self.state.af.as_u8s.left, 7) },
    //         0x78 => unsafe { self.bit(self.state.bc.as_u8s.left, 7) },
    //         0x79 => unsafe { self.bit(self.state.bc.as_u8s.right, 7) },
    //         0x7A => unsafe { self.bit(self.state.de.as_u8s.left, 7) },
    //         0x7B => unsafe { self.bit(self.state.de.as_u8s.right, 7) },
    //         0x7C => unsafe { self.bit(self.state.hl.as_u8s.left, 7) },
    //         0x7D => unsafe { self.bit(self.state.hl.as_u8s.right, 7) },
    //         0x7E => unsafe {
    //             self.bit(self.memory.get(self.state.hl.as_u16), 7);
    //         },
    //         0x7F => unsafe { self.bit(self.state.af.as_u8s.left, 7) },
    //         0x80 => unsafe { self.state.bc.as_u8s.left = res(self.state.bc.as_u8s.left, 0) },
    //         0x81 => unsafe { self.state.bc.as_u8s.right = res(self.state.bc.as_u8s.right, 0) },
    //         0x82 => unsafe { self.state.de.as_u8s.left = res(self.state.de.as_u8s.left, 0) },
    //         0x83 => unsafe { self.state.de.as_u8s.right = res(self.state.de.as_u8s.right, 0) },
    //         0x84 => unsafe { self.state.hl.as_u8s.left = res(self.state.hl.as_u8s.left, 0) },
    //         0x85 => unsafe { self.state.hl.as_u8s.right = res(self.state.hl.as_u8s.right, 0) },
    //         0x86 => unsafe {
    //             let rotated = res(self.memory.get(self.state.hl.as_u16), 0);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x87 => unsafe { self.state.af.as_u8s.left = res(self.state.af.as_u8s.left, 0) },
    //         0x88 => unsafe { self.state.bc.as_u8s.left = res(self.state.bc.as_u8s.left, 1) },
    //         0x89 => unsafe { self.state.bc.as_u8s.right = res(self.state.bc.as_u8s.right, 1) },
    //         0x8A => unsafe { self.state.de.as_u8s.left = res(self.state.de.as_u8s.left, 1) },
    //         0x8B => unsafe { self.state.de.as_u8s.right = res(self.state.de.as_u8s.right, 1) },
    //         0x8C => unsafe { self.state.hl.as_u8s.left = res(self.state.hl.as_u8s.left, 1) },
    //         0x8D => unsafe { self.state.hl.as_u8s.right = res(self.state.hl.as_u8s.right, 1) },
    //         0x8E => unsafe {
    //             let rotated = res(self.memory.get(self.state.hl.as_u16), 1);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x8F => unsafe { self.state.af.as_u8s.left = res(self.state.af.as_u8s.left, 1) },
    //         0x90 => unsafe { self.state.bc.as_u8s.left = res(self.state.bc.as_u8s.left, 2) },
    //         0x91 => unsafe { self.state.bc.as_u8s.right = res(self.state.bc.as_u8s.right, 2) },
    //         0x92 => unsafe { self.state.de.as_u8s.left = res(self.state.de.as_u8s.left, 2) },
    //         0x93 => unsafe { self.state.de.as_u8s.right = res(self.state.de.as_u8s.right, 2) },
    //         0x94 => unsafe { self.state.hl.as_u8s.left = res(self.state.hl.as_u8s.left, 2) },
    //         0x95 => unsafe { self.state.hl.as_u8s.right = res(self.state.hl.as_u8s.right, 2) },
    //         0x96 => unsafe {
    //             let rotated = res(self.memory.get(self.state.hl.as_u16), 2);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x97 => unsafe { self.state.af.as_u8s.left = res(self.state.af.as_u8s.left, 2) },
    //         0x98 => unsafe { self.state.bc.as_u8s.left = res(self.state.bc.as_u8s.left, 3) },
    //         0x99 => unsafe { self.state.bc.as_u8s.right = res(self.state.bc.as_u8s.right, 3) },
    //         0x9A => unsafe { self.state.de.as_u8s.left = res(self.state.de.as_u8s.left, 3) },
    //         0x9B => unsafe { self.state.de.as_u8s.right = res(self.state.de.as_u8s.right, 3) },
    //         0x9C => unsafe { self.state.hl.as_u8s.left = res(self.state.hl.as_u8s.left, 3) },
    //         0x9D => unsafe { self.state.hl.as_u8s.right = res(self.state.hl.as_u8s.right, 3) },
    //         0x9E => unsafe {
    //             let rotated = res(self.memory.get(self.state.hl.as_u16), 3);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0x9F => unsafe { self.state.af.as_u8s.left = res(self.state.af.as_u8s.left, 3) },
    //         0xA0 => unsafe { self.state.bc.as_u8s.left = res(self.state.bc.as_u8s.left, 4) },
    //         0xA1 => unsafe { self.state.bc.as_u8s.right = res(self.state.bc.as_u8s.right, 4) },
    //         0xA2 => unsafe { self.state.de.as_u8s.left = res(self.state.de.as_u8s.left, 4) },
    //         0xA3 => unsafe { self.state.de.as_u8s.right = res(self.state.de.as_u8s.right, 4) },
    //         0xA4 => unsafe { self.state.hl.as_u8s.left = res(self.state.hl.as_u8s.left, 4) },
    //         0xA5 => unsafe { self.state.hl.as_u8s.right = res(self.state.hl.as_u8s.right, 4) },
    //         0xA6 => unsafe {
    //             let rotated = res(self.memory.get(self.state.hl.as_u16), 4);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xA7 => unsafe { self.state.af.as_u8s.left = res(self.state.af.as_u8s.left, 4) },
    //         0xA8 => unsafe { self.state.bc.as_u8s.left = res(self.state.bc.as_u8s.left, 5) },
    //         0xA9 => unsafe { self.state.bc.as_u8s.right = res(self.state.bc.as_u8s.right, 5) },
    //         0xAA => unsafe { self.state.de.as_u8s.left = res(self.state.de.as_u8s.left, 5) },
    //         0xAB => unsafe { self.state.de.as_u8s.right = res(self.state.de.as_u8s.right, 5) },
    //         0xAC => unsafe { self.state.hl.as_u8s.left = res(self.state.hl.as_u8s.left, 5) },
    //         0xAD => unsafe { self.state.hl.as_u8s.right = res(self.state.hl.as_u8s.right, 5) },
    //         0xAE => unsafe {
    //             let rotated = res(self.memory.get(self.state.hl.as_u16), 5);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xAF => unsafe { self.state.af.as_u8s.left = res(self.state.af.as_u8s.left, 5) },
    //         0xB0 => unsafe { self.state.bc.as_u8s.left = res(self.state.bc.as_u8s.left, 6) },
    //         0xB1 => unsafe { self.state.bc.as_u8s.right = res(self.state.bc.as_u8s.right, 6) },
    //         0xB2 => unsafe { self.state.de.as_u8s.left = res(self.state.de.as_u8s.left, 6) },
    //         0xB3 => unsafe { self.state.de.as_u8s.right = res(self.state.de.as_u8s.right, 6) },
    //         0xB4 => unsafe { self.state.hl.as_u8s.left = res(self.state.hl.as_u8s.left, 6) },
    //         0xB5 => unsafe { self.state.hl.as_u8s.right = res(self.state.hl.as_u8s.right, 6) },
    //         0xB6 => unsafe {
    //             let rotated = res(self.memory.get(self.state.hl.as_u16), 6);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xB7 => unsafe { self.state.af.as_u8s.left = res(self.state.af.as_u8s.left, 6) },
    //         0xB8 => unsafe { self.state.bc.as_u8s.left = res(self.state.bc.as_u8s.left, 7) },
    //         0xB9 => unsafe { self.state.bc.as_u8s.right = res(self.state.bc.as_u8s.right, 7) },
    //         0xBA => unsafe { self.state.de.as_u8s.left = res(self.state.de.as_u8s.left, 7) },
    //         0xBB => unsafe { self.state.de.as_u8s.right = res(self.state.de.as_u8s.right, 7) },
    //         0xBC => unsafe { self.state.hl.as_u8s.left = res(self.state.hl.as_u8s.left, 7) },
    //         0xBD => unsafe { self.state.hl.as_u8s.right = res(self.state.hl.as_u8s.right, 7) },
    //         0xBE => unsafe {
    //             let rotated = res(self.memory.get(self.state.hl.as_u16), 7);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xBF => unsafe { self.state.af.as_u8s.left = res(self.state.af.as_u8s.left, 7) },
    //         0xC0 => unsafe { self.state.bc.as_u8s.left = set(self.state.bc.as_u8s.left, 0) },
    //         0xC1 => unsafe { self.state.bc.as_u8s.right = set(self.state.bc.as_u8s.right, 0) },
    //         0xC2 => unsafe { self.state.de.as_u8s.left = set(self.state.de.as_u8s.left, 0) },
    //         0xC3 => unsafe { self.state.de.as_u8s.right = set(self.state.de.as_u8s.right, 0) },
    //         0xC4 => unsafe { self.state.hl.as_u8s.left = set(self.state.hl.as_u8s.left, 0) },
    //         0xC5 => unsafe { self.state.hl.as_u8s.right = set(self.state.hl.as_u8s.right, 0) },
    //         0xC6 => unsafe {
    //             let rotated = set(self.memory.get(self.state.hl.as_u16), 0);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xC7 => unsafe { self.state.af.as_u8s.left = set(self.state.af.as_u8s.left, 0) },
    //         0xC8 => unsafe { self.state.bc.as_u8s.left = set(self.state.bc.as_u8s.left, 1) },
    //         0xC9 => unsafe { self.state.bc.as_u8s.right = set(self.state.bc.as_u8s.right, 1) },
    //         0xCA => unsafe { self.state.de.as_u8s.left = set(self.state.de.as_u8s.left, 1) },
    //         0xCB => unsafe { self.state.de.as_u8s.right = set(self.state.de.as_u8s.right, 1) },
    //         0xCC => unsafe { self.state.hl.as_u8s.left = set(self.state.hl.as_u8s.left, 1) },
    //         0xCD => unsafe { self.state.hl.as_u8s.right = set(self.state.hl.as_u8s.right, 1) },
    //         0xCE => unsafe {
    //             let rotated = set(self.memory.get(self.state.hl.as_u16), 1);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xCF => unsafe { self.state.af.as_u8s.left = set(self.state.af.as_u8s.left, 1) },
    //         0xD0 => unsafe { self.state.bc.as_u8s.left = set(self.state.bc.as_u8s.left, 2) },
    //         0xD1 => unsafe { self.state.bc.as_u8s.right = set(self.state.bc.as_u8s.right, 2) },
    //         0xD2 => unsafe { self.state.de.as_u8s.left = set(self.state.de.as_u8s.left, 2) },
    //         0xD3 => unsafe { self.state.de.as_u8s.right = set(self.state.de.as_u8s.right, 2) },
    //         0xD4 => unsafe { self.state.hl.as_u8s.left = set(self.state.hl.as_u8s.left, 2) },
    //         0xD5 => unsafe { self.state.hl.as_u8s.right = set(self.state.hl.as_u8s.right, 2) },
    //         0xD6 => unsafe {
    //             let rotated = set(self.memory.get(self.state.hl.as_u16), 2);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xD7 => unsafe { self.state.af.as_u8s.left = set(self.state.af.as_u8s.left, 2) },
    //         0xD8 => unsafe { self.state.bc.as_u8s.left = set(self.state.bc.as_u8s.left, 3) },
    //         0xD9 => unsafe { self.state.bc.as_u8s.right = set(self.state.bc.as_u8s.right, 3) },
    //         0xDA => unsafe { self.state.de.as_u8s.left = set(self.state.de.as_u8s.left, 3) },
    //         0xDB => unsafe { self.state.de.as_u8s.right = set(self.state.de.as_u8s.right, 3) },
    //         0xDC => unsafe { self.state.hl.as_u8s.left = set(self.state.hl.as_u8s.left, 3) },
    //         0xDD => unsafe { self.state.hl.as_u8s.right = set(self.state.hl.as_u8s.right, 3) },
    //         0xDE => unsafe {
    //             let rotated = set(self.memory.get(self.state.hl.as_u16), 3);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xDF => unsafe { self.state.af.as_u8s.left = set(self.state.af.as_u8s.left, 3) },
    //         0xE0 => unsafe { self.state.bc.as_u8s.left = set(self.state.bc.as_u8s.left, 4) },
    //         0xE1 => unsafe { self.state.bc.as_u8s.right = set(self.state.bc.as_u8s.right, 4) },
    //         0xE2 => unsafe { self.state.de.as_u8s.left = set(self.state.de.as_u8s.left, 4) },
    //         0xE3 => unsafe { self.state.de.as_u8s.right = set(self.state.de.as_u8s.right, 4) },
    //         0xE4 => unsafe { self.state.hl.as_u8s.left = set(self.state.hl.as_u8s.left, 4) },
    //         0xE5 => unsafe { self.state.hl.as_u8s.right = set(self.state.hl.as_u8s.right, 4) },
    //         0xE6 => unsafe {
    //             let rotated = set(self.memory.get(self.state.hl.as_u16), 4);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xE7 => unsafe { self.state.af.as_u8s.left = set(self.state.af.as_u8s.left, 4) },
    //         0xE8 => unsafe { self.state.bc.as_u8s.left = set(self.state.bc.as_u8s.left, 5) },
    //         0xE9 => unsafe { self.state.bc.as_u8s.right = set(self.state.bc.as_u8s.right, 5) },
    //         0xEA => unsafe { self.state.de.as_u8s.left = set(self.state.de.as_u8s.left, 5) },
    //         0xEB => unsafe { self.state.de.as_u8s.right = set(self.state.de.as_u8s.right, 5) },
    //         0xEC => unsafe { self.state.hl.as_u8s.left = set(self.state.hl.as_u8s.left, 5) },
    //         0xED => unsafe { self.state.hl.as_u8s.right = set(self.state.hl.as_u8s.right, 5) },
    //         0xEE => unsafe {
    //             let rotated = set(self.memory.get(self.state.hl.as_u16), 5);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xEF => unsafe { self.state.af.as_u8s.left = set(self.state.af.as_u8s.left, 5) },
    //         0xF0 => unsafe { self.state.bc.as_u8s.left = set(self.state.bc.as_u8s.left, 6) },
    //         0xF1 => unsafe { self.state.bc.as_u8s.right = set(self.state.bc.as_u8s.right, 6) },
    //         0xF2 => unsafe { self.state.de.as_u8s.left = set(self.state.de.as_u8s.left, 6) },
    //         0xF3 => unsafe { self.state.de.as_u8s.right = set(self.state.de.as_u8s.right, 6) },
    //         0xF4 => unsafe { self.state.hl.as_u8s.left = set(self.state.hl.as_u8s.left, 6) },
    //         0xF5 => unsafe { self.state.hl.as_u8s.right = set(self.state.hl.as_u8s.right, 6) },
    //         0xF6 => unsafe {
    //             let rotated = set(self.memory.get(self.state.hl.as_u16), 6);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xF7 => unsafe { self.state.af.as_u8s.left = set(self.state.af.as_u8s.left, 6) },
    //         0xF8 => unsafe { self.state.bc.as_u8s.left = set(self.state.bc.as_u8s.left, 7) },
    //         0xF9 => unsafe { self.state.bc.as_u8s.right = set(self.state.bc.as_u8s.right, 7) },
    //         0xFA => unsafe { self.state.de.as_u8s.left = set(self.state.de.as_u8s.left, 7) },
    //         0xFB => unsafe { self.state.de.as_u8s.right = set(self.state.de.as_u8s.right, 7) },
    //         0xFC => unsafe { self.state.hl.as_u8s.left = set(self.state.hl.as_u8s.left, 7) },
    //         0xFD => unsafe { self.state.hl.as_u8s.right = set(self.state.hl.as_u8s.right, 7) },
    //         0xFE => unsafe {
    //             let rotated = set(self.memory.get(self.state.hl.as_u16), 7);
    //             self.memory.set(self.state.hl.as_u16, rotated)
    //         },
    //         0xFF => unsafe { self.state.af.as_u8s.left = set(self.state.af.as_u8s.left, 7) },
    //     }
    // }

    #[allow(dead_code)]
    fn instruction_length(&self, _opcode: u8) -> u8 {
        1
    }
}

fn undefined(opcode: u8) {
    panic!("Undefined behaviour: opcode {:#X}", opcode);
}