inst.rs

fn ld_sp_hl(cpu: &mut Cpu) {
    cpu.sp = cpu.hl();
}

fn ld_a_mu16(cpu: &mut Cpu) {
    let word = cpu.read_u16();
    let byte = cpu.mmu.read(word);
    cpu.a = byte;
}

fn ei(cpu: &mut Cpu) {
    cpu.enable_int();
}

fn cp_a_u8(cpu: &mut Cpu) {
    let byte = cpu.read_u8();
    sub_set_flags(cpu, cpu.a, byte);
}

fn rst_38h(cpu: &mut Cpu) {
    rst(cpu, 0x0038);
}

fn rlc_b(cpu: &mut Cpu) {
    cpu.b = rlc(cpu, cpu.b);
}

fn rlc_c(cpu: &mut Cpu) {
    cpu.c = rlc(cpu, cpu.c);
}

fn rlc_d(cpu: &mut Cpu) {
    cpu.d = rlc(cpu, cpu.d);
}

fn rlc_e(cpu: &mut Cpu) {
    cpu.e = rlc(cpu, cpu.e);
}

fn rlc_h(cpu: &mut Cpu) {
    cpu.h = rlc(cpu, cpu.h);
}

fn rlc_l(cpu: &mut Cpu) {
    cpu.l = rlc(cpu, cpu.l);
}

fn rlc_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let result = rlc(cpu, byte);
    cpu.mmu.write(hl, result);
}

fn rlc_a(cpu: &mut Cpu) {
    cpu.a = rlc(cpu, cpu.a);
}

fn rrc_b(cpu: &mut Cpu) {
    cpu.b = rrc(cpu, cpu.b);
}

fn rrc_c(cpu: &mut Cpu) {
    cpu.c = rrc(cpu, cpu.c);
}

fn rrc_d(cpu: &mut Cpu) {
    cpu.d = rrc(cpu, cpu.d);
}

fn rrc_e(cpu: &mut Cpu) {
    cpu.e = rrc(cpu, cpu.e);
}

fn rrc_h(cpu: &mut Cpu) {
    cpu.h = rrc(cpu, cpu.h);
}

fn rrc_l(cpu: &mut Cpu) {
    cpu.l = rrc(cpu, cpu.l);
}

fn rrc_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let result = rrc(cpu, byte);
    cpu.mmu.write(hl, result);
}

fn rrc_a(cpu: &mut Cpu) {
    cpu.a = rrc(cpu, cpu.a);
}

fn rl_b(cpu: &mut Cpu) {
    cpu.b = rl(cpu, cpu.b);
}

fn rl_c(cpu: &mut Cpu) {
    cpu.c = rl(cpu, cpu.c);
}

fn rl_d(cpu: &mut Cpu) {
    cpu.d = rl(cpu, cpu.d);
}

fn rl_e(cpu: &mut Cpu) {
    cpu.e = rl(cpu, cpu.e);
}

fn rl_h(cpu: &mut Cpu) {
    cpu.h = rl(cpu, cpu.h);
}

fn rl_l(cpu: &mut Cpu) {
    cpu.l = rl(cpu, cpu.l);
}

fn rl_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let result = rl(cpu, byte);
    cpu.mmu.write(hl, result);
}

fn rl_a(cpu: &mut Cpu) {
    cpu.a = rl(cpu, cpu.a);
}

fn rr_b(cpu: &mut Cpu) {
    cpu.b = rr(cpu, cpu.b);
}

fn rr_c(cpu: &mut Cpu) {
    cpu.c = rr(cpu, cpu.c);
}

fn rr_d(cpu: &mut Cpu) {
    cpu.d = rr(cpu, cpu.d);
}

fn rr_e(cpu: &mut Cpu) {
    cpu.e = rr(cpu, cpu.e);
}

fn rr_h(cpu: &mut Cpu) {
    cpu.h = rr(cpu, cpu.h);
}

fn rr_l(cpu: &mut Cpu) {
    cpu.l = rr(cpu, cpu.l);
}

fn rr_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let result = rr(cpu, byte);
    cpu.mmu.write(hl, result);
}

