RubyGems - rubyboy - Versions diffs - 0.4.0 → 1.1.0 - Mend

rubyboy 0.4.0 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

checksums.yaml +4 -4
data/.rubocop.yml +3 -0
data/CHANGELOG.md +12 -0
data/README.md +7 -15
data/exe/rubyboy +17 -0
data/lib/bench.rb +26 -0
data/lib/rubyboy/bus.rb +1 -8
data/lib/rubyboy/cartridge/mbc1.rb +1 -1
data/lib/rubyboy/cpu.rb +1016 -1501
data/lib/rubyboy/interrupt.rb +12 -4
data/lib/rubyboy/joypad.rb +4 -4
data/lib/rubyboy/operand/direct16.rb +13 -0
data/lib/rubyboy/operand/direct8.rb +13 -0
data/lib/rubyboy/operand/hl_dec.rb +11 -0
data/lib/rubyboy/operand/hl_inc.rb +11 -0
data/lib/rubyboy/operand/immediate16.rb +13 -0
data/lib/rubyboy/operand/immediate8.rb +13 -0
data/lib/rubyboy/operand/indirect.rb +13 -0
data/lib/rubyboy/operand/register16.rb +13 -0
data/lib/rubyboy/operand/register8.rb +13 -0
data/lib/rubyboy/operand.rb +12 -0
data/lib/rubyboy/ppu.rb +68 -40
data/lib/rubyboy/register.rb +0 -2
data/lib/rubyboy/registers.rb +80 -0
data/lib/rubyboy/rom.rb +1 -30
data/lib/rubyboy/timer.rb +4 -5
data/lib/rubyboy/version.rb +1 -1
data/lib/rubyboy.rb +23 -9
metadata +18 -4

data/lib/rubyboy/cpu.rb CHANGED Viewed

@@ -1,96 +1,47 @@
 # frozen_string_literal: true
-require 'json'
-require_relative 'register'
+require_relative 'registers'
+require_relative 'operand'
 module Rubyboy
   class Cpu
-    def initialize(bus)
-      @a = Register.new(name: 'a', value: 0x01)
-      @b = Register.new(name: 'b', value: 0x00)
-      @c = Register.new(name: 'c', value: 0x13)
-      @d = Register.new(name: 'd', value: 0x00)
-      @e = Register.new(name: 'e', value: 0xd8)
-      @h = Register.new(name: 'h', value: 0x01)
-      @l = Register.new(name: 'l', value: 0x4d)
-      @f = Register.new(name: 'f', value: 0xb0)
+    def initialize(bus, interrupt)
+      @bus = bus
+      @interrupt = interrupt
+      @registers = Registers.new
       @pc = 0x0100
       @sp = 0xfffe
       @ime = false
       @ime_delay = false
-      @bus = bus
-      @opcodes = File.open('lib/opcodes.json', 'r') { |file| JSON.parse(file.read) }
       @halted = false
-      @cnt = 0
-    end
-    def af
-      (@a.value << 8) + @f.value
-    end
-    def af=(value)
-      value &= 0xffff
-      @a.value = value >> 8
-      @f.value = value & 0xf0
-    end
-    def bc
-      (@b.value << 8) + @c.value
-    end
-    def bc=(value)
-      value &= 0xffff
-      @b.value = value >> 8
-      @c.value = value & 0xff
-    end
-    def de
-      (@d.value << 8) + @e.value
-    end
-    def de=(value)
-      value &= 0xffff
-      @d.value = value >> 8
-      @e.value = value & 0xff
-    end
-    def hl
-      (@h.value << 8) + @l.value
-    end
-    def hl=(value)
-      value &= 0xffff
-      @h.value = value >> 8
-      @l.value = value & 0xff
     end
     def exec
       opcode = read_byte(@pc)
       # print_log(opcode)
-      in_interrupt = false
+      @halted &= @interrupt.interrupts == 0
-      if @ime && @bus.interrupt.interrupts.positive?
-        in_interrupt = true
-      else
-        increment_pc
-      end
+      return 16 if @halted
-      if in_interrupt
+      if @ime && @interrupt.interrupts > 0
         pcs = [0x0040, 0x0048, 0x0050, 0x0058, 0x0060]
         5.times do |i|
-          next if @bus.interrupt.interrupts[i].zero?
+          next if @interrupt.interrupts[i] == 0
-          @bus.interrupt.if &= (~(1 << i)) & 0xff
+          @interrupt.reset_flag(i)
           @ime = false
           @sp -= 2
           @bus.write_word(@sp, @pc)
           @pc = pcs[i]
           break
         end
         return 20
+      else
+        increment_pc
       end
       if @ime_delay
@@ -98,1386 +49,517 @@ module Rubyboy
         @ime = true
       end
-      cbprefixed = false
-      branched = false
       case opcode