fn rr_a(cpu: &mut Cpu) {
    cpu.a = rr(cpu, cpu.a);
}

fn sla_b(cpu: &mut Cpu) {
    cpu.b = sla(cpu, cpu.b);
}

fn sla_c(cpu: &mut Cpu) {
    cpu.c = sla(cpu, cpu.c);
}

fn sla_d(cpu: &mut Cpu) {
    cpu.d = sla(cpu, cpu.d);
}

fn sla_e(cpu: &mut Cpu) {
    cpu.e = sla(cpu, cpu.e);
}

fn sla_h(cpu: &mut Cpu) {
    cpu.h = sla(cpu, cpu.h);
}

fn sla_l(cpu: &mut Cpu) {
    cpu.l = sla(cpu, cpu.l);
}

fn sla_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let result = sla(cpu, byte);
    cpu.mmu.write(hl, result);
}

fn sla_a(cpu: &mut Cpu) {
    cpu.a = sla(cpu, cpu.a);
}

fn sra_b(cpu: &mut Cpu) {
    cpu.b = sra(cpu, cpu.b);
}

fn sra_c(cpu: &mut Cpu) {
    cpu.c = sra(cpu, cpu.c);
}

fn sra_d(cpu: &mut Cpu) {
    cpu.d = sra(cpu, cpu.d);
}

fn sra_e(cpu: &mut Cpu) {
    cpu.e = sra(cpu, cpu.e);
}

fn sra_h(cpu: &mut Cpu) {
    cpu.h = sra(cpu, cpu.h);
}

fn sra_l(cpu: &mut Cpu) {
    cpu.l = sra(cpu, cpu.l);
}

fn sra_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let result = sra(cpu, byte);
    cpu.mmu.write(hl, result);
}

fn sra_a(cpu: &mut Cpu) {
    cpu.a = sra(cpu, cpu.a);
}

fn swap_b(cpu: &mut Cpu) {
    cpu.b = swap(cpu, cpu.b)
}

fn swap_c(cpu: &mut Cpu) {
    cpu.c = swap(cpu, cpu.c)
}

fn swap_d(cpu: &mut Cpu) {
    cpu.d = swap(cpu, cpu.d)
}

fn swap_e(cpu: &mut Cpu) {
    cpu.e = swap(cpu, cpu.e)
}

fn swap_h(cpu: &mut Cpu) {
    cpu.h = swap(cpu, cpu.h)
}

fn swap_l(cpu: &mut Cpu) {
    cpu.l = swap(cpu, cpu.l)
}

fn swap_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let result = swap(cpu, byte);
    cpu.mmu.write(hl, result);
}

fn swap_a(cpu: &mut Cpu) {
    cpu.a = swap(cpu, cpu.a)
}

fn srl_b(cpu: &mut Cpu) {
    cpu.b = srl(cpu, cpu.b);
}

fn srl_c(cpu: &mut Cpu) {
    cpu.c = srl(cpu, cpu.c);
}

fn srl_d(cpu: &mut Cpu) {
    cpu.d = srl(cpu, cpu.d);
}

fn srl_e(cpu: &mut Cpu) {
    cpu.e = srl(cpu, cpu.e);
}

fn srl_h(cpu: &mut Cpu) {
    cpu.h = srl(cpu, cpu.h);
}

fn srl_l(cpu: &mut Cpu) {
    cpu.l = srl(cpu, cpu.l);
}

fn srl_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let result = srl(cpu, byte);
    cpu.mmu.write(hl, result);
}

fn srl_a(cpu: &mut Cpu) {
    cpu.a = srl(cpu, cpu.a);
}

fn bit_0_b(cpu: &mut Cpu) {
    bit_b(cpu, 0);
}

fn bit_0_c(cpu: &mut Cpu) {
    bit_c(cpu, 0);
}

fn bit_0_d(cpu: &mut Cpu) {
    bit_d(cpu, 0);
}

fn bit_0_e(cpu: &mut Cpu) {
    bit_e(cpu, 0);
}

fn bit_0_h(cpu: &mut Cpu) {
    bit_h(cpu, 0);
}

fn bit_0_l(cpu: &mut Cpu) {
    bit_l(cpu, 0);
}

fn bit_0_mhl(cpu: &mut Cpu) {
    bit_mhl(cpu, 0);
}

fn bit_0_a(cpu: &mut Cpu) {
    bit_a(cpu, 0);
}

fn bit_1_b(cpu: &mut Cpu) {
    bit_b(cpu, 1);
}

fn bit_1_c(cpu: &mut Cpu) {
    bit_c(cpu, 1);
}

fn bit_1_d(cpu: &mut Cpu) {
    bit_d(cpu, 1);
}

fn bit_1_e(cpu: &mut Cpu) {
    bit_e(cpu, 1);
}

fn bit_1_h(cpu: &mut Cpu) {
    bit_h(cpu, 1);
}

fn bit_1_l(cpu: &mut Cpu) {
    bit_l(cpu, 1);
}

fn bit_1_mhl(cpu: &mut Cpu) {
    bit_mhl(cpu, 1);
}

fn bit_1_a(cpu: &mut Cpu) {
    bit_a(cpu, 1);
}

fn bit_2_b(cpu: &mut Cpu) {
    bit_b(cpu, 2);
}

fn bit_2_c(cpu: &mut Cpu) {
    bit_c(cpu, 2);
}

fn bit_2_d(cpu: &mut Cpu) {
    bit_d(cpu, 2);
}

fn bit_2_e(cpu: &mut Cpu) {
    bit_e(cpu, 2);
}

fn bit_2_h(cpu: &mut Cpu) {
    bit_h(cpu, 2);
}

fn bit_2_l(cpu: &mut Cpu) {
    bit_l(cpu, 2);
}

fn bit_2_mhl(cpu: &mut Cpu) {
    bit_mhl(cpu, 2);
}

fn bit_2_a(cpu: &mut Cpu) {
    bit_a(cpu, 2);
}

fn bit_3_b(cpu: &mut Cpu) {
    bit_b(cpu, 3);
}

fn bit_3_c(cpu: &mut Cpu) {
    bit_c(cpu, 3);
}

fn bit_3_d(cpu: &mut Cpu) {
    bit_d(cpu, 3);
}

fn bit_3_e(cpu: &mut Cpu) {
    bit_e(cpu, 3);
}

fn bit_3_h(cpu: &mut Cpu) {
    bit_h(cpu, 3);
}

fn bit_3_l(cpu: &mut Cpu) {
    bit_l(cpu, 3);
}

fn bit_3_mhl(cpu: &mut Cpu) {
    bit_mhl(cpu, 3);
}

fn bit_3_a(cpu: &mut Cpu) {
    bit_a(cpu, 3);
}

fn bit_4_b(cpu: &mut Cpu) {
    bit_b(cpu, 4);
}

fn bit_4_c(cpu: &mut Cpu) {
    bit_c(cpu, 4);
}

fn bit_4_d(cpu: &mut Cpu) {
    bit_d(cpu, 4);
}

fn bit_4_e(cpu: &mut Cpu) {
    bit_e(cpu, 4);
}

fn bit_4_h(cpu: &mut Cpu) {
    bit_h(cpu, 4);
}

fn bit_4_l(cpu: &mut Cpu) {
    bit_l(cpu, 4);
}

fn bit_4_mhl(cpu: &mut Cpu) {
    bit_mhl(cpu, 4);
}

fn bit_4_a(cpu: &mut Cpu) {
    bit_a(cpu, 4);
}

fn bit_5_b(cpu: &mut Cpu) {
    bit_b(cpu, 5);
}

fn bit_5_c(cpu: &mut Cpu) {
    bit_c(cpu, 5);
}

fn bit_5_d(cpu: &mut Cpu) {
    bit_d(cpu, 5);
}

fn bit_5_e(cpu: &mut Cpu) {
    bit_e(cpu, 5);
}

fn bit_5_h(cpu: &mut Cpu) {
    bit_h(cpu, 5);
}

fn bit_5_l(cpu: &mut Cpu) {
    bit_l(cpu, 5);
}

fn bit_5_mhl(cpu: &mut Cpu) {
    bit_mhl(cpu, 5);
}

fn bit_5_a(cpu: &mut Cpu) {
    bit_a(cpu, 5);
}