-      when 0x00 # NOP
-      when 0x01 # LD BC, nn
-        self.bc = read_word_and_advance_pc
-      when 0x02 # LD (BC), A
-        write_byte(bc, @a.value)
-      when 0x03 # INC BC
-        self.bc = bc + 1
-      when 0x04 # INC B
-        @b.increment
-        update_flags(
-          z: @b.value.zero?,
-          n: false,
-          h: (@b.value & 0x0f).zero?
-        )
-      when 0x05 # DEC B
-        @b.decrement
-        update_flags(
-          z: @b.value.zero?,
-          n: true,
-          h: (@b.value & 0x0f) == 0x0f
-        )
-      when 0x06 # LD B, d8
-        @b.value = read_byte_and_advance_pc
-      when 0x07 # RLCA
-        @a.value = (@a.value << 1) | (@a.value >> 7)
-        update_flags(
-          z: false,
-          n: false,
-          h: false,
-          c: @a.value[0] == 1
-        )
-      when 0x08 # LD (nn), SP
-        word = read_word_and_advance_pc
-        write_word(word, @sp)
-      when 0x09 # ADD HL, BC
-        hflag = (hl & 0x0fff) + (bc & 0x0fff) > 0x0fff
-        cflag = hl + bc > 0xffff
-        self.hl = hl + bc
-        update_flags(
-          n: false,
-          h: hflag,
-          c: cflag
-        )
-      when 0x0a # LD A, (BC)
-        @a.value = read_byte(bc)
-      when 0x0b # DEC BC
-        self.bc = bc - 1
-      when 0x0c # INC C
-        @c.increment
-        update_flags(
-          z: @c.value.zero?,
-          n: false,
-          h: (@c.value & 0x0f).zero?
-        )
-      when 0x0d # DEC C
-        @c.decrement
-        update_flags(
-          z: @c.value.zero?,
-          n: true,
-          h: (@c.value & 0x0f) == 0x0f
-        )
-      when 0x0e # LD C, d8
-        @c.value = read_byte_and_advance_pc
-      when 0x0f # RRCA
-        @a.value = (@a.value >> 1) | (@a.value << 7)
-        update_flags(
-          z: false,
-          n: false,
-          h: false,
-          c: @a.value[7] == 1
-        )
-      when 0x10 # STOP
-      when 0x11 # LD DE, nn
-        self.de = read_word_and_advance_pc
-      when 0x12 # LD (DE), A
-        write_byte(de, @a.value)
-      when 0x13 # INC DE
-        self.de = de + 1
-      when 0x14 # INC D
-        @d.increment
-        update_flags(
-          z: @d.value.zero?,
-          n: false,
-          h: (@d.value & 0x0f).zero?
-        )
-      when 0x15 # DEC D
-        @d.decrement
-        update_flags(
-          z: @d.value.zero?,
-          n: true,
-          h: (@d.value & 0x0f) == 0x0f
-        )
-      when 0x16 # LD D, d8
-        @d.value = read_byte_and_advance_pc
-      when 0x17 # RLA
-        cflag = @a.value[7] == 1
-        @a.value = (@a.value << 1) | bool_to_integer(flags[:c])
-        update_flags(
-          z: false,
-          n: false,
-          h: false,
-          c: cflag
-        )
-      when 0x18 # JR r8
-        byte = convert_to_twos_complement(read_byte_and_advance_pc)
-        @pc += byte
-      when 0x19 # ADD HL, DE
-        hflag = (hl & 0x0fff) + (de & 0x0fff) > 0x0fff
-        cflag = hl + de > 0xffff
-        self.hl = hl + de
-        update_flags(
-          n: false,
-          h: hflag,
-          c: cflag
-        )
-      when 0x1a # LD A, (DE)
-        @a.value = read_byte(de)
-      when 0x1b # DEC DE
-        self.de = de - 1
-      when 0x1c # INC E
-        @e.increment
-        update_flags(
-          z: @e.value.zero?,
-          n: false,
-          h: (@e.value & 0x0f).zero?
-        )
-      when 0x1d # DEC E
-        @e.decrement
-        update_flags(
-          z: @e.value.zero?,
-          n: true,
-          h: (@e.value & 0x0f) == 0x0f
-        )
-      when 0x1e # LD E, d8
-        @e.value = read_byte_and_advance_pc
-      when 0x1f # RRA
-        cflag = @a.value[0] == 1
-        @a.value = (@a.value >> 1) | (bool_to_integer(flags[:c]) << 7)
-        update_flags(
-          z: false,
-          n: false,
-          h: false,
-          c: cflag
-        )
-      when 0x20 # JR NZ, r8
-        byte = convert_to_twos_complement(read_byte_and_advance_pc)
-        unless flags[:z]
-          @pc += byte
-          branched = true
-        end
-      when 0x21 # LD HL, nn
-        self.hl = read_word_and_advance_pc
-      when 0x22 # LD (HL+), A
-        write_byte(hl, @a.value)
-        self.hl = hl + 1
-      when 0x23 # INC HL
-        self.hl = hl + 1
-      when 0x24 # INC H
-        @h.increment
-        update_flags(
-          z: @h.value.zero?,
-          n: false,
-          h: (@h.value & 0x0f).zero?
-        )
-      when 0x25 # DEC H
-        @h.decrement
-        update_flags(
-          z: @h.value.zero?,
-          n: true,
-          h: (@h.value & 0x0f) == 0x0f
-        )
-      when 0x26 # LD H, d8
-        @h.value = read_byte_and_advance_pc
-      when 0x27 # DAA
-        if flags[:n]
-          @a.value -= 0x06 if flags[:h]
-          @a.value -= 0x60 if flags[:c]
-        else
-          if flags[:c] || @a.value > 0x99
-            @a.value += 0x60
-            update_flags(c: true)
-          end
-          @a.value += 0x06 if flags[:h] || (@a.value & 0x0f) > 0x09
-        end
-        update_flags(
-          z: @a.value.zero?,
-          h: false
-        )
-      when 0x28 # JR Z, r8
-        byte = convert_to_twos_complement(read_byte_and_advance_pc)
-        if flags[:z]
-          @pc += byte
-          branched = true
-        end
-      when 0x29 # ADD HL, HL
-        hflag = (hl & 0x0fff) + (hl & 0x0fff) > 0x0fff
-        cflag = hl + hl > 0xffff
-        self.hl = hl + hl
-        update_flags(
-          n: false,
-          h: hflag,
-          c: cflag
-        )
-      when 0x2a # LD A, (HL+)
-        @a.value = read_byte(hl)
-        self.hl = hl + 1
-      when 0x2b # DEC HL
-        self.hl = hl - 1
-      when 0x2c # INC L
-        @l.increment
-        update_flags(
-          z: @l.value.zero?,
-          n: false,
-          h: (@l.value & 0x0f).zero?
-        )
-      when 0x2d # DEC L
-        @l.decrement
-        update_flags(
-          z: @l.value.zero?,
-          n: true,
-          h: (@l.value & 0x0f) == 0x0f
-        )
-      when 0x2e # LD L, d8
-        @l.value = read_byte_and_advance_pc
-      when 0x2f # CPL
-        @a.value = ~@a.value
-        update_flags(
-          n: true,
-          h: true
-        )
-      when 0x30 # JR NC, r8
-        byte = convert_to_twos_complement(read_byte_and_advance_pc)
-        unless flags[:c]
-          @pc += byte
-          branched = true
-        end
-      when 0x31 # LD SP, nn
-        @sp = read_word_and_advance_pc
-      when 0x32 # LD (HL-), A
-        write_byte(hl, @a.value)
-        self.hl = hl - 1
-      when 0x33 # INC SP
-        @sp = (@sp + 1) & 0xffff
-      when 0x34 # INC (HL)
-        byte = read_byte(hl)
-        byte = (byte + 1) & 0xff
-        write_byte(hl, byte)
-        update_flags(
-          z: byte.zero?,
-          n: false,
-          h: (byte & 0x0f).zero?
-        )
-      when 0x35 # DEC (HL)
-        byte = read_byte(hl)
-        byte = (byte - 1) & 0xff
-        write_byte(hl, byte)
-        update_flags(
-          z: byte.zero?,
-          n: true,
-          h: (byte & 0x0f) == 0x0f
-        )
-      when 0x36 # LD (HL), d8
-        byte = read_byte_and_advance_pc
-        write_byte(hl, byte)
-      when 0x37 # SCF
-        update_flags(
-          n: false,
-          h: false,
-          c: true
-        )
-      when 0x38 # JR C, r8
-        byte = convert_to_twos_complement(read_byte_and_advance_pc)
-        if flags[:c]
-          @pc += byte
-          branched = true
-        end
-      when 0x39 # ADD HL, SP
-        hflag = (hl & 0x0fff) + (@sp & 0x0fff) > 0x0fff
-        cflag = hl + @sp > 0xffff
-        self.hl = hl + @sp
-        update_flags(
-          n: false,
-          h: hflag,
-          c: cflag
-        )
-      when 0x3a # LD A, (HL-)
-        @a.value = read_byte(hl)
-        self.hl = hl - 1
-      when 0x3b # DEC SP
-        @sp = (@sp - 1) & 0xffff
-      when 0x3c # INC A
-        @a.increment
-        update_flags(
-          z: @a.value.zero?,
-          n: false,
-          h: (@a.value & 0x0f).zero?
-        )
-      when 0x3d # DEC A
-        @a.decrement
-        update_flags(
-          z: @a.value.zero?,
-          n: true,
-          h: (@a.value & 0x0f) == 0x0f
-        )
-      when 0x3e # LD A, d8
-        @a.value = read_byte_and_advance_pc
-      when 0x3f # CCF
-        update_flags(
-          n: false,
-          h: false,
-          c: !flags[:c]
-        )
-      when 0x40 # LD B, B
-        @b.value = @b.value
-      when 0x41 # LD B, C
-        @b.value = @c.value
-      when 0x42 # LD B, D
-        @b.value = @d.value
-      when 0x43 # LD B, E
-        @b.value = @e.value
-      when 0x44 # LD B, H
-        @b.value = @h.value
-      when 0x45 # LD B, L
-        @b.value = @l.value
-      when 0x46 # LD B, (HL)
-        @b.value = read_byte(hl)
-      when 0x47 # LD B, A
-        @b.value = @a.value
-      when 0x48 # LD C, B
-        @c.value = @b.value
-      when 0x49 # LD C, C
-        @c.value = @c.value
-      when 0x4a # LD C, D
-        @c.value = @d.value
-      when 0x4b # LD C, E
-        @c.value = @e.value
-      when 0x4c # LD C, H
-        @c.value = @h.value
-      when 0x4d # LD C, L
-        @c.value = @l.value
-      when 0x4e # LD C, (HL)
-        @c.value = read_byte(hl)
-      when 0x4f # LD C, A
-        @c.value = @a.value
-      when 0x50 # LD D, B
-        @d.value = @b.value
-      when 0x51 # LD D, C
-        @d.value = @c.value
-      when 0x52 # LD D, D
-        @d.value = @d.value
-      when 0x53 # LD D, E
-        @d.value = @e.value
-      when 0x54 # LD D, H
-        @d.value = @h.value
-      when 0x55 # LD D, L
-        @d.value = @l.value
-      when 0x56 # LD D, (HL)
-        @d.value = read_byte(hl)
-      when 0x57 # LD D, A
-        @d.value = @a.value
-      when 0x58 # LD E, B
-        @e.value = @b.value
-      when 0x59 # LD E, C
-        @e.value = @c.value
-      when 0x5a # LD E, D
-        @e.value = @d.value
-      when 0x5b # LD E, E
-        @e.value = @e.value
-      when 0x5c # LD E, H
-        @e.value = @h.value
-      when 0x5d # LD E, L
-        @e.value = @l.value
-      when 0x5e # LD E, (HL)
-        @e.value = read_byte(hl)
-      when 0x5f # LD E, A
-        @e.value = @a.value
-      when 0x60 # LD H, B
-        @h.value = @b.value
-      when 0x61 # LD H, C
-        @h.value = @c.value
-      when 0x62 # LD H, D
-        @h.value = @d.value
-      when 0x63 # LD H, E
-        @h.value = @e.value
-      when 0x64 # LD H, H
-        @h.value = @h.value
-      when 0x65 # LD H, L
-        @h.value = @l.value
-      when 0x66 # LD H, (HL)
-        @h.value = read_byte(hl)
-      when 0x67 # LD H, A
-        @h.value = @a.value
-      when 0x68 # LD L, B
-        @l.value = @b.value
-      when 0x69 # LD L, C
-        @l.value = @c.value
-      when 0x6a # LD L, D
-        @l.value = @d.value
-      when 0x6b # LD L, E
-        @l.value = @e.value
-      when 0x6c # LD L, H
-        @l.value = @h.value
-      when 0x6d # LD L, L
-        @l.value = @l.value
-      when 0x6e # LD L, (HL)
-        @l.value = read_byte(hl)
-      when 0x6f # LD L, A
-        @l.value = @a.value
-      when 0x70 # LD (HL), B
-        write_byte(hl, @b.value)
-      when 0x71 # LD (HL), C
-        write_byte(hl, @c.value)
-      when 0x72 # LD (HL), D
-        write_byte(hl, @d.value)
-      when 0x73 # LD (HL), E
-        write_byte(hl, @e.value)
-      when 0x74 # LD (HL), H
-        write_byte(hl, @h.value)
-      when 0x75 # LD (HL), L
-        write_byte(hl, @l.value)
-      when 0x76 # HALT
-        @pc -= 1 unless @bus.interrupt.interrupts.positive?
-      when 0x77 # LD (HL), A
-        write_byte(hl, @a.value)
-      when 0x78 # LD A, B
-        @a.value = @b.value
-      when 0x79 # LD A, C
-        @a.value = @c.value
-      when 0x7a # LD A, D
-        @a.value = @d.value
-      when 0x7b # LD A, E
-        @a.value = @e.value
-      when 0x7c # LD A, H
-        @a.value = @h.value
-      when 0x7d # LD A, L
-        @a.value = @l.value
-      when 0x7e # LD A, (HL)
-        @a.value = read_byte(hl)
-      when 0x7f # LD A, A
-        @a.value = @a.value
-      when 0x80 # ADD A, B
-        add8(@a, @b)
-      when 0x81 # ADD A, C
-        add8(@a, @c)
-      when 0x82 # ADD A, D
-        add8(@a, @d)
-      when 0x83 # ADD A, E
-        add8(@a, @e)
-      when 0x84 # ADD A, H
-        add8(@a, @h)
-      when 0x85 # ADD A, L
-        add8(@a, @l)
-      when 0x86 # ADD A, (HL)
-        add8(@a, Register.new(name: 'HL', value: read_byte(hl)))
-      when 0x87 # ADD A, A
-        add8(@a, @a)
-      when 0x88 # ADC A, B
-        adc8(@a, @b)
-      when 0x89 # ADC A, C
-        adc8(@a, @c)
-      when 0x8a # ADC A, D
-        adc8(@a, @d)
-      when 0x8b # ADC A, E
-        adc8(@a, @e)
-      when 0x8c # ADC A, H
-        adc8(@a, @h)
-      when 0x8d # ADC A, L
-        adc8(@a, @l)
-      when 0x8e # ADC A, (HL)
-        adc8(@a, Register.new(name: 'HL', value: read_byte(hl)))
-      when 0x8f # ADC A, A
-        adc8(@a, @a)
-      when 0x90 # SUB B
-        sub8(@b)
-      when 0x91 # SUB C
-        sub8(@c)
-      when 0x92 # SUB D
-        sub8(@d)
-      when 0x93 # SUB E
-        sub8(@e)
-      when 0x94 # SUB H
-        sub8(@h)
-      when 0x95 # SUB L
-        sub8(@l)
-      when 0x96 # SUB (HL)
-        sub8(Register.new(name: 'HL', value: read_byte(hl)))
-      when 0x97 # SUB A
-        sub8(@a)
-      when 0x98 # SBC A, B
-        sbc8(@b)
-      when 0x99 # SBC A, C
-        sbc8(@c)
-      when 0x9a # SBC A, D
-        sbc8(@d)
-      when 0x9b # SBC A, E
-        sbc8(@e)
-      when 0x9c # SBC A, H
-        sbc8(@h)
-      when 0x9d # SBC A, L
-        sbc8(@l)
-      when 0x9e # SBC A, (HL)
-        sbc8(Register.new(name: 'HL', value: read_byte(hl)))
-      when 0x9f # SBC A, A
-        sbc8(@a)
-      when 0xa0 # AND B
-        and8(@b)
-      when 0xa1 # AND C
-        and8(@c)
-      when 0xa2 # AND D
-        and8(@d)
-      when 0xa3 # AND E
-        and8(@e)
-      when 0xa4 # AND H
-        and8(@h)
-      when 0xa5 # AND L
-        and8(@l)
-      when 0xa6 # AND (HL)
-        and8(Register.new(name: 'HL', value: read_byte(hl)))
-      when 0xa7 # AND A
-        and8(@a)
-      when 0xa8 # XOR B
-        xor8(@b)
-      when 0xa9 # XOR C
-        xor8(@c)
-      when 0xaa # XOR D
-        xor8(@d)
-      when 0xab # XOR E
-        xor8(@e)
-      when 0xac # XOR H
-        xor8(@h)
-      when 0xad # XOR L
-        xor8(@l)
-      when 0xae # XOR (HL)
-        xor8(Register.new(name: 'HL', value: read_byte(hl)))
-      when 0xaf # XOR A
-        xor8(@a)
-      when 0xb0 # OR B
-        or8(@b)
-      when 0xb1 # OR C
-        or8(@c)
-      when 0xb2 # OR D
-        or8(@d)
-      when 0xb3 # OR E
-        or8(@e)
-      when 0xb4 # OR H
-        or8(@h)
-      when 0xb5 # OR L
-        or8(@l)
-      when 0xb6 # OR (HL)
-        or8(Register.new(name: 'HL', value: read_byte(hl)))
-      when 0xb7 # OR A
-        or8(@a)
-      when 0xb8 # CP B
-        cp8(@b)
-      when 0xb9 # CP C
-        cp8(@c)
-      when 0xba # CP D
-        cp8(@d)
-      when 0xbb # CP E
-        cp8(@e)
-      when 0xbc # CP H
-        cp8(@h)
-      when 0xbd # CP L
-        cp8(@l)
-      when 0xbe # CP (HL)
-        cp8(Register.new(name: 'HL', value: read_byte(hl)))
-      when 0xbf # CP A
-        cp8(@a)
-      when 0xc0 # RET NZ
-        unless flags[:z]
-          @pc = read_word(@sp)
-          @sp += 2
-          branched = true
-        end
-      when 0xc1 # POP BC
-        self.bc = read_word(@sp)
-        @sp += 2
-      when 0xc2 # JP NZ, nn
-        word = read_word_and_advance_pc
-        unless flags[:z]
-          @pc = word
-          branched = true
-        end
-      when 0xc3 # JP nn
-        @pc = read_word_and_advance_pc
-      when 0xc4 # CALL NZ, nn
-        word = read_word_and_advance_pc
-        unless flags[:z]
-          @sp -= 2
-          write_word(@sp, @pc)
-          @pc = word
-          branched = true
-        end
-      when 0xc5 # PUSH BC
-        @sp -= 2
-        write_word(@sp, bc)
-      when 0xc6 # ADD A, d8
-        byte = read_byte_and_advance_pc
-        add8(@a, Register.new(name: 'd8', value: byte))
-      when 0xc7 # RST 00H
-        @sp -= 2
-        write_word(@sp, @pc)
-        @pc = 0x00
-      when 0xc8 # RET Z
-        if flags[:z]
-          @pc = read_word(@sp)
-          @sp += 2
-          branched = true
-        end
-      when 0xc9 # RET
-        @pc = read_word(@sp)
-        @sp += 2
-      when 0xca # JP Z, nn
-        word = read_word_and_advance_pc
-        if flags[:z]
-          @pc = word
-          branched = true
-        end
-      when 0xcc # CALL Z, nn
-        word = read_word_and_advance_pc
-        if flags[:z]
-          @sp -= 2
-          write_word(@sp, @pc)
-          @pc = word
-          branched = true
-        end
-      when 0xcd # CALL nn
-        word = read_word_and_advance_pc
-        @sp -= 2
-        write_word(@sp, @pc)
-        @pc = word
-      when 0xce # ADC A, d8
-        byte = read_byte_and_advance_pc
-        adc8(@a, Register.new(name: 'd8', value: byte))
-      when 0xcf # RST 08H
-        @sp -= 2
-        write_word(@sp, @pc)
-        @pc = 0x08
-      when 0xd0 # RET NC
-        unless flags[:c]
-          @pc = read_word(@sp)
-          @sp += 2
-          branched = true
-        end
-      when 0xd1 # POP DE
-        self.de = read_word(@sp)
-        @sp += 2
-      when 0xd2 # JP NC, nn
-        word = read_word_and_advance_pc
-        unless flags[:c]
-          @pc = word
-          branched = true
-        end
-      when 0xd4 # CALL NC, nn
-        word = read_word_and_advance_pc
-        unless flags[:c]
-          @sp -= 2
-          write_word(@sp, @pc)
-          @pc = word
-          branched = true
-        end
-      when 0xd5 # PUSH DE
-        @sp -= 2
-        write_word(@sp, de)
-      when 0xd6 # SUB d8
-        byte = read_byte_and_advance_pc
-        sub8(Register.new(name: 'd8', value: byte))
-      when 0xd7 # RST 10H
-        @sp -= 2
-        write_word(@sp, @pc)
-        @pc = 0x10
-      when 0xd8 # RET C
-        if flags[:c]
-          @pc = read_word(@sp)
-          @sp += 2
-          branched = true
-        end
-      when 0xd9 # RETI
-        @pc = read_word(@sp)
-        @sp += 2
-        @ime = true
-      when 0xda # JP C, nn
-        word = read_word_and_advance_pc
-        if flags[:c]
-          @pc = word
-          branched = true
-        end
-      when 0xdc # CALL C, nn
-        word = read_word_and_advance_pc
-        if flags[:c]
-          @sp -= 2
-          write_word(@sp, @pc)
-          @pc = word
-          branched = true
-        end
-      when 0xde # SBC A, d8
-        byte = read_byte_and_advance_pc
-        sbc8(Register.new(name: 'd8', value: byte))
-      when 0xdf # RST 18H
-        @sp -= 2
-        write_word(@sp, @pc)
-        @pc = 0x18
-      when 0xe0 # LDH (a8), A
-        byte = read_byte_and_advance_pc
-        write_byte(0xff00 + byte, @a.value)
-      when 0xe1 # POP HL
-        self.hl = read_word(@sp)
-        @sp += 2
-      when 0xe2 # LD (C), A
-        write_byte(0xff00 + @c.value, @a.value)
-      when 0xe5 # PUSH HL
-        @sp -= 2
-        write_word(@sp, hl)
-      when 0xe6 # AND d8
-        byte = read_byte_and_advance_pc
-        and8(Register.new(name: 'd8', value: byte))
-      when 0xe7 # RST 20H
-        @sp -= 2
-        write_word(@sp, @pc)
-        @pc = 0x20
-      when 0xe8 # ADD SP, r8
-        byte = convert_to_twos_complement(read_byte_and_advance_pc)
-        hflag = (@sp & 0x0f) + (byte & 0x0f) > 0x0f
-        cflag = (@sp & 0xff) + (byte & 0xff) > 0xff
-        @sp += byte
-        @sp &= 0xffff
-        update_flags(
-          z: false,
-          n: false,
-          h: hflag,
-          c: cflag
-        )
-      when 0xe9 # JP (HL)
-        @pc = hl
-      when 0xea # LD (nn), A
-        word = read_word_and_advance_pc
-        write_byte(word, @a.value)
-      when 0xee # XOR d8
-        byte = read_byte_and_advance_pc
-        xor8(Register.new(name: 'd8', value: byte))
-      when 0xef # RST 28H
-        @sp -= 2
-        write_word(@sp, @pc)
-        @pc = 0x28
-      when 0xf0 # LDH A, (a8)
-        byte = read_byte_and_advance_pc
-        @a.value = read_byte(0xff00 + byte)
-      when 0xf1 # POP AF
-        self.af = read_word(@sp)
-        @sp += 2
-      when 0xf2 # LD A, (C)
-        @a.value = read_byte(0xff00 + @c.value)
-      when 0xf3 # DI
-        @ime_delay = false
-        @ime = false
-      when 0xf5 # PUSH AF
-        @sp -= 2
-        write_word(@sp, af)
-      when 0xf6 # OR d8
-        byte = read_byte_and_advance_pc
-        or8(Register.new(name: 'd8', value: byte))
-      when 0xf7 # RST 30H
-        @sp -= 2
-        write_word(@sp, @pc)
-        @pc = 0x30
-      when 0xf8 # LD HL, SP+r8
-        byte = convert_to_twos_complement(read_byte_and_advance_pc)
-        hflag = (@sp & 0x0f) + (byte & 0x0f) > 0x0f
-        cflag = (@sp & 0xff) + (byte & 0xff) > 0xff
-        self.hl = @sp + byte
-        update_flags(
-          z: false,
-          n: false,
-          h: hflag,
-          c: cflag
-        )
-      when 0xf9 # LD SP, HL
-        @sp = hl
-      when 0xfa # LD A, (nn)
-        word = read_word_and_advance_pc
-        @a.value = read_byte(word)
-      when 0xfb # EI
-        @ime_delay = true
-      when 0xfe # CP d8
-        byte = read_byte_and_advance_pc
-        update_flags(
-          z: @a.value == byte,
-          n: true,
-          h: (@a.value & 0x0f) < (byte & 0x0f),
-          c: @a.value < byte
-        )
-      when 0xff # RST 38H
-        @sp -= 2
-        write_word(@sp, @pc)
-        @pc = 0x38
+      when 0x00 then 4 # NOP
+      when 0x01 then ld16({ type: :register16, value: :bc }, { type: :immediate16 })
+      when 0x02 then ld8({ type: :indirect, value: :bc }, { type: :register8, value: :a })
+      when 0x03 then inc16({ type: :register16, value: :bc })
+      when 0x04 then inc8({ type: :register8, value: :b })
+      when 0x05 then dec8({ type: :register8, value: :b })
+      when 0x06 then ld8({ type: :register8, value: :b }, { type: :immediate8 })
+      when 0x07 then rlca
+      when 0x08 then ld16({ type: :direct16 }, { type: :sp })
+      when 0x09 then add16({ type: :register16, value: :hl }, { type: :register16, value: :bc })
+      when 0x0a then ld8({ type: :register8, value: :a }, { type: :indirect, value: :bc })
+      when 0x0b then dec16({ type: :register16, value: :bc })
+      when 0x0c then inc8({ type: :register8, value: :c })
+      when 0x0d then dec8({ type: :register8, value: :c })
+      when 0x0e then ld8({ type: :register8, value: :c }, { type: :immediate8 })
+      when 0x0f then rrca
+      when 0x10 then 4 # STOP
+      when 0x11 then ld16({ type: :register16, value: :de }, { type: :immediate16 })
+      when 0x12 then ld8({ type: :indirect, value: :de }, { type: :register8, value: :a })
+      when 0x13 then inc16({ type: :register16, value: :de })
+      when 0x14 then inc8({ type: :register8, value: :d })
+      when 0x15 then dec8({ type: :register8, value: :d })
+      when 0x16 then ld8({ type: :register8, value: :d }, { type: :immediate8 })
+      when 0x17 then rla
+      when 0x18 then jr
+      when 0x19 then add16({ type: :register16, value: :hl }, { type: :register16, value: :de })
+      when 0x1a then ld8({ type: :register8, value: :a }, { type: :indirect, value: :de })
+      when 0x1b then dec16({ type: :register16, value: :de })
+      when 0x1c then inc8({ type: :register8, value: :e })
+      when 0x1d then dec8({ type: :register8, value: :e })
+      when 0x1e then ld8({ type: :register8, value: :e }, { type: :immediate8 })
+      when 0x1f then rra
+      when 0x20 then jr(condition: !flags[:z])
+      when 0x21 then ld16({ type: :register16, value: :hl }, { type: :immediate16 })
+      when 0x22 then ld8({ type: :hl_inc }, { type: :register8, value: :a })
+      when 0x23 then inc16({ type: :register16, value: :hl })
+      when 0x24 then inc8({ type: :register8, value: :h })
+      when 0x25 then dec8({ type: :register8, value: :h })
+      when 0x26 then ld8({ type: :register8, value: :h }, { type: :immediate8 })
+      when 0x27 then daa
+      when 0x28 then jr(condition: flags[:z])
+      when 0x29 then add16({ type: :register16, value: :hl }, { type: :register16, value: :hl })
+      when 0x2a then ld8({ type: :register8, value: :a }, { type: :hl_inc })
+      when 0x2b then dec16({ type: :register16, value: :hl })
+      when 0x2c then inc8({ type: :register8, value: :l })
+      when 0x2d then dec8({ type: :register8, value: :l })
+      when 0x2e then ld8({ type: :register8, value: :l }, { type: :immediate8 })
+      when 0x2f then cpl
+      when 0x30 then jr(condition: !flags[:c])
+      when 0x31 then ld16({ type: :sp }, { type: :immediate16 })
+      when 0x32 then ld8({ type: :hl_dec }, { type: :register8, value: :a })
+      when 0x33 then inc16({ type: :sp })
+      when 0x34 then inc8({ type: :indirect, value: :hl })
+      when 0x35 then dec8({ type: :indirect, value: :hl })
+      when 0x36 then ld8({ type: :indirect, value: :hl }, { type: :immediate8 })
+      when 0x37 then scf
+      when 0x38 then jr(condition: flags[:c])
+      when 0x39 then add16({ type: :register16, value: :hl }, { type: :sp })
+      when 0x3a then ld8({ type: :register8, value: :a }, { type: :hl_dec })
+      when 0x3b then dec16({ type: :sp })
+      when 0x3c then inc8({ type: :register8, value: :a })
+      when 0x3d then dec8({ type: :register8, value: :a })
+      when 0x3e then ld8({ type: :register8, value: :a }, { type: :immediate8 })
+      when 0x3f then ccf
+      when 0x40 then ld8({ type: :register8, value: :b }, { type: :register8, value: :b })
+      when 0x41 then ld8({ type: :register8, value: :b }, { type: :register8, value: :c })
+      when 0x42 then ld8({ type: :register8, value: :b }, { type: :register8, value: :d })
+      when 0x43 then ld8({ type: :register8, value: :b }, { type: :register8, value: :e })
+      when 0x44 then ld8({ type: :register8, value: :b }, { type: :register8, value: :h })
+      when 0x45 then ld8({ type: :register8, value: :b }, { type: :register8, value: :l })
+      when 0x46 then ld8({ type: :register8, value: :b }, { type: :indirect, value: :hl })
+      when 0x47 then ld8({ type: :register8, value: :b }, { type: :register8, value: :a })
+      when 0x48 then ld8({ type: :register8, value: :c }, { type: :register8, value: :b })
+      when 0x49 then ld8({ type: :register8, value: :c }, { type: :register8, value: :c })
+      when 0x4a then ld8({ type: :register8, value: :c }, { type: :register8, value: :d })
+      when 0x4b then ld8({ type: :register8, value: :c }, { type: :register8, value: :e })
+      when 0x4c then ld8({ type: :register8, value: :c }, { type: :register8, value: :h })
+      when 0x4d then ld8({ type: :register8, value: :c }, { type: :register8, value: :l })
+      when 0x4e then ld8({ type: :register8, value: :c }, { type: :indirect, value: :hl })
+      when 0x4f then ld8({ type: :register8, value: :c }, { type: :register8, value: :a })
+      when 0x50 then ld8({ type: :register8, value: :d }, { type: :register8, value: :b })
+      when 0x51 then ld8({ type: :register8, value: :d }, { type: :register8, value: :c })
+      when 0x52 then ld8({ type: :register8, value: :d }, { type: :register8, value: :d })
+      when 0x53 then ld8({ type: :register8, value: :d }, { type: :register8, value: :e })
+      when 0x54 then ld8({ type: :register8, value: :d }, { type: :register8, value: :h })
+      when 0x55 then ld8({ type: :register8, value: :d }, { type: :register8, value: :l })
+      when 0x56 then ld8({ type: :register8, value: :d }, { type: :indirect, value: :hl })
+      when 0x57 then ld8({ type: :register8, value: :d }, { type: :register8, value: :a })
+      when 0x58 then ld8({ type: :register8, value: :e }, { type: :register8, value: :b })
+      when 0x59 then ld8({ type: :register8, value: :e }, { type: :register8, value: :c })
+      when 0x5a then ld8({ type: :register8, value: :e }, { type: :register8, value: :d })
+      when 0x5b then ld8({ type: :register8, value: :e }, { type: :register8, value: :e })
+      when 0x5c then ld8({ type: :register8, value: :e }, { type: :register8, value: :h })
+      when 0x5d then ld8({ type: :register8, value: :e }, { type: :register8, value: :l })
+      when 0x5e then ld8({ type: :register8, value: :e }, { type: :indirect, value: :hl })
+      when 0x5f then ld8({ type: :register8, value: :e }, { type: :register8, value: :a })
+      when 0x60 then ld8({ type: :register8, value: :h }, { type: :register8, value: :b })
+      when 0x61 then ld8({ type: :register8, value: :h }, { type: :register8, value: :c })
+      when 0x62 then ld8({ type: :register8, value: :h }, { type: :register8, value: :d })
+      when 0x63 then ld8({ type: :register8, value: :h }, { type: :register8, value: :e })
+      when 0x64 then ld8({ type: :register8, value: :h }, { type: :register8, value: :h })
+      when 0x65 then ld8({ type: :register8, value: :h }, { type: :register8, value: :l })
+      when 0x66 then ld8({ type: :register8, value: :h }, { type: :indirect, value: :hl })
+      when 0x67 then ld8({ type: :register8, value: :h }, { type: :register8, value: :a })
+      when 0x68 then ld8({ type: :register8, value: :l }, { type: :register8, value: :b })
+      when 0x69 then ld8({ type: :register8, value: :l }, { type: :register8, value: :c })
+      when 0x6a then ld8({ type: :register8, value: :l }, { type: :register8, value: :d })
+      when 0x6b then ld8({ type: :register8, value: :l }, { type: :register8, value: :e })
+      when 0x6c then ld8({ type: :register8, value: :l }, { type: :register8, value: :h })
+      when 0x6d then ld8({ type: :register8, value: :l }, { type: :register8, value: :l })
+      when 0x6e then ld8({ type: :register8, value: :l }, { type: :indirect, value: :hl })
+      when 0x6f then ld8({ type: :register8, value: :l }, { type: :register8, value: :a })
+      when 0x70 then ld8({ type: :indirect, value: :hl }, { type: :register8, value: :b })
+      when 0x71 then ld8({ type: :indirect, value: :hl }, { type: :register8, value: :c })
+      when 0x72 then ld8({ type: :indirect, value: :hl }, { type: :register8, value: :d })
+      when 0x73 then ld8({ type: :indirect, value: :hl }, { type: :register8, value: :e })
+      when 0x74 then ld8({ type: :indirect, value: :hl }, { type: :register8, value: :h })
+      when 0x75 then ld8({ type: :indirect, value: :hl }, { type: :register8, value: :l })
+      when 0x76 then halt
+      when 0x77 then ld8({ type: :indirect, value: :hl }, { type: :register8, value: :a })
+      when 0x78 then ld8({ type: :register8, value: :a }, { type: :register8, value: :b })
+      when 0x79 then ld8({ type: :register8, value: :a }, { type: :register8, value: :c })
+      when 0x7a then ld8({ type: :register8, value: :a }, { type: :register8, value: :d })
+      when 0x7b then ld8({ type: :register8, value: :a }, { type: :register8, value: :e })
+      when 0x7c then ld8({ type: :register8, value: :a }, { type: :register8, value: :h })
+      when 0x7d then ld8({ type: :register8, value: :a }, { type: :register8, value: :l })
+      when 0x7e then ld8({ type: :register8, value: :a }, { type: :indirect, value: :hl })
+      when 0x7f then ld8({ type: :register8, value: :a }, { type: :register8, value: :a })
+      when 0x80 then add8({ type: :register8, value: :b })
+      when 0x81 then add8({ type: :register8, value: :c })
+      when 0x82 then add8({ type: :register8, value: :d })
+      when 0x83 then add8({ type: :register8, value: :e })
+      when 0x84 then add8({ type: :register8, value: :h })
+      when 0x85 then add8({ type: :register8, value: :l })
+      when 0x86 then add8({ type: :indirect, value: :hl })
+      when 0x87 then add8({ type: :register8, value: :a })
+      when 0x88 then adc8({ type: :register8, value: :b })
+      when 0x89 then adc8({ type: :register8, value: :c })
+      when 0x8a then adc8({ type: :register8, value: :d })
+      when 0x8b then adc8({ type: :register8, value: :e })
+      when 0x8c then adc8({ type: :register8, value: :h })
+      when 0x8d then adc8({ type: :register8, value: :l })
+      when 0x8e then adc8({ type: :indirect, value: :hl })
+      when 0x8f then adc8({ type: :register8, value: :a })
+      when 0x90 then sub8({ type: :register8, value: :b })
+      when 0x91 then sub8({ type: :register8, value: :c })
+      when 0x92 then sub8({ type: :register8, value: :d })
+      when 0x93 then sub8({ type: :register8, value: :e })
+      when 0x94 then sub8({ type: :register8, value: :h })
+      when 0x95 then sub8({ type: :register8, value: :l })
+      when 0x96 then sub8({ type: :indirect, value: :hl })
+      when 0x97 then sub8({ type: :register8, value: :a })
+      when 0x98 then sbc8({ type: :register8, value: :b })
+      when 0x99 then sbc8({ type: :register8, value: :c })
+      when 0x9a then sbc8({ type: :register8, value: :d })
+      when 0x9b then sbc8({ type: :register8, value: :e })
+      when 0x9c then sbc8({ type: :register8, value: :h })
+      when 0x9d then sbc8({ type: :register8, value: :l })
+      when 0x9e then sbc8({ type: :indirect, value: :hl })
+      when 0x9f then sbc8({ type: :register8, value: :a })
+      when 0xa0 then and8({ type: :register8, value: :b })
+      when 0xa1 then and8({ type: :register8, value: :c })
+      when 0xa2 then and8({ type: :register8, value: :d })
+      when 0xa3 then and8({ type: :register8, value: :e })
+      when 0xa4 then and8({ type: :register8, value: :h })
+      when 0xa5 then and8({ type: :register8, value: :l })
+      when 0xa6 then and8({ type: :indirect, value: :hl })
+      when 0xa7 then and8({ type: :register8, value: :a })
+      when 0xa8 then xor8({ type: :register8, value: :b })
+      when 0xa9 then xor8({ type: :register8, value: :c })
+      when 0xaa then xor8({ type: :register8, value: :d })
+      when 0xab then xor8({ type: :register8, value: :e })
+      when 0xac then xor8({ type: :register8, value: :h })
+      when 0xad then xor8({ type: :register8, value: :l })
+      when 0xae then xor8({ type: :indirect, value: :hl })
+      when 0xaf then xor8({ type: :register8, value: :a })
+      when 0xb0 then or8({ type: :register8, value: :b })
+      when 0xb1 then or8({ type: :register8, value: :c })
+      when 0xb2 then or8({ type: :register8, value: :d })
+      when 0xb3 then or8({ type: :register8, value: :e })
+      when 0xb4 then or8({ type: :register8, value: :h })
+      when 0xb5 then or8({ type: :register8, value: :l })
+      when 0xb6 then or8({ type: :indirect, value: :hl })
+      when 0xb7 then or8({ type: :register8, value: :a })
+      when 0xb8 then cp8({ type: :register8, value: :b })
+      when 0xb9 then cp8({ type: :register8, value: :c })
+      when 0xba then cp8({ type: :register8, value: :d })
+      when 0xbb then cp8({ type: :register8, value: :e })
+      when 0xbc then cp8({ type: :register8, value: :h })
+      when 0xbd then cp8({ type: :register8, value: :l })
+      when 0xbe then cp8({ type: :indirect, value: :hl })
+      when 0xbf then cp8({ type: :register8, value: :a })
+      when 0xc0 then ret_if(!flags[:z])
+      when 0xc1 then pop16(:bc)
+      when 0xc2 then jp({ type: :immediate16 }, condition: !flags[:z])
+      when 0xc3 then jp({ type: :immediate16 })
+      when 0xc4 then call16({ type: :immediate16 }, condition: !flags[:z])
+      when 0xc5 then push16(:bc)
+      when 0xc6 then add8({ type: :immediate8 })
+      when 0xc7 then rst(0x00)
+      when 0xc8 then ret_if(flags[:z])
+      when 0xc9 then ret
+      when 0xca then jp({ type: :immediate16 }, condition: flags[:z])
+      when 0xcc then call16({ type: :immediate16 }, condition: flags[:z])
+      when 0xcd then call16({ type: :immediate16 })
+      when 0xce then adc8({ type: :immediate8 })
+      when 0xcf then rst(0x08)
+      when 0xd0 then ret_if(!flags[:c])
+      when 0xd1 then pop16(:de)
+      when 0xd2 then jp({ type: :immediate16 }, condition: !flags[:c])
+      when 0xd4 then call16({ type: :immediate16 }, condition: !flags[:c])
+      when 0xd5 then push16(:de)
+      when 0xd6 then sub8({ type: :immediate8 })
+      when 0xd7 then rst(0x10)
+      when 0xd8 then ret_if(flags[:c])
+      when 0xd9 then reti
+      when 0xda then jp({ type: :immediate16 }, condition: flags[:c])
+      when 0xdc then call16({ type: :immediate16 }, condition: flags[:c])
+      when 0xde then sbc8({ type: :immediate8 })
+      when 0xdf then rst(0x18)
+      when 0xe0 then ld8({ type: :ff00 }, { type: :register8, value: :a })
+      when 0xe1 then pop16(:hl)
+      when 0xe2 then ld8({ type: :ff00_c }, { type: :register8, value: :a })
+      when 0xe5 then push16(:hl)
+      when 0xe6 then and8({ type: :immediate8 })
+      when 0xe7 then rst(0x20)
+      when 0xe8 then add_sp_r8
+      when 0xe9 then jp({ type: :register16, value: :hl })
+      when 0xea then ld8({ type: :direct8 }, { type: :register8, value: :a })
+      when 0xee then xor8({ type: :immediate8 })
+      when 0xef then rst(0x28)
+      when 0xf0 then ld8({ type: :register8, value: :a }, { type: :ff00 })
+      when 0xf1 then pop16(:af)
+      when 0xf2 then ld8({ type: :register8, value: :a }, { type: :ff00_c })
+      when 0xf3 then di
+      when 0xf5 then push16(:af)
+      when 0xf6 then or8({ type: :immediate8 })
+      when 0xf7 then rst(0x30)
+      when 0xf8 then ld_hl_sp_r8
+      when 0xf9 then ld16({ type: :sp }, { type: :register16, value: :hl })
+      when 0xfa then ld8({ type: :register8, value: :a }, { type: :direct8 })
+      when 0xfb then ei
+      when 0xfe then cp8({ type: :immediate8 })
+      when 0xff then rst(0x38)
       when 0xcb # CB prefix
         opcode = read_byte_and_advance_pc
-        cbprefixed = true
-        # p "CB #{opcode.to_s(16)}"
         case opcode
-        when 0x00 # RLC B
-          rlc8(@b)
-        when 0x01 # RLC C
-          rlc8(@c)
-        when 0x02 # RLC D
-          rlc8(@d)
-        when 0x03 # RLC E
-          rlc8(@e)
-        when 0x04 # RLC H
-          rlc8(@h)
-        when 0x05 # RLC L
-          rlc8(@l)
-        when 0x06 # RLC (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          rlc8(reg)
-          write_byte(hl, reg.value)
-        when 0x07 # RLC A
-          rlc8(@a)
-        when 0x08 # RRC B
-          rrc8(@b)
-        when 0x09 # RRC C
-          rrc8(@c)
-        when 0x0a # RRC D
-          rrc8(@d)
-        when 0x0b # RRC E
-          rrc8(@e)
-        when 0x0c # RRC H
-          rrc8(@h)
-        when 0x0d # RRC L
-          rrc8(@l)
-        when 0x0e # RRC (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          rrc8(reg)
-          write_byte(hl, reg.value)
-        when 0x0f # RRC A
-          rrc8(@a)
-        when 0x10 # RL B
-          rl8(@b)
-        when 0x11 # RL C
-          rl8(@c)
-        when 0x12 # RL D
-          rl8(@d)
-        when 0x13 # RL E
-          rl8(@e)
-        when 0x14 # RL H
-          rl8(@h)
-        when 0x15 # RL L
-          rl8(@l)
-        when 0x16 # RL (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          rl8(reg)
-          write_byte(hl, reg.value)
-        when 0x17 # RL A
-          rl8(@a)
-        when 0x18 # RR B
-          rr8(@b)
-        when 0x19 # RR C
-          rr8(@c)
-        when 0x1a # RR D
-          rr8(@d)
-        when 0x1b # RR E
-          rr8(@e)
-        when 0x1c # RR H
-          rr8(@h)
-        when 0x1d # RR L
-          rr8(@l)
-        when 0x1e # RR (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          rr8(reg)
-          write_byte(hl, reg.value)
-        when 0x1f # RR A
-          rr8(@a)
-        when 0x20 # SLA B
-          sla8(@b)
-        when 0x21 # SLA C
-          sla8(@c)
-        when 0x22 # SLA D
-          sla8(@d)
-        when 0x23 # SLA E
-          sla8(@e)
-        when 0x24 # SLA H
-          sla8(@h)
-        when 0x25 # SLA L
-          sla8(@l)
-        when 0x26 # SLA (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          sla8(reg)
-          write_byte(hl, reg.value)
-        when 0x27 # SLA A
-          sla8(@a)
-        when 0x28 # SRA B
-          sra8(@b)
-        when 0x29 # SRA C
-          sra8(@c)
-        when 0x2a # SRA D
-          sra8(@d)
-        when 0x2b # SRA E
-          sra8(@e)
-        when 0x2c # SRA H
-          sra8(@h)
-        when 0x2d # SRA L
-          sra8(@l)
-        when 0x2e # SRA (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          sra8(reg)
-          write_byte(hl, reg.value)
-        when 0x2f # SRA A
-          sra8(@a)
-        when 0x30 # SWAP B
-          swap8(@b)
-        when 0x31 # SWAP C
-          swap8(@c)
-        when 0x32 # SWAP D
-          swap8(@d)
-        when 0x33 # SWAP E
-          swap8(@e)
-        when 0x34 # SWAP H
-          swap8(@h)
-        when 0x35 # SWAP L
-          swap8(@l)
-        when 0x36 # SWAP (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          swap8(reg)
-          write_byte(hl, reg.value)
-        when 0x37 # SWAP A
-          swap8(@a)
-        when 0x38 # SRL B
-          srl8(@b)
-        when 0x39 # SRL C
-          srl8(@c)
-        when 0x3a # SRL D
-          srl8(@d)
-        when 0x3b # SRL E
-          srl8(@e)
-        when 0x3c # SRL H
-          srl8(@h)
-        when 0x3d # SRL L
-          srl8(@l)
-        when 0x3e # SRL (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          srl8(reg)
-          write_byte(hl, reg.value)
-        when 0x3f # SRL A
-          srl8(@a)
-        when 0x40 # BIT 0, B
-          bit8(0, @b)
-        when 0x41 # BIT 0, C
-          bit8(0, @c)
-        when 0x42 # BIT 0, D
-          bit8(0, @d)
-        when 0x43 # BIT 0, E
-          bit8(0, @e)
-        when 0x44 # BIT 0, H
-          bit8(0, @h)
-        when 0x45 # BIT 0, L
-          bit8(0, @l)
-        when 0x46 # BIT 0, (HL)
-          bit8(0, Register.new(name: 'HL', value: read_byte(hl)))
-        when 0x47 # BIT 0, A
-          bit8(0, @a)
-        when 0x48 # BIT 1, B
-          bit8(1, @b)
-        when 0x49 # BIT 1, C
-          bit8(1, @c)
-        when 0x4a # BIT 1, D
-          bit8(1, @d)
-        when 0x4b # BIT 1, E
-          bit8(1, @e)
-        when 0x4c # BIT 1, H
-          bit8(1, @h)
-        when 0x4d # BIT 1, L
-          bit8(1, @l)
-        when 0x4e # BIT 1, (HL)
-          bit8(1, Register.new(name: 'HL', value: read_byte(hl)))
-        when 0x4f # BIT 1, A
-          bit8(1, @a)
-        when 0x50 # BIT 2, B
-          bit8(2, @b)
-        when 0x51 # BIT 2, C
-          bit8(2, @c)
-        when 0x52 # BIT 2, D
-          bit8(2, @d)
-        when 0x53 # BIT 2, E
-          bit8(2, @e)
-        when 0x54 # BIT 2, H
-          bit8(2, @h)
-        when 0x55 # BIT 2, L
-          bit8(2, @l)
-        when 0x56 # BIT 2, (HL)
-          bit8(2, Register.new(name: 'HL', value: read_byte(hl)))
-        when 0x57 # BIT 2, A
-          bit8(2, @a)
-        when 0x58 # BIT 3, B
-          bit8(3, @b)
-        when 0x59 # BIT 3, C
-          bit8(3, @c)
-        when 0x5a # BIT 3, D
-          bit8(3, @d)
-        when 0x5b # BIT 3, E
-          bit8(3, @e)
-        when 0x5c # BIT 3, H
-          bit8(3, @h)
-        when 0x5d # BIT 3, L
-          bit8(3, @l)
-        when 0x5e # BIT 3, (HL)
-          bit8(3, Register.new(name: 'HL', value: read_byte(hl)))
-        when 0x5f # BIT 3, A
-          bit8(3, @a)
-        when 0x60 # BIT 4, B
-          bit8(4, @b)
-        when 0x61 # BIT 4, C
-          bit8(4, @c)
-        when 0x62 # BIT 4, D
-          bit8(4, @d)
-        when 0x63 # BIT 4, E
-          bit8(4, @e)
-        when 0x64 # BIT 4, H
-          bit8(4, @h)
-        when 0x65 # BIT 4, L
-          bit8(4, @l)
-        when 0x66 # BIT 4, (HL)
-          bit8(4, Register.new(name: 'HL', value: read_byte(hl)))
-        when 0x67 # BIT 4, A
-          bit8(4, @a)
-        when 0x68 # BIT 5, B
-          bit8(5, @b)
-        when 0x69 # BIT 5, C
-          bit8(5, @c)
-        when 0x6a # BIT 5, D
-          bit8(5, @d)
-        when 0x6b # BIT 5, E
-          bit8(5, @e)
-        when 0x6c # BIT 5, H
-          bit8(5, @h)
-        when 0x6d # BIT 5, L
-          bit8(5, @l)
-        when 0x6e # BIT 5, (HL)
-          bit8(5, Register.new(name: 'HL', value: read_byte(hl)))
-        when 0x6f # BIT 5, A
-          bit8(5, @a)
-        when 0x70 # BIT 6, B
-          bit8(6, @b)
-        when 0x71 # BIT 6, C
-          bit8(6, @c)
-        when 0x72 # BIT 6, D
-          bit8(6, @d)
-        when 0x73 # BIT 6, E
-          bit8(6, @e)
-        when 0x74 # BIT 6, H
-          bit8(6, @h)
-        when 0x75 # BIT 6, L
-          bit8(6, @l)
-        when 0x76 # BIT 6, (HL)
-          bit8(6, Register.new(name: 'HL', value: read_byte(hl)))
-        when 0x77 # BIT 6, A
-          bit8(6, @a)
-        when 0x78 # BIT 7, B
-          bit8(7, @b)
-        when 0x79 # BIT 7, C
-          bit8(7, @c)
-        when 0x7a # BIT 7, D
-          bit8(7, @d)
-        when 0x7b # BIT 7, E
-          bit8(7, @e)
-        when 0x7c # BIT 7, H
-          bit8(7, @h)
-        when 0x7d # BIT 7, L
-          bit8(7, @l)
-        when 0x7e # BIT 7, (HL)
-          bit8(7, Register.new(name: 'HL', value: read_byte(hl)))
-        when 0x7f # BIT 7, A
-          bit8(7, @a)
-        when 0x80 # RES 0, B
-          res8(0, @b)
-        when 0x81 # RES 0, C
-          res8(0, @c)
-        when 0x82 # RES 0, D
-          res8(0, @d)
-        when 0x83 # RES 0, E
-          res8(0, @e)
-        when 0x84 # RES 0, H
-          res8(0, @h)
-        when 0x85 # RES 0, L
-          res8(0, @l)
-        when 0x86 # RES 0, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          res8(0, reg)
-          write_byte(hl, reg.value)
-        when 0x87 # RES 0, A
-          res8(0, @a)
-        when 0x88 # RES 1, B
-          res8(1, @b)
-        when 0x89 # RES 1, C
-          res8(1, @c)
-        when 0x8a # RES 1, D
-          res8(1, @d)
-        when 0x8b # RES 1, E
-          res8(1, @e)
-        when 0x8c # RES 1, H
-          res8(1, @h)
-        when 0x8d # RES 1, L
-          res8(1, @l)
-        when 0x8e # RES 1, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          res8(1, reg)
-          write_byte(hl, reg.value)
-        when 0x8f # RES 1, A
-          res8(1, @a)
-        when 0x90 # RES 2, B
-          res8(2, @b)
-        when 0x91 # RES 2, C
-          res8(2, @c)
-        when 0x92 # RES 2, D
-          res8(2, @d)
-        when 0x93 # RES 2, E
-          res8(2, @e)
-        when 0x94 # RES 2, H
-          res8(2, @h)
-        when 0x95 # RES 2, L
-          res8(2, @l)
-        when 0x96 # RES 2, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          res8(2, reg)
-          write_byte(hl, reg.value)
-        when 0x97 # RES 2, A
-          res8(2, @a)
-        when 0x98 # RES 3, B
-          res8(3, @b)
-        when 0x99 # RES 3, C
-          res8(3, @c)
-        when 0x9a # RES 3, D
-          res8(3, @d)
-        when 0x9b # RES 3, E
-          res8(3, @e)
-        when 0x9c # RES 3, H
-          res8(3, @h)
-        when 0x9d # RES 3, L
-          res8(3, @l)
-        when 0x9e # RES 3, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          res8(3, reg)
-          write_byte(hl, reg.value)
-        when 0x9f # RES 3, A
-          res8(3, @a)
-        when 0xa0 # RES 4, B
-          res8(4, @b)
-        when 0xa1 # RES 4, C
-          res8(4, @c)
-        when 0xa2 # RES 4, D
-          res8(4, @d)
-        when 0xa3 # RES 4, E
-          res8(4, @e)
-        when 0xa4 # RES 4, H
-          res8(4, @h)
-        when 0xa5 # RES 4, L
-          res8(4, @l)
-        when 0xa6 # RES 4, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          res8(4, reg)
-          write_byte(hl, reg.value)
-        when 0xa7 # RES 4, A
-          res8(4, @a)
-        when 0xa8 # RES 5, B
-          res8(5, @b)
-        when 0xa9 # RES 5, C
-          res8(5, @c)
-        when 0xaa # RES 5, D
-          res8(5, @d)
-        when 0xab # RES 5, E
-          res8(5, @e)
-        when 0xac # RES 5, H
-          res8(5, @h)
-        when 0xad # RES 5, L
-          res8(5, @l)
-        when 0xae # RES 5, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          res8(5, reg)
-          write_byte(hl, reg.value)
-        when 0xaf # RES 5, A
-          res8(5, @a)
-        when 0xb0 # RES 6, B
-          res8(6, @b)
-        when 0xb1 # RES 6, C
-          res8(6, @c)
-        when 0xb2 # RES 6, D
-          res8(6, @d)
-        when 0xb3 # RES 6, E
-          res8(6, @e)
-        when 0xb4 # RES 6, H
-          res8(6, @h)
-        when 0xb5 # RES 6, L
-          res8(6, @l)
-        when 0xb6 # RES 6, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          res8(6, reg)
-          write_byte(hl, reg.value)
-        when 0xb7 # RES 6, A
-          res8(6, @a)
-        when 0xb8 # RES 7, B
-          res8(7, @b)
-        when 0xb9 # RES 7, C
-          res8(7, @c)
-        when 0xba # RES 7, D
-          res8(7, @d)
-        when 0xbb # RES 7, E
-          res8(7, @e)
-        when 0xbc # RES 7, H
-          res8(7, @h)
-        when 0xbd # RES 7, L
-          res8(7, @l)
-        when 0xbe # RES 7, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          res8(7, reg)
-          write_byte(hl, reg.value)
-        when 0xbf # RES 7, A
-          res8(7, @a)
-        when 0xc0 # SET 0, B
-          set8(0, @b)
-        when 0xc1 # SET 0, C
-          set8(0, @c)
-        when 0xc2 # SET 0, D
-          set8(0, @d)
-        when 0xc3 # SET 0, E
-          set8(0, @e)
-        when 0xc4 # SET 0, H
-          set8(0, @h)
-        when 0xc5 # SET 0, L
-          set8(0, @l)
-        when 0xc6 # SET 0, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          set8(0, reg)
-          write_byte(hl, reg.value)
-        when 0xc7 # SET 0, A
-          set8(0, @a)
-        when 0xc8 # SET 1, B
-          set8(1, @b)
-        when 0xc9 # SET 1, C
-          set8(1, @c)
-        when 0xca # SET 1, D
-          set8(1, @d)
-        when 0xcb # SET 1, E
-          set8(1, @e)
-        when 0xcc # SET 1, H
-          set8(1, @h)
-        when 0xcd # SET 1, L
-          set8(1, @l)
-        when 0xce # SET 1, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          set8(1, reg)
-          write_byte(hl, reg.value)
-        when 0xcf # SET 1, A
-          set8(1, @a)
-        when 0xd0 # SET 2, B
-          set8(2, @b)
-        when 0xd1 # SET 2, C
-          set8(2, @c)
-        when 0xd2 # SET 2, D
-          set8(2, @d)
-        when 0xd3 # SET 2, E
-          set8(2, @e)
-        when 0xd4 # SET 2, H
-          set8(2, @h)
-        when 0xd5 # SET 2, L
-          set8(2, @l)
-        when 0xd6 # SET 2, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          set8(2, reg)
-          write_byte(hl, reg.value)
-        when 0xd7 # SET 2, A
-          set8(2, @a)
-        when 0xd8 # SET 3, B
-          set8(3, @b)
-        when 0xd9 # SET 3, C
-          set8(3, @c)
-        when 0xda # SET 3, D
-          set8(3, @d)
-        when 0xdb # SET 3, E
-          set8(3, @e)
-        when 0xdc # SET 3, H
-          set8(3, @h)
-        when 0xdd # SET 3, L
-          set8(3, @l)
-        when 0xde # SET 3, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          set8(3, reg)
-          write_byte(hl, reg.value)
-        when 0xdf # SET 3, A
-          set8(3, @a)
-        when 0xe0 # SET 4, B
-          set8(4, @b)
-        when 0xe1 # SET 4, C
-          set8(4, @c)
-        when 0xe2 # SET 4, D
-          set8(4, @d)
-        when 0xe3 # SET 4, E
-          set8(4, @e)
-        when 0xe4 # SET 4, H
-          set8(4, @h)
-        when 0xe5 # SET 4, L
-          set8(4, @l)
-        when 0xe6 # SET 4, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          set8(4, reg)
-          write_byte(hl, reg.value)
-        when 0xe7 # SET 4, A
-          set8(4, @a)
-        when 0xe8 # SET 5, B
-          set8(5, @b)
-        when 0xe9 # SET 5, C
-          set8(5, @c)
-        when 0xea # SET 5, D
-          set8(5, @d)
-        when 0xeb # SET 5, E
-          set8(5, @e)
-        when 0xec # SET 5, H
-          set8(5, @h)
-        when 0xed # SET 5, L
-          set8(5, @l)
-        when 0xee # SET 5, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          set8(5, reg)
-          write_byte(hl, reg.value)
-        when 0xef # SET 5, A
-          set8(5, @a)
-        when 0xf0 # SET 6, B
-          set8(6, @b)
-        when 0xf1 # SET 6, C
-          set8(6, @c)
-        when 0xf2 # SET 6, D
-          set8(6, @d)
-        when 0xf3 # SET 6, E
-          set8(6, @e)
-        when 0xf4 # SET 6, H
-          set8(6, @h)
-        when 0xf5 # SET 6, L
-          set8(6, @l)
-        when 0xf6 # SET 6, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          set8(6, reg)
-          write_byte(hl, reg.value)
-        when 0xf7 # SET 6, A
-          set8(6, @a)
-        when 0xf8 # SET 7, B
-          set8(7, @b)
-        when 0xf9 # SET 7, C
-          set8(7, @c)
-        when 0xfa # SET 7, D
-          set8(7, @d)
-        when 0xfb # SET 7, E
-          set8(7, @e)
-        when 0xfc then set8(7, @h)
-        when 0xfd then set8(7, @l)
-        when 0xfe # SET 7, (HL)
-          reg = Register.new(name: 'HL', value: read_byte(hl))
-          set8(7, reg)
-          write_byte(hl, reg.value)
-        when 0xff then set8(7, @a) # SET 7, A
+        when 0x00 then rlc8({ type: :register8, value: :b })
+        when 0x01 then rlc8({ type: :register8, value: :c })
+        when 0x02 then rlc8({ type: :register8, value: :d })
+        when 0x03 then rlc8({ type: :register8, value: :e })
+        when 0x04 then rlc8({ type: :register8, value: :h })
+        when 0x05 then rlc8({ type: :register8, value: :l })
+        when 0x06 then rlc8({ type: :indirect, value: :hl })
+        when 0x07 then rlc8({ type: :register8, value: :a })
+        when 0x08 then rrc8({ type: :register8, value: :b })
+        when 0x09 then rrc8({ type: :register8, value: :c })
+        when 0x0a then rrc8({ type: :register8, value: :d })
+        when 0x0b then rrc8({ type: :register8, value: :e })
+        when 0x0c then rrc8({ type: :register8, value: :h })
+        when 0x0d then rrc8({ type: :register8, value: :l })
+        when 0x0e then rrc8({ type: :indirect, value: :hl })
+        when 0x0f then rrc8({ type: :register8, value: :a })
+        when 0x10 then rl8({ type: :register8, value: :b })
+        when 0x11 then rl8({ type: :register8, value: :c })
+        when 0x12 then rl8({ type: :register8, value: :d })
+        when 0x13 then rl8({ type: :register8, value: :e })
+        when 0x14 then rl8({ type: :register8, value: :h })
+        when 0x15 then rl8({ type: :register8, value: :l })
+        when 0x16 then rl8({ type: :indirect, value: :hl })
+        when 0x17 then rl8({ type: :register8, value: :a })
+        when 0x18 then rr8({ type: :register8, value: :b })
+        when 0x19 then rr8({ type: :register8, value: :c })
+        when 0x1a then rr8({ type: :register8, value: :d })
+        when 0x1b then rr8({ type: :register8, value: :e })
+        when 0x1c then rr8({ type: :register8, value: :h })
+        when 0x1d then rr8({ type: :register8, value: :l })
+        when 0x1e then rr8({ type: :indirect, value: :hl })
+        when 0x1f then rr8({ type: :register8, value: :a })
+        when 0x20 then sla8({ type: :register8, value: :b })
+        when 0x21 then sla8({ type: :register8, value: :c })
+        when 0x22 then sla8({ type: :register8, value: :d })
+        when 0x23 then sla8({ type: :register8, value: :e })
+        when 0x24 then sla8({ type: :register8, value: :h })
+        when 0x25 then sla8({ type: :register8, value: :l })
+        when 0x26 then sla8({ type: :indirect, value: :hl })
+        when 0x27 then sla8({ type: :register8, value: :a })
+        when 0x28 then sra8({ type: :register8, value: :b })
+        when 0x29 then sra8({ type: :register8, value: :c })
+        when 0x2a then sra8({ type: :register8, value: :d })
+        when 0x2b then sra8({ type: :register8, value: :e })
+        when 0x2c then sra8({ type: :register8, value: :h })
+        when 0x2d then sra8({ type: :register8, value: :l })
+        when 0x2e then sra8({ type: :indirect, value: :hl })
+        when 0x2f then sra8({ type: :register8, value: :a })
+        when 0x30 then swap8({ type: :register8, value: :b })
+        when 0x31 then swap8({ type: :register8, value: :c })
+        when 0x32 then swap8({ type: :register8, value: :d })
+        when 0x33 then swap8({ type: :register8, value: :e })
+        when 0x34 then swap8({ type: :register8, value: :h })
+        when 0x35 then swap8({ type: :register8, value: :l })
+        when 0x36 then swap8({ type: :indirect, value: :hl })
+        when 0x37 then swap8({ type: :register8, value: :a })
+        when 0x38 then srl8({ type: :register8, value: :b })
+        when 0x39 then srl8({ type: :register8, value: :c })
+        when 0x3a then srl8({ type: :register8, value: :d })
+        when 0x3b then srl8({ type: :register8, value: :e })
+        when 0x3c then srl8({ type: :register8, value: :h })
+        when 0x3d then srl8({ type: :register8, value: :l })
+        when 0x3e then srl8({ type: :indirect, value: :hl })
+        when 0x3f then srl8({ type: :register8, value: :a })
+        when 0x40 then bit8(0, { type: :register8, value: :b })
+        when 0x41 then bit8(0, { type: :register8, value: :c })
+        when 0x42 then bit8(0, { type: :register8, value: :d })
+        when 0x43 then bit8(0, { type: :register8, value: :e })
+        when 0x44 then bit8(0, { type: :register8, value: :h })
+        when 0x45 then bit8(0, { type: :register8, value: :l })
+        when 0x46 then bit8(0, { type: :indirect, value: :hl })
+        when 0x47 then bit8(0, { type: :register8, value: :a })
+        when 0x48 then bit8(1, { type: :register8, value: :b })
+        when 0x49 then bit8(1, { type: :register8, value: :c })
+        when 0x4a then bit8(1, { type: :register8, value: :d })
+        when 0x4b then bit8(1, { type: :register8, value: :e })
+        when 0x4c then bit8(1, { type: :register8, value: :h })
+        when 0x4d then bit8(1, { type: :register8, value: :l })
+        when 0x4e then bit8(1, { type: :indirect, value: :hl })
+        when 0x4f then bit8(1, { type: :register8, value: :a })
+        when 0x50 then bit8(2, { type: :register8, value: :b })
+        when 0x51 then bit8(2, { type: :register8, value: :c })
+        when 0x52 then bit8(2, { type: :register8, value: :d })
+        when 0x53 then bit8(2, { type: :register8, value: :e })
+        when 0x54 then bit8(2, { type: :register8, value: :h })
+        when 0x55 then bit8(2, { type: :register8, value: :l })
+        when 0x56 then bit8(2, { type: :indirect, value: :hl })
+        when 0x57 then bit8(2, { type: :register8, value: :a })
+        when 0x58 then bit8(3, { type: :register8, value: :b })
+        when 0x59 then bit8(3, { type: :register8, value: :c })
+        when 0x5a then bit8(3, { type: :register8, value: :d })
+        when 0x5b then bit8(3, { type: :register8, value: :e })
+        when 0x5c then bit8(3, { type: :register8, value: :h })
+        when 0x5d then bit8(3, { type: :register8, value: :l })
+        when 0x5e then bit8(3, { type: :indirect, value: :hl })
+        when 0x5f then bit8(3, { type: :register8, value: :a })
+        when 0x60 then bit8(4, { type: :register8, value: :b })
+        when 0x61 then bit8(4, { type: :register8, value: :c })
+        when 0x62 then bit8(4, { type: :register8, value: :d })
+        when 0x63 then bit8(4, { type: :register8, value: :e })
+        when 0x64 then bit8(4, { type: :register8, value: :h })
+        when 0x65 then bit8(4, { type: :register8, value: :l })
+        when 0x66 then bit8(4, { type: :indirect, value: :hl })
+        when 0x67 then bit8(4, { type: :register8, value: :a })
+        when 0x68 then bit8(5, { type: :register8, value: :b })
+        when 0x69 then bit8(5, { type: :register8, value: :c })
+        when 0x6a then bit8(5, { type: :register8, value: :d })
+        when 0x6b then bit8(5, { type: :register8, value: :e })
+        when 0x6c then bit8(5, { type: :register8, value: :h })
+        when 0x6d then bit8(5, { type: :register8, value: :l })
+        when 0x6e then bit8(5, { type: :indirect, value: :hl })
+        when 0x6f then bit8(5, { type: :register8, value: :a })
+        when 0x70 then bit8(6, { type: :register8, value: :b })
+        when 0x71 then bit8(6, { type: :register8, value: :c })
+        when 0x72 then bit8(6, { type: :register8, value: :d })
+        when 0x73 then bit8(6, { type: :register8, value: :e })
+        when 0x74 then bit8(6, { type: :register8, value: :h })
+        when 0x75 then bit8(6, { type: :register8, value: :l })
+        when 0x76 then bit8(6, { type: :indirect, value: :hl })
+        when 0x77 then bit8(6, { type: :register8, value: :a })
+        when 0x78 then bit8(7, { type: :register8, value: :b })
+        when 0x79 then bit8(7, { type: :register8, value: :c })
+        when 0x7a then bit8(7, { type: :register8, value: :d })
+        when 0x7b then bit8(7, { type: :register8, value: :e })
+        when 0x7c then bit8(7, { type: :register8, value: :h })
+        when 0x7d then bit8(7, { type: :register8, value: :l })
+        when 0x7e then bit8(7, { type: :indirect, value: :hl })
+        when 0x7f then bit8(7, { type: :register8, value: :a })
+        when 0x80 then res8(0, { type: :register8, value: :b })
+        when 0x81 then res8(0, { type: :register8, value: :c })
+        when 0x82 then res8(0, { type: :register8, value: :d })
+        when 0x83 then res8(0, { type: :register8, value: :e })
+        when 0x84 then res8(0, { type: :register8, value: :h })
+        when 0x85 then res8(0, { type: :register8, value: :l })
+        when 0x86 then res8(0, { type: :indirect, value: :hl })
+        when 0x87 then res8(0, { type: :register8, value: :a })
+        when 0x88 then res8(1, { type: :register8, value: :b })
+        when 0x89 then res8(1, { type: :register8, value: :c })
+        when 0x8a then res8(1, { type: :register8, value: :d })
+        when 0x8b then res8(1, { type: :register8, value: :e })
+        when 0x8c then res8(1, { type: :register8, value: :h })
+        when 0x8d then res8(1, { type: :register8, value: :l })
+        when 0x8e then res8(1, { type: :indirect, value: :hl })
+        when 0x8f then res8(1, { type: :register8, value: :a })
+        when 0x90 then res8(2, { type: :register8, value: :b })
+        when 0x91 then res8(2, { type: :register8, value: :c })
+        when 0x92 then res8(2, { type: :register8, value: :d })
+        when 0x93 then res8(2, { type: :register8, value: :e })
+        when 0x94 then res8(2, { type: :register8, value: :h })
+        when 0x95 then res8(2, { type: :register8, value: :l })
+        when 0x96 then res8(2, { type: :indirect, value: :hl })
+        when 0x97 then res8(2, { type: :register8, value: :a })
+        when 0x98 then res8(3, { type: :register8, value: :b })
+        when 0x99 then res8(3, { type: :register8, value: :c })
+        when 0x9a then res8(3, { type: :register8, value: :d })
+        when 0x9b then res8(3, { type: :register8, value: :e })
+        when 0x9c then res8(3, { type: :register8, value: :h })
+        when 0x9d then res8(3, { type: :register8, value: :l })
+        when 0x9e then res8(3, { type: :indirect, value: :hl })
+        when 0x9f then res8(3, { type: :register8, value: :a })
+        when 0xa0 then res8(4, { type: :register8, value: :b })
+        when 0xa1 then res8(4, { type: :register8, value: :c })
+        when 0xa2 then res8(4, { type: :register8, value: :d })
+        when 0xa3 then res8(4, { type: :register8, value: :e })
+        when 0xa4 then res8(4, { type: :register8, value: :h })
+        when 0xa5 then res8(4, { type: :register8, value: :l })
+        when 0xa6 then res8(4, { type: :indirect, value: :hl })
+        when 0xa7 then res8(4, { type: :register8, value: :a })
+        when 0xa8 then res8(5, { type: :register8, value: :b })
+        when 0xa9 then res8(5, { type: :register8, value: :c })
+        when 0xaa then res8(5, { type: :register8, value: :d })
+        when 0xab then res8(5, { type: :register8, value: :e })
+        when 0xac then res8(5, { type: :register8, value: :h })
+        when 0xad then res8(5, { type: :register8, value: :l })
+        when 0xae then res8(5, { type: :indirect, value: :hl })
+        when 0xaf then res8(5, { type: :register8, value: :a })
+        when 0xb0 then res8(6, { type: :register8, value: :b })
+        when 0xb1 then res8(6, { type: :register8, value: :c })
+        when 0xb2 then res8(6, { type: :register8, value: :d })
+        when 0xb3 then res8(6, { type: :register8, value: :e })
+        when 0xb4 then res8(6, { type: :register8, value: :h })
+        when 0xb5 then res8(6, { type: :register8, value: :l })
+        when 0xb6 then res8(6, { type: :indirect, value: :hl })
+        when 0xb7 then res8(6, { type: :register8, value: :a })
+        when 0xb8 then res8(7, { type: :register8, value: :b })
+        when 0xb9 then res8(7, { type: :register8, value: :c })
+        when 0xba then res8(7, { type: :register8, value: :d })
+        when 0xbb then res8(7, { type: :register8, value: :e })
+        when 0xbc then res8(7, { type: :register8, value: :h })
+        when 0xbd then res8(7, { type: :register8, value: :l })
+        when 0xbe then res8(7, { type: :indirect, value: :hl })
+        when 0xbf then res8(7, { type: :register8, value: :a })
+        when 0xc0 then set8(0, { type: :register8, value: :b })
+        when 0xc1 then set8(0, { type: :register8, value: :c })
+        when 0xc2 then set8(0, { type: :register8, value: :d })
+        when 0xc3 then set8(0, { type: :register8, value: :e })
+        when 0xc4 then set8(0, { type: :register8, value: :h })
+        when 0xc5 then set8(0, { type: :register8, value: :l })
+        when 0xc6 then set8(0, { type: :indirect, value: :hl })
+        when 0xc7 then set8(0, { type: :register8, value: :a })
+        when 0xc8 then set8(1, { type: :register8, value: :b })
+        when 0xc9 then set8(1, { type: :register8, value: :c })
+        when 0xca then set8(1, { type: :register8, value: :d })
+        when 0xcb then set8(1, { type: :register8, value: :e })
+        when 0xcc then set8(1, { type: :register8, value: :h })
+        when 0xcd then set8(1, { type: :register8, value: :l })
+        when 0xce then set8(1, { type: :indirect, value: :hl })
+        when 0xcf then set8(1, { type: :register8, value: :a })
+        when 0xd0 then set8(2, { type: :register8, value: :b })
+        when 0xd1 then set8(2, { type: :register8, value: :c })
+        when 0xd2 then set8(2, { type: :register8, value: :d })
+        when 0xd3 then set8(2, { type: :register8, value: :e })
+        when 0xd4 then set8(2, { type: :register8, value: :h })
+        when 0xd5 then set8(2, { type: :register8, value: :l })
+        when 0xd6 then set8(2, { type: :indirect, value: :hl })
+        when 0xd7 then set8(2, { type: :register8, value: :a })
+        when 0xd8 then set8(3, { type: :register8, value: :b })
+        when 0xd9 then set8(3, { type: :register8, value: :c })
+        when 0xda then set8(3, { type: :register8, value: :d })
+        when 0xdb then set8(3, { type: :register8, value: :e })
+        when 0xdc then set8(3, { type: :register8, value: :h })
+        when 0xdd then set8(3, { type: :register8, value: :l })
+        when 0xde then set8(3, { type: :indirect, value: :hl })
+        when 0xdf then set8(3, { type: :register8, value: :a })
+        when 0xe0 then set8(4, { type: :register8, value: :b })
+        when 0xe1 then set8(4, { type: :register8, value: :c })
+        when 0xe2 then set8(4, { type: :register8, value: :d })
+        when 0xe3 then set8(4, { type: :register8, value: :e })
+        when 0xe4 then set8(4, { type: :register8, value: :h })
+        when 0xe5 then set8(4, { type: :register8, value: :l })
+        when 0xe6 then set8(4, { type: :indirect, value: :hl })
+        when 0xe7 then set8(4, { type: :register8, value: :a })
+        when 0xe8 then set8(5, { type: :register8, value: :b })
+        when 0xe9 then set8(5, { type: :register8, value: :c })
+        when 0xea then set8(5, { type: :register8, value: :d })
+        when 0xeb then set8(5, { type: :register8, value: :e })
+        when 0xec then set8(5, { type: :register8, value: :h })
+        when 0xed then set8(5, { type: :register8, value: :l })
+        when 0xee then set8(5, { type: :indirect, value: :hl })
+        when 0xef then set8(5, { type: :register8, value: :a })
+        when 0xf0 then set8(6, { type: :register8, value: :b })
+        when 0xf1 then set8(6, { type: :register8, value: :c })
+        when 0xf2 then set8(6, { type: :register8, value: :d })
+        when 0xf3 then set8(6, { type: :register8, value: :e })
+        when 0xf4 then set8(6, { type: :register8, value: :h })
+        when 0xf5 then set8(6, { type: :register8, value: :l })
+        when 0xf6 then set8(6, { type: :indirect, value: :hl })
+        when 0xf7 then set8(6, { type: :register8, value: :a })
+        when 0xf8 then set8(7, { type: :register8, value: :b })
+        when 0xf9 then set8(7, { type: :register8, value: :c })
+        when 0xfa then set8(7, { type: :register8, value: :d })
+        when 0xfb then set8(7, { type: :register8, value: :e })
+        when 0xfc then set8(7, { type: :register8, value: :h })
+        when 0xfd then set8(7, { type: :register8, value: :l })
+        when 0xfe then set8(7, { type: :indirect, value: :hl })
+        when 0xff then set8(7, { type: :register8, value: :a })
         else
           raise "unknown opcode: 0xcb 0x#{'%02x' % opcode}"
         end
       else
         raise "unknown opcode: 0x#{'%02x' % opcode}"
       end