fn bit_6_b(cpu: &mut Cpu) {
    bit_b(cpu, 6);
}

fn bit_6_c(cpu: &mut Cpu) {
    bit_c(cpu, 6);
}

fn bit_6_d(cpu: &mut Cpu) {
    bit_d(cpu, 6);
}

fn bit_6_e(cpu: &mut Cpu) {
    bit_e(cpu, 6);
}

fn bit_6_h(cpu: &mut Cpu) {
    bit_h(cpu, 6);
}

fn bit_6_l(cpu: &mut Cpu) {
    bit_l(cpu, 6);
}

fn bit_6_mhl(cpu: &mut Cpu) {
    bit_mhl(cpu, 6);
}

fn bit_6_a(cpu: &mut Cpu) {
    bit_a(cpu, 6);
}

fn bit_7_b(cpu: &mut Cpu) {
    bit_b(cpu, 7);
}

fn bit_7_c(cpu: &mut Cpu) {
    bit_c(cpu, 7);
}

fn bit_7_d(cpu: &mut Cpu) {
    bit_d(cpu, 7);
}

fn bit_7_e(cpu: &mut Cpu) {
    bit_e(cpu, 7);
}

fn bit_7_h(cpu: &mut Cpu) {
    bit_h(cpu, 7);
}

fn bit_7_l(cpu: &mut Cpu) {
    bit_l(cpu, 7);
}

fn bit_7_mhl(cpu: &mut Cpu) {
    bit_mhl(cpu, 7);
}

fn bit_7_a(cpu: &mut Cpu) {
    bit_a(cpu, 7);
}

fn res_0_b(cpu: &mut Cpu) {
    cpu.b = res(cpu.b, 0);
}

fn res_0_c(cpu: &mut Cpu) {
    cpu.c = res(cpu.c, 0);
}

fn res_0_d(cpu: &mut Cpu) {
    cpu.d = res(cpu.d, 0);
}

fn res_0_e(cpu: &mut Cpu) {
    cpu.e = res(cpu.e, 0);
}

fn res_0_h(cpu: &mut Cpu) {
    cpu.h = res(cpu.h, 0);
}

fn res_0_l(cpu: &mut Cpu) {
    cpu.l = res(cpu.l, 0);
}

fn res_0_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = res(byte, 0);
    cpu.mmu.write(hl, value);
}

fn res_0_a(cpu: &mut Cpu) {
    cpu.a = res(cpu.a, 0);
}

fn res_1_b(cpu: &mut Cpu) {
    cpu.b = res(cpu.b, 1);
}

fn res_1_c(cpu: &mut Cpu) {
    cpu.c = res(cpu.c, 1);
}

fn res_1_d(cpu: &mut Cpu) {
    cpu.d = res(cpu.d, 1);
}

fn res_1_e(cpu: &mut Cpu) {
    cpu.e = res(cpu.e, 1);
}

fn res_1_h(cpu: &mut Cpu) {
    cpu.h = res(cpu.h, 1);
}

fn res_1_l(cpu: &mut Cpu) {
    cpu.l = res(cpu.l, 1);
}

fn res_1_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = res(byte, 1);
    cpu.mmu.write(hl, value);
}

fn res_1_a(cpu: &mut Cpu) {
    cpu.a = res(cpu.a, 1);
}

fn res_2_b(cpu: &mut Cpu) {
    cpu.b = res(cpu.b, 2);
}

fn res_2_c(cpu: &mut Cpu) {
    cpu.c = res(cpu.c, 2);
}

fn res_2_d(cpu: &mut Cpu) {
    cpu.d = res(cpu.d, 2);
}

fn res_2_e(cpu: &mut Cpu) {
    cpu.e = res(cpu.e, 2);
}

fn res_2_h(cpu: &mut Cpu) {
    cpu.h = res(cpu.h, 2);
}

fn res_2_l(cpu: &mut Cpu) {
    cpu.l = res(cpu.l, 2);
}

fn res_2_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = res(byte, 2);
    cpu.mmu.write(hl, value);
}

fn res_2_a(cpu: &mut Cpu) {
    cpu.a = res(cpu.a, 2);
}