-      @sp &= 0xffff
-      opcode_kind = cbprefixed ? 'cbprefixed' : 'unprefixed'
-      opcode_str = "0x#{'%02X' % opcode}"
-      cycles = @opcodes[opcode_kind][opcode_str]['cycles']
-      branched ? cycles.max : cycles.min
     end
     private
@@ -1511,24 +593,27 @@ module Rubyboy
     end
     def print_log(opcode)
-      puts "OP: 0x#{'%02x' % opcode}, PC: 0x#{'%04x' % @pc}, SP: 0x#{'%04x' % @sp}, A: 0x#{'%02x' % @a.value}, B: 0x#{'%02x' % @b.value}, C: 0x#{'%02x' % @c.value}, D: 0x#{'%02x' % @d.value}, E: 0x#{'%02x' % @e.value}, H: 0x#{'%02x' % @h.value}, L: 0x#{'%02x' % @l.value}, F: 0x#{'%02x' % @f.value}"
+      puts "PC: 0x#{'%04x' % @pc}, Opcode: 0x#{'%02x' % opcode}, AF: 0x#{'%04x' % @registers.read16(:af)}, BC: 0x#{'%04x' % @registers.read16(:bc)}, HL: 0x#{'%04x' % @registers.read16(:hl)}, SP: 0x#{'%04x' % @sp}"
     end
     def flags
+      f_value = @registers.read8(:f)
       {
-        z: @f.value[7] == 1,
-        n: @f.value[6] == 1,
-        h: @f.value[5] == 1,
-        c: @f.value[4] == 1
+        z: f_value[7] == 1,
+        n: f_value[6] == 1,
+        h: f_value[5] == 1,
+        c: f_value[4] == 1
       }
     end
     def update_flags(z: flags[:z], n: flags[:n], h: flags[:h], c: flags[:c])
-      @f.value = 0x00
-      @f.value |= 0x80 if z
-      @f.value |= 0x40 if n
-      @f.value |= 0x20 if h
-      @f.value |= 0x10 if c
+      f_value = 0x00
+      f_value |= 0x80 if z
+      f_value |= 0x40 if n
+      f_value |= 0x20 if h
+      f_value |= 0x10 if c
+      @registers.write8(:f, f_value)
     end
     def bool_to_integer(bool)
@@ -1543,205 +628,635 @@ module Rubyboy
       @pc += byte
     end
-    def convert_to_twos_complement(byte)
+    def to_signed_byte(byte)
       byte &= 0xff
       byte > 127 ? byte - 256 : byte
     end
-    def ld8(x, y)
-      x.value = y.value
+    def rlca
+      a_value = @registers.read8(:a)
+      a_value = ((a_value << 1) | (a_value >> 7)) & 0xff
+      @registers.write8(:a, a_value)
+      update_flags(
+        z: false,
+        n: false,
+        h: false,
+        c: a_value[0] == 1
+      )
+      4
+    end
+    def rrca
+      a_value = @registers.read8(:a)
+      a_value = ((a_value >> 1) | (a_value << 7)) & 0xff
+      @registers.write8(:a, a_value)
+      update_flags(
+        z: false,
+        n: false,
+        h: false,
+        c: a_value[7] == 1
+      )
+      4
+    end
+    def rra
+      a_value = @registers.read8(:a)
+      cflag = a_value[0] == 1
+      a_value = ((a_value >> 1) | (bool_to_integer(flags[:c]) << 7)) & 0xff
+      @registers.write8(:a, a_value)
+      update_flags(
+        z: false,
+        n: false,
+        h: false,
+        c: cflag
+      )
+      4
+    end
+    def rla
+      a_value = @registers.read8(:a)
+      cflag = a_value[7] == 1
+      a_value = ((a_value << 1) | bool_to_integer(flags[:c])) & 0xff
+      @registers.write8(:a, a_value)
+      update_flags(
+        z: false,
+        n: false,
+        h: false,
+        c: cflag
+      )
+      4
+    end
+    def daa
+      a_value = @registers.read8(:a)
+      if flags[:n]
+        a_value -= 0x06 if flags[:h]
+        a_value -= 0x60 if flags[:c]
+      else
+        if flags[:c] || a_value > 0x99
+          a_value += 0x60
+          update_flags(c: true)
+        end
+        a_value += 0x06 if flags[:h] || (a_value & 0x0f) > 0x09
+      end
+      @registers.write8(:a, a_value)
+      update_flags(
+        z: @registers.read8(:a) == 0,
+        h: false
+      )
+      4
+    end
+    def cpl
+      @registers.write8(:a, ~@registers.read8(:a))
+      update_flags(
+        n: true,
+        h: true
+      )
+      4
     end