fn res_3_b(cpu: &mut Cpu) {
    cpu.b = res(cpu.b, 3);
}

fn res_3_c(cpu: &mut Cpu) {
    cpu.c = res(cpu.c, 3);
}

fn res_3_d(cpu: &mut Cpu) {
    cpu.d = res(cpu.d, 3);
}

fn res_3_e(cpu: &mut Cpu) {
    cpu.e = res(cpu.e, 3);
}

fn res_3_h(cpu: &mut Cpu) {
    cpu.h = res(cpu.h, 3);
}

fn res_3_l(cpu: &mut Cpu) {
    cpu.l = res(cpu.l, 3);
}

fn res_3_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = res(byte, 3);
    cpu.mmu.write(hl, value);
}

fn res_3_a(cpu: &mut Cpu) {
    cpu.a = res(cpu.a, 3);
}

fn res_4_b(cpu: &mut Cpu) {
    cpu.b = res(cpu.b, 4);
}

fn res_4_c(cpu: &mut Cpu) {
    cpu.c = res(cpu.c, 4);
}

fn res_4_d(cpu: &mut Cpu) {
    cpu.d = res(cpu.d, 4);
}

fn res_4_e(cpu: &mut Cpu) {
    cpu.e = res(cpu.e, 4);
}

fn res_4_h(cpu: &mut Cpu) {
    cpu.h = res(cpu.h, 4);
}

fn res_4_l(cpu: &mut Cpu) {
    cpu.l = res(cpu.l, 4);
}

fn res_4_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = res(byte, 4);
    cpu.mmu.write(hl, value);
}

fn res_4_a(cpu: &mut Cpu) {
    cpu.a = res(cpu.a, 4);
}

fn res_5_b(cpu: &mut Cpu) {
    cpu.b = res(cpu.b, 5);
}

fn res_5_c(cpu: &mut Cpu) {
    cpu.c = res(cpu.c, 5);
}

fn res_5_d(cpu: &mut Cpu) {
    cpu.d = res(cpu.d, 5);
}

fn res_5_e(cpu: &mut Cpu) {
    cpu.e = res(cpu.e, 5);
}

fn res_5_h(cpu: &mut Cpu) {
    cpu.h = res(cpu.h, 5);
}

fn res_5_l(cpu: &mut Cpu) {
    cpu.l = res(cpu.l, 5);
}

fn res_5_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = res(byte, 5);
    cpu.mmu.write(hl, value);
}

fn res_5_a(cpu: &mut Cpu) {
    cpu.a = res(cpu.a, 5);
}

fn res_6_b(cpu: &mut Cpu) {
    cpu.b = res(cpu.b, 6);
}

fn res_6_c(cpu: &mut Cpu) {
    cpu.c = res(cpu.c, 6);
}

fn res_6_d(cpu: &mut Cpu) {
    cpu.d = res(cpu.d, 6);
}

fn res_6_e(cpu: &mut Cpu) {
    cpu.e = res(cpu.e, 6);
}

fn res_6_h(cpu: &mut Cpu) {
    cpu.h = res(cpu.h, 6);
}

fn res_6_l(cpu: &mut Cpu) {
    cpu.l = res(cpu.l, 6);
}

fn res_6_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = res(byte, 6);
    cpu.mmu.write(hl, value);
}

fn res_6_a(cpu: &mut Cpu) {
    cpu.a = res(cpu.a, 6);
}

fn res_7_b(cpu: &mut Cpu) {
    cpu.b = res(cpu.b, 7);
}

fn res_7_c(cpu: &mut Cpu) {
    cpu.c = res(cpu.c, 7);
}

fn res_7_d(cpu: &mut Cpu) {
    cpu.d = res(cpu.d, 7);
}

fn res_7_e(cpu: &mut Cpu) {
    cpu.e = res(cpu.e, 7);
}

fn res_7_h(cpu: &mut Cpu) {
    cpu.h = res(cpu.h, 7);
}

fn res_7_l(cpu: &mut Cpu) {
    cpu.l = res(cpu.l, 7);
}

fn res_7_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = res(byte, 7);
    cpu.mmu.write(hl, value);
}