-    def add8(x, y)
-      hflag = (x.value & 0x0f) + (y.value & 0x0f) > 0x0f
-      cflag = x.value + y.value > 0xff
-      x.value += y.value
+    def scf
       update_flags(
-        z: x.value.zero?,
+        n: false,
+        h: false,
+        c: true
+      )
+      4
+    end
+    def ccf
+      update_flags(
+        n: false,
+        h: false,
+        c: !flags[:c]
+      )
+      4
+    end
+    def inc8(x)
+      value = (get_value(x) + 1) & 0xff
+      set_value(x, value)
+      update_flags(
+        z: value == 0,
+        n: false,
+        h: (value & 0x0f) == 0
+      )
+      x[:type] == :register8 ? 4 : 12
+    end
+    def inc16(x)
+      set_value(x, get_value(x) + 1)
+      8
+    end
+    def dec8(x)
+      value = (get_value(x) - 1) & 0xff
+      set_value(x, value)
+      update_flags(
+        z: value == 0,
+        n: true,
+        h: (value & 0x0f) == 0x0f
+      )
+      x[:type] == :register8 ? 4 : 12
+    end
+    def dec16(x)
+      set_value(x, get_value(x) - 1)
+      8
+    end
+    def add8(x)
+      a_value = @registers.read8(:a)
+      x_value = get_value(x)
+      hflag = (a_value & 0x0f) + (x_value & 0x0f) > 0x0f
+      cflag = a_value + x_value > 0xff
+      a_value += x_value
+      @registers.write8(:a, a_value)
+      update_flags(
+        z: @registers.read8(:a) == 0,
         n: false,
         h: hflag,
         c: cflag
       )
+      x[:type] == :register8 ? 4 : 8
     end
-    def adc8(x, y)
-      c_value = bool_to_integer(flags[:c])
-      hflag = (x.value & 0x0f) + (y.value & 0x0f) + c_value > 0x0f
-      cflag = x.value + y.value + c_value > 0xff
-      x.value += y.value + c_value
+    def add16(x, y)
+      x_value = get_value(x)
+      y_value = get_value(y)
+      hflag = (x_value & 0x0fff) + (y_value & 0x0fff) > 0x0fff
+      cflag = x_value + y_value > 0xffff
+      set_value(x, x_value + y_value)
+      update_flags(
+        n: false,
+        h: hflag,
+        c: cflag
+      )
+      8
+    end
+    def add_sp_r8
+      byte = to_signed_byte(read_byte_and_advance_pc)
+      hflag = (@sp & 0x0f) + (byte & 0x0f) > 0x0f
+      cflag = (@sp & 0xff) + (byte & 0xff) > 0xff
+      @sp += byte
+      @sp &= 0xffff
       update_flags(
-        z: x.value.zero?,
+        z: false,
         n: false,
         h: hflag,
         c: cflag
       )
+      16
     end
     def sub8(x)
-      hflag = (x.value & 0x0f) > (@a.value & 0x0f)
-      cflag = x.value > @a.value
-      @a.value -= x.value
+      a_value = @registers.read8(:a)
+      x_value = get_value(x)
+      hflag = (x_value & 0x0f) > (a_value & 0x0f)
+      cflag = x_value > a_value
+      a_value -= x_value
+      @registers.write8(:a, a_value)
       update_flags(
-        z: @a.value.zero?,
+        z: a_value == 0,
         n: true,
         h: hflag,
         c: cflag
       )