fn res_7_a(cpu: &mut Cpu) {
    cpu.a = res(cpu.a, 7);
}

fn set_0_b(cpu: &mut Cpu) {
    cpu.b = set(cpu.b, 0);
}

fn set_0_c(cpu: &mut Cpu) {
    cpu.c = set(cpu.c, 0);
}

fn set_0_d(cpu: &mut Cpu) {
    cpu.d = set(cpu.d, 0);
}

fn set_0_e(cpu: &mut Cpu) {
    cpu.e = set(cpu.e, 0);
}

fn set_0_h(cpu: &mut Cpu) {
    cpu.h = set(cpu.h, 0);
}

fn set_0_l(cpu: &mut Cpu) {
    cpu.l = set(cpu.l, 0);
}

fn set_0_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = set(byte, 0);
    cpu.mmu.write(hl, value);
}

fn set_0_a(cpu: &mut Cpu) {
    cpu.a = set(cpu.a, 0);
}

fn set_1_b(cpu: &mut Cpu) {
    cpu.b = set(cpu.b, 1);
}

fn set_1_c(cpu: &mut Cpu) {
    cpu.c = set(cpu.c, 1);
}

fn set_1_d(cpu: &mut Cpu) {
    cpu.d = set(cpu.d, 1);
}

fn set_1_e(cpu: &mut Cpu) {
    cpu.e = set(cpu.e, 1);
}

fn set_1_h(cpu: &mut Cpu) {
    cpu.h = set(cpu.h, 1);
}

fn set_1_l(cpu: &mut Cpu) {
    cpu.l = set(cpu.l, 1);
}

fn set_1_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = set(byte, 1);
    cpu.mmu.write(hl, value);
}

fn set_1_a(cpu: &mut Cpu) {
    cpu.a = set(cpu.a, 1);
}

fn set_2_b(cpu: &mut Cpu) {
    cpu.b = set(cpu.b, 2);
}

fn set_2_c(cpu: &mut Cpu) {
    cpu.c = set(cpu.c, 2);
}

fn set_2_d(cpu: &mut Cpu) {
    cpu.d = set(cpu.d, 2);
}

fn set_2_e(cpu: &mut Cpu) {
    cpu.e = set(cpu.e, 2);
}

fn set_2_h(cpu: &mut Cpu) {
    cpu.h = set(cpu.h, 2);
}

fn set_2_l(cpu: &mut Cpu) {
    cpu.l = set(cpu.l, 2);
}

fn set_2_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = set(byte, 2);
    cpu.mmu.write(hl, value);
}

fn set_2_a(cpu: &mut Cpu) {
    cpu.a = set(cpu.a, 2);
}

fn set_3_b(cpu: &mut Cpu) {
    cpu.b = set(cpu.b, 3);
}

fn set_3_c(cpu: &mut Cpu) {
    cpu.c = set(cpu.c, 3);
}

fn set_3_d(cpu: &mut Cpu) {
    cpu.d = set(cpu.d, 3);
}

fn set_3_e(cpu: &mut Cpu) {
    cpu.e = set(cpu.e, 3);
}

fn set_3_h(cpu: &mut Cpu) {
    cpu.h = set(cpu.h, 3);
}

fn set_3_l(cpu: &mut Cpu) {
    cpu.l = set(cpu.l, 3);
}

fn set_3_mhl(cpu: &mut Cpu) {
    let hl = cpu.hl();
    let byte = cpu.mmu.read(hl);
    let value = set(byte, 3);
    cpu.mmu.write(hl, value);
}

fn set_3_a(cpu: &mut Cpu) {
    cpu.a = set(cpu.a, 3);
}

fn set_4_b(cpu: &mut Cpu) {
    cpu.b = set(cpu.b, 4);
}

fn set_4_c(cpu: &mut Cpu) {
    cpu.c = set(cpu.c, 4);
}

fn set_4_d(cpu: &mut Cpu) {
    cpu.d = set(cpu.d, 4);
}

fn set_4_e(cpu: &mut Cpu) {
    cpu.e = set(cpu.e, 4);
}

fn set_4_h(cpu: &mut Cpu) {
    cpu.h = set(cpu.h, 4);
}