+      x[:type] == :register8 ? 4 : 8
+    end
+    def adc8(x)
+      a_value = @registers.read8(:a)
+      x_value = get_value(x)
+      c_value = bool_to_integer(flags[:c])
+      hflag = (a_value & 0x0f) + (x_value & 0x0f) + c_value > 0x0f
+      cflag = a_value + x_value + c_value > 0xff
+      a_value += x_value + c_value
+      @registers.write8(:a, a_value)
+      update_flags(
+        z: @registers.read8(:a) == 0,
+        n: false,
+        h: hflag,
+        c: cflag
+      )
+      x[:type] == :register8 ? 4 : 8
     end
     def sbc8(x)
+      a_value = @registers.read8(:a)
+      x_value = get_value(x)
       c_value = bool_to_integer(flags[:c])
-      hflag = (x.value & 0x0f) + c_value > (@a.value & 0x0f)
-      cflag = x.value + c_value > @a.value
-      @a.value -= x.value + c_value
+      hflag = (x_value & 0x0f) + c_value > (a_value & 0x0f)
+      cflag = x_value + c_value > a_value
+      a_value -= x_value + c_value
+      @registers.write8(:a, a_value)
       update_flags(
-        z: @a.value.zero?,
+        z: @registers.read8(:a) == 0,
         n: true,
         h: hflag,
         c: cflag
       )
+      x[:type] == :register8 ? 4 : 8
     end
     def and8(x)
-      @a.value &= x.value
+      a_value = @registers.read8(:a) & get_value(x)
+      @registers.write8(:a, a_value)
       update_flags(
-        z: @a.value.zero?,
+        z: a_value == 0,
         n: false,
         h: true,
         c: false
       )
+      x[:type] == :register8 ? 4 : 8
     end
     def or8(x)
-      @a.value |= x.value
+      a_value = @registers.read8(:a) | get_value(x)
+      @registers.write8(:a, a_value)
       update_flags(
-        z: @a.value.zero?,
+        z: a_value == 0,
         n: false,
         h: false,
         c: false
       )
+      x[:type] == :register8 ? 4 : 8
     end
     def xor8(x)
-      @a.value ^= x.value
+      a_value = @registers.read8(:a) ^ get_value(x)
+      @registers.write8(:a, a_value)
       update_flags(
-        z: @a.value.zero?,
+        z: a_value == 0,
         n: false,
         h: false,
         c: false
       )
+      x[:type] == :register8 ? 4 : 8
+    end
+    def push16(register16)
+      value = @registers.read16(register16)
+      @sp -= 2
+      write_word(@sp, value)
+      16
+    end
+    def pop16(register16)
+      @registers.write16(register16, read_word(@sp))
+      @sp += 2
+      12
+    end
+    def halt
+      @halted = true
+      4
+    end
+    def ld8(x, y)
+      value = get_value(y)
+      set_value(x, value)
+      return 4 if x[:type] == :register8 && y[:type] == :register8
+      return 12 if x[:type] == :indirect && y[:type] == :immediate8
+      return 12 if x[:type] == :ff00 || y[:type] == :ff00
+      return 16 if x[:type] == :direct8 || y[:type] == :direct8
+      8
+    end
+    def ld16(x, y)
+      value = get_value(y)
+      set_value(x, value)
+      return 8 if y[:type] == :register16
+      return 20 if y[:type] == :sp
+      12
+    end
+    def ld_hl_sp_r8
+      byte = to_signed_byte(read_byte_and_advance_pc)
+      hflag = (@sp & 0x0f) + (byte & 0x0f) > 0x0f
+      cflag = (@sp & 0xff) + (byte & 0xff) > 0xff
+      @registers.write16(:hl, @sp + byte)
+      update_flags(
+        z: false,
+        n: false,
+        h: hflag,
+        c: cflag
+      )
+      12
+    end
+    def ei
+      @ime_delay = true
+      4
+    end
+    def di
+      @ime_delay = false
+      @ime = false
+      4
     end
     def cp8(x)
-      hflag = (x.value & 0x0f) > (@a.value & 0x0f)
-      cflag = x.value > @a.value
+      a_value = @registers.read8(:a)
+      x_value = get_value(x)
+      hflag = (x_value & 0x0f) > (a_value & 0x0f)
+      cflag = x_value > a_value
       update_flags(
-        z: @a.value == x.value,
+        z: a_value == x_value,
         n: true,
         h: hflag,
         c: cflag
       )
+      x[:type] == :register8 ? 4 : 8
+    end
+    def rst(addr)
+      @sp -= 2
+      write_word(@sp, @pc)
+      @pc = addr
+      16
+    end
+    def jr(condition: true)
+      value = to_signed_byte(read_byte_and_advance_pc)
+      @pc += value if condition
+      condition ? 12 : 8
+    end
+    def jp(x, condition: true)
+      addr = get_value(x)
+      @pc = addr if condition
+      return 4 if x[:type] == :register16
+      condition ? 16 : 12
+    end
+    def call16(x, condition: true)
+      addr = get_value(x)
+      if condition
+        @sp -= 2
+        write_word(@sp, @pc)
+        @pc = addr
+      end
+      condition ? 24 : 12
+    end
+    def ret
+      @pc = read_word(@sp)
+      @sp += 2
+      16
+    end
+    def ret_if(condition)
+      ret if condition
+      condition ? 20 : 8
+    end
+    def reti
+      @ime = true
+      ret
     end
     def rlc8(x)
-      x.value = (x.value << 1) | (x.value >> 7)
+      value = get_value(x)
+      value = (value << 1) | (value >> 7)
+      set_value(x, value)
       update_flags(
-        z: x.value.zero?,
+        z: value == 0,
         n: false,
         h: false,
-        c: x.value[0] == 1
+        c: value[0] == 1
       )
+      x[:type] == :register8 ? 8 : 16
     end
     def rrc8(x)
-      x.value = (x.value >> 1) | (x.value << 7)
+      value = get_value(x)
+      value = (value >> 1) | (value << 7)
+      set_value(x, value)
       update_flags(
-        z: x.value.zero?,
+        z: value == 0,
         n: false,
         h: false,
-        c: x.value[7] == 1
+        c: value[7] == 1
       )
+      x[:type] == :register8 ? 8 : 16
     end
     def rl8(x)
-      cflag = x.value[7] == 1
-      x.value = (x.value << 1) | bool_to_integer(flags[:c])
+      value = get_value(x)
+      cflag = value[7] == 1
+      value = ((value << 1) | bool_to_integer(flags[:c])) & 0xff
+      set_value(x, value)
       update_flags(
-        z: x.value.zero?,
+        z: value == 0,
         n: false,
         h: false,
         c: cflag
       )
+      x[:type] == :register8 ? 8 : 16
     end
     def rr8(x)
-      cflag = x.value[0] == 1
-      x.value = (x.value >> 1) | (bool_to_integer(flags[:c]) << 7)
+      value = get_value(x)
+      cflag = value[0] == 1
+      value = (value >> 1) | (bool_to_integer(flags[:c]) << 7)
+      set_value(x, value)
       update_flags(
-        z: x.value.zero?,
+        z: value == 0,
         n: false,
         h: false,
         c: cflag
       )
+      x[:type] == :register8 ? 8 : 16
     end
     def sla8(x)
-      cflag = x.value[7] == 1
-      x.value <<= 1
+      value = get_value(x)
+      cflag = value[7] == 1
+      value <<= 1
+      value &= 0xff
+      set_value(x, value)
       update_flags(
-        z: x.value.zero?,
+        z: value == 0,
         n: false,
         h: false,
         c: cflag
       )
+      x[:type] == :register8 ? 8 : 16
     end
     def sra8(x)
-      cflag = x.value[0] == 1
-      x.value = (x.value >> 1) | (x.value[7] << 7)
+      value = get_value(x)
+      cflag = value[0] == 1
+      value = (value >> 1) | (value[7] << 7)
+      set_value(x, value)
       update_flags(
-        z: x.value.zero?,
+        z: value == 0,
         n: false,
         h: false,
         c: cflag
       )
+      x[:type] == :register8 ? 8 : 16
     end
     def swap8(x)
-      x.value = ((x.value & 0x0f) << 4) | ((x.value & 0xf0) >> 4)
+      value = get_value(x)
+      value = ((value & 0x0f) << 4) | ((value & 0xf0) >> 4)
+      set_value(x, value)
       update_flags(
-        z: x.value.zero?,
+        z: value == 0,
         n: false,
         h: false,
         c: false
       )
+      x[:type] == :register8 ? 8 : 16
     end
     def srl8(x)
-      cflag = x.value[0] == 1
-      x.value >>= 1
+      value = get_value(x)
+      cflag = value[0] == 1
+      value >>= 1
+      set_value(x, value)
       update_flags(
-        z: x.value.zero?,
+        z: value == 0,
         n: false,
         h: false,
         c: cflag
       )
+      x[:type] == :register8 ? 8 : 16
     end
     def bit8(n, x)
+      value = get_value(x)
       update_flags(
-        z: x.value[n].zero?,
+        z: value[n] == 0,
         n: false,
         h: true
       )
+      x[:type] == :register8 ? 8 : 12
+    end
+    def res8(n, x)
+      value = get_value(x)
+      value &= ((~(1 << n)) & 0xff)
+      set_value(x, value)
+      x[:type] == :register8 ? 8 : 16
     end
     def set8(n, x)
-      x.value |= (1 << n)
+      value = get_value(x)
+      value |= (1 << n)
+      set_value(x, value)
+      x[:type] == :register8 ? 8 : 16
     end
-    def res8(n, x)
-      x.value &= ((~(1 << n)) & 0xff)
+    def get_value(operand)
+      case operand[:type]
+      when :register8 then @registers.read8(operand[:value])
+      when :register16 then @registers.read16(operand[:value])
+      when :sp then @sp
+      when :immediate8 then read_byte_and_advance_pc
+      when :immediate16 then read_word_and_advance_pc
+      when :direct8 then read_byte(read_word_and_advance_pc)
+      when :direct16 then read_word(read_word_and_advance_pc)
+      when :indirect then read_byte(@registers.read16(operand[:value]))
+      when :ff00 then read_byte(0xff00 + read_byte_and_advance_pc)
+      when :ff00_c then read_byte(0xff00 + @registers.read8(:c))
+      when :hl_inc
+        value = read_byte(@registers.read16(:hl))
+        @registers.increment16(:hl)
+        value
+      when :hl_dec
+        value = read_byte(@registers.read16(:hl))
+        @registers.decrement16(:hl)
+        value
+      else raise "unknown operand: #{operand}"
+      end
+    end
+    def set_value(operand, value)
+      case operand[:type]
+      when :register8 then @registers.write8(operand[:value], value)
+      when :register16 then @registers.write16(operand[:value], value)
+      when :sp then @sp = value & 0xffff
+      when :direct8 then write_byte(read_word_and_advance_pc, value)
+      when :direct16 then write_word(read_word_and_advance_pc, value)
+      when :indirect then write_byte(@registers.read16(operand[:value]), value)
+      when :ff00 then write_byte(0xff00 + read_byte_and_advance_pc, value)
+      when :ff00_c then write_byte(0xff00 + @registers.read8(:c), value)
+      when :hl_inc
+        write_byte(@registers.read16(:hl), value)
+        @registers.increment16(:hl)
+      when :hl_dec
+        write_byte(@registers.read16(:hl), value)
+        @registers.decrement16(:hl)
+      when :immediate8, :immediate16 then raise 'immediate type is read only'
+      else raise "unknown operand: #{operand}"
+      end
     end
   end
 end