From 9ee72dc145976126f5c957a6a91f8c35aed2757f Mon Sep 17 00:00:00 2001
From: Ariejan de Vroom <ariejan@ariejan.net>
Date: Sat, 16 Aug 2014 21:54:06 +0200
Subject: [PATCH] Clean up code / Refactorings

---
 addressing-modes.go |  36 ----
 cpu.go              | 316 +++++++++++++++++++++++++++----
 cpu_instructions.go | 271 ---------------------------
 cpu_stack.go        |  19 --
 cpu_stack_test.go   |  28 ---
 cpu_test.go         | 445 +++++++++++++++++++++++---------------------
 instruction.go      |  21 ---
 opcodes.go          |  35 ++++
 8 files changed, 547 insertions(+), 624 deletions(-)
 delete mode 100644 addressing-modes.go
 delete mode 100644 cpu_instructions.go
 delete mode 100644 cpu_stack.go
 delete mode 100644 cpu_stack_test.go

diff --git a/addressing-modes.go b/addressing-modes.go
deleted file mode 100644
index d2ac78e..0000000
--- a/addressing-modes.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package i6502
-
-// Addressing modes
-const (
-	_ = iota
-	absolute
-	absoluteX
-	absoluteY
-	accumulator
-	immediate
-	implied
-	indirect
-	indirectX
-	indirectY
-	relative
-	zeropage
-	zeropageX
-	zeropageY
-)
-
-var addressingNames = [...]string{
-	"",
-	"absolute",
-	"absoluteX",
-	"absoluteY",
-	"accumulator",
-	"immediate",
-	"implied",
-	"(indirect)",
-	"(indirect,X)",
-	"(indirect),Y",
-	"relative",
-	"zeropage",
-	"zeropageX",
-	"zeropageY",
-}
diff --git a/cpu.go b/cpu.go
index e5f5268..93ceef2 100644
--- a/cpu.go
+++ b/cpu.go
@@ -3,8 +3,6 @@ package i6502
 import "fmt"
 
 type Cpu struct {
-	bus *AddressBus // The address bus
-
 	PC uint16 // 16-bit program counter
 	P  byte   // Status Register
 	SP byte   // Stack Pointer
@@ -12,16 +10,20 @@ type Cpu struct {
 	A byte // Accumulator
 	X byte // X index register
 	Y byte // Y index register
+
+	Bus *AddressBus // The address bus
 }
 
 const (
 	ResetVector = 0xFFFC // 0xFFFC-FFFD
 	IrqVector   = 0xFFFE // 0xFFFE-FFFF
+
+	StackBase = 0x0100 // One page 0x0100-01FF
 )
 
 // Create an new Cpu instance with the specified AddressBus
 func NewCpu(bus *AddressBus) (*Cpu, error) {
-	return &Cpu{bus: bus}, nil
+	return &Cpu{Bus: bus}, nil
 }
 
 func (c *Cpu) String() string {
@@ -29,13 +31,13 @@ func (c *Cpu) String() string {
 	return fmt.Sprintf(str, c.A, c.X, c.Y, c.SP, c.PC, c.P)
 }
 
-func (c *Cpu) HasAddressBus() bool {
-	return c.bus != nil
+func (c *Cpu) hasAddressBus() bool {
+	return c.Bus != nil
 }
 
 // Reset the CPU, emulating the RESB pin.
 func (c *Cpu) Reset() {
-	c.PC = c.bus.Read16(ResetVector)
+	c.PC = c.Bus.Read16(ResetVector)
 	c.P = 0x34
 
 	// Not specified, but let's clean up
@@ -57,14 +59,14 @@ func (c *Cpu) handleIrq(PC uint16) {
 
 	c.setIrqDisable(true)
 
-	c.PC = c.bus.Read16(IrqVector)
+	c.PC = c.Bus.Read16(IrqVector)
 }
 
 // Load the specified program data at the given memory location
 // and point the Program Counter to the beginning of the program
 func (c *Cpu) LoadProgram(data []byte, location uint16) {
 	for i, b := range data {
-		c.bus.Write(location+uint16(i), b)
+		c.Bus.Write(location+uint16(i), b)
 	}
 
 	c.PC = location
@@ -72,10 +74,8 @@ func (c *Cpu) LoadProgram(data []byte, location uint16) {
 
 // Execute the instruction pointed to by the Program Counter (PC)
 func (c *Cpu) Step() {
-	// fmt.Println(c)
 	instruction := c.readNextInstruction()
 	c.PC += uint16(instruction.Size)
-	// fmt.Println(instruction)
 	c.execute(instruction)
 }
 
@@ -84,9 +84,9 @@ func (c *Cpu) execute(instruction Instruction) {
 	case nop:
 		break
 	case adc:
-		c.ADC(instruction)
+		c.adc(instruction)
 	case sbc:
-		c.SBC(instruction)
+		c.sbc(instruction)
 	case sec:
 		c.setCarry(true)
 	case sed:
@@ -106,31 +106,40 @@ func (c *Cpu) execute(instruction Instruction) {
 	case iny:
 		c.setY(c.Y + 1)
 	case inc:
-		c.INC(instruction)
+		c.inc(instruction)
 	case dex:
 		c.setX(c.X - 1)
 	case dey:
 		c.setY(c.Y - 1)
 	case dec:
-		c.DEC(instruction)
+		c.dec(instruction)
 	case lda:
-		c.LDA(instruction)
+		value := c.resolveOperand(instruction)
+		c.setA(value)
 	case ldx:
-		c.LDX(instruction)
+		value := c.resolveOperand(instruction)
+		c.setX(value)
 	case ldy:
-		c.LDY(instruction)
+		value := c.resolveOperand(instruction)
+		c.setY(value)
 	case ora:
-		c.ORA(instruction)
+		value := c.resolveOperand(instruction)
+		c.setA(c.A | value)
 	case and:
-		c.AND(instruction)
+		value := c.resolveOperand(instruction)
+		c.setA(c.A & value)
 	case eor:
-		c.EOR(instruction)
+		value := c.resolveOperand(instruction)
+		c.setA(c.A ^ value)
 	case sta:
-		c.STA(instruction)
+		address := c.memoryAddress(instruction)
+		c.Bus.Write(address, c.A)
 	case stx:
-		c.STX(instruction)
+		address := c.memoryAddress(instruction)
+		c.Bus.Write(address, c.X)
 	case sty:
-		c.STY(instruction)
+		address := c.memoryAddress(instruction)
+		c.Bus.Write(address, c.Y)
 	case tax:
 		c.setX(c.A)
 	case tay:
@@ -144,21 +153,28 @@ func (c *Cpu) execute(instruction Instruction) {
 	case txs:
 		c.SP = c.X
 	case asl:
-		c.ASL(instruction)
+		c.asl(instruction)
 	case lsr:
-		c.LSR(instruction)
+		c.lsr(instruction)
 	case rol:
-		c.ROL(instruction)
+		c.rol(instruction)
 	case ror:
-		c.ROR(instruction)
+		c.ror(instruction)
 	case cmp:
-		c.CMP(instruction)
+		value := c.resolveOperand(instruction)
+		c.setCarry(c.A >= value)
+		c.setArithmeticFlags(c.A - value)
 	case cpx:
-		c.CPX(instruction)
+		value := c.resolveOperand(instruction)
+		c.setCarry(c.X >= value)
+		c.setArithmeticFlags(c.X - value)
 	case cpy:
-		c.CPY(instruction)
+		value := c.resolveOperand(instruction)
+		c.setCarry(c.Y >= value)
+		c.setArithmeticFlags(c.Y - value)
 	case brk:
-		c.BRK()
+		c.setBreak(true)
+		c.handleIrq(c.PC + 1)
 	case bcc:
 		if !c.getCarry() {
 			c.branch(instruction)
@@ -192,7 +208,10 @@ func (c *Cpu) execute(instruction Instruction) {
 			c.branch(instruction)
 		}
 	case bit:
-		c.BIT(instruction)
+		value := c.resolveOperand(instruction)
+		c.setNegative((value & 0x80) != 0)
+		c.setOverflow((value & 0x40) != 0)
+		c.setZero((c.A & value) == 0)
 	case php:
 		c.stackPush(c.P | 0x30)
 	case plp:
@@ -203,9 +222,11 @@ func (c *Cpu) execute(instruction Instruction) {
 		value := c.stackPop()
 		c.setA(value)
 	case jmp:
-		c.JMP(instruction)
+		c.PC = c.memoryAddress(instruction)
 	case jsr:
-		c.JSR(instruction)
+		c.stackPush(byte((c.PC - 1) >> 8))
+		c.stackPush(byte(c.PC - 1))
+		c.PC = c.memoryAddress(instruction)
 	case rts:
 		c.PC = (uint16(c.stackPop()) | uint16(c.stackPop())<<8) + 1
 	case rti:
@@ -216,6 +237,27 @@ func (c *Cpu) execute(instruction Instruction) {
 	}
 }
 
+func (c *Cpu) readNextInstruction() Instruction {
+	// Read the opcode
+	opcode := c.Bus.Read(c.PC)
+
+	optype, ok := opTypes[opcode]
+	if !ok {
+		panic(fmt.Sprintf("Unknown or unimplemented opcode 0x%02X\n%s", opcode, c.String()))
+	}
+
+	instruction := Instruction{OpType: optype, Address: c.PC}
+	switch instruction.Size {
+	case 1: // Zero operand instruction
+	case 2: // 8-bit operand
+		instruction.Op8 = c.Bus.Read(c.PC + 1)
+	case 3: // 16-bit operand
+		instruction.Op16 = c.Bus.Read16(c.PC + 1)
+	}
+
+	return instruction
+}
+
 func (c *Cpu) branch(in Instruction) {
 	relative := int8(in.Op8) // Signed!
 	if relative >= 0 {
@@ -230,7 +272,7 @@ func (c *Cpu) resolveOperand(in Instruction) uint8 {
 	case immediate:
 		return in.Op8
 	default:
-		return c.bus.Read(c.memoryAddress(in))
+		return c.Bus.Read(c.memoryAddress(in))
 	}
 }
 
@@ -243,11 +285,11 @@ func (c *Cpu) memoryAddress(in Instruction) uint16 {
 	case absoluteY:
 		return in.Op16 + uint16(c.Y)
 	case indirect:
-		return c.bus.Read16(in.Op16)
+		return c.Bus.Read16(in.Op16)
 	case indirectX:
-		return c.bus.Read16(uint16(in.Op8 + c.X))
+		return c.Bus.Read16(uint16(in.Op8 + c.X))
 	case indirectY:
-		return c.bus.Read16(uint16(in.Op8)) + uint16(c.Y)
+		return c.Bus.Read16(uint16(in.Op8)) + uint16(c.Y)
 	case relative:
 		panic("Relative addressing not yet implemented.")
 	case zeropage:
@@ -260,3 +302,201 @@ func (c *Cpu) memoryAddress(in Instruction) uint16 {
 		panic(fmt.Errorf("Unhandled addressing mode. Are you sure you are running a 6502 ROM?"))
 	}
 }
+
+// Add Memory to Accumulator with Carry
+func (c *Cpu) adc(in Instruction) {
+	operand := c.resolveOperand(in)
+	carryIn := c.getCarryInt()
+
+	if c.getDecimal() {
+		c.adcDecimal(c.A, operand, carryIn)
+	} else {
+		c.adcNormal(c.A, operand, carryIn)
+	}
+}
+
+// Substract memory from Accummulator with carry
+func (c *Cpu) sbc(in Instruction) {
+	operand := c.resolveOperand(in)
+	carryIn := c.getCarryInt()
+
+	// fmt.Printf("SBC: A: 0x%02X V: 0x%02X C: %b D: %v\n", c.A, operand, carryIn, c.getDecimal())
+
+	if c.getDecimal() {
+		c.sbcDecimal(c.A, operand, carryIn)
+	} else {
+		c.adcNormal(c.A, ^operand, carryIn)
+	}
+}
+
+func (c *Cpu) inc(in Instruction) {
+	address := c.memoryAddress(in)
+	value := c.Bus.Read(address) + 1
+
+	c.Bus.Write(address, value)
+	c.setArithmeticFlags(value)
+}
+
+func (c *Cpu) dec(in Instruction) {
+	address := c.memoryAddress(in)
+	value := c.Bus.Read(address) - 1
+
+	c.Bus.Write(address, value)
+	c.setArithmeticFlags(value)
+}
+
+func (c *Cpu) asl(in Instruction) {
+	switch in.addressingId {
+	case accumulator:
+		c.setCarry((c.A >> 7) == 1)
+		c.A <<= 1
+		c.setArithmeticFlags(c.A)
+	default:
+		address := c.memoryAddress(in)
+		value := c.Bus.Read(address)
+		c.setCarry((value >> 7) == 1)
+		value <<= 1
+		c.Bus.Write(address, value)
+		c.setArithmeticFlags(value)
+	}
+}
+
+func (c *Cpu) lsr(in Instruction) {
+	switch in.addressingId {
+	case accumulator:
+		c.setCarry((c.A & 0x01) == 1)
+		c.A >>= 1
+		c.setArithmeticFlags(c.A)
+	default:
+		address := c.memoryAddress(in)
+		value := c.Bus.Read(address)
+		c.setCarry((value & 0x01) == 1)
+		value >>= 1
+		c.Bus.Write(address, value)
+		c.setArithmeticFlags(value)
+	}
+}
+
+func (c *Cpu) rol(in Instruction) {
+	carry := c.getCarryInt()
+
+	switch in.addressingId {
+	case accumulator:
+		c.setCarry((c.A & 0x80) != 0)
+		c.A = c.A<<1 | carry
+		c.setArithmeticFlags(c.A)
+	default:
+		address := c.memoryAddress(in)
+		value := c.Bus.Read(address)
+		c.setCarry((value & 0x80) != 0)
+		value = value<<1 | carry
+		c.Bus.Write(address, value)
+		c.setArithmeticFlags(value)
+	}
+}
+
+func (c *Cpu) ror(in Instruction) {
+	carry := c.getCarryInt()
+
+	switch in.addressingId {
+	case accumulator:
+		c.setCarry(c.A&0x01 == 1)
+		c.A = c.A>>1 | carry<<7
+		c.setArithmeticFlags(c.A)
+	default:
+		address := c.memoryAddress(in)
+		value := c.Bus.Read(address)
+		c.setCarry(value&0x01 == 1)
+		value = value>>1 | carry<<7
+		c.Bus.Write(address, value)
+		c.setArithmeticFlags(value)
+	}
+}
+
+// Performs regular, 8-bit addition
+func (c *Cpu) adcNormal(a uint8, b uint8, carryIn uint8) {
+	result16 := uint16(a) + uint16(b) + uint16(carryIn)
+	result := uint8(result16)
+	carryOut := (result16 & 0x100) != 0
+	overflow := (a^result)&(b^result)&0x80 != 0
+
+	// Set the carry flag if we exceed 8-bits
+	c.setCarry(carryOut)
+	// Set the overflow bit
+	c.setOverflow(overflow)
+	// Store the resulting value (8-bits)
+	c.setA(result)
+}
+
+// Performs addition in decimal mode
+func (c *Cpu) adcDecimal(a uint8, b uint8, carryIn uint8) {
+	var carryB uint8 = 0
+
+	low := (a & 0x0F) + (b & 0x0F) + carryIn
+	if (low & 0xFF) > 9 {
+		low += 6
+	}
+	if low > 15 {
+		carryB = 1
+	}
+
+	high := (a >> 4) + (b >> 4) + carryB
+	if (high & 0xFF) > 9 {
+		high += 6
+	}
+
+	result := (low & 0x0F) | (high<<4)&0xF0
+
+	c.setCarry(high > 15)
+	c.setZero(result == 0)
+	c.setNegative(false) // BCD never sets negative
+	c.setOverflow(false) // BCD never sets overflow
+
+	c.A = result
+}
+
+func (c *Cpu) sbcDecimal(a uint8, b uint8, carryIn uint8) {
+	var carryB uint8 = 0
+
+	if carryIn == 0 {
+		carryIn = 1
+	} else {
+		carryIn = 0
+	}
+
+	low := (a & 0x0F) - (b & 0x0F) - carryIn
+	if (low & 0x10) != 0 {
+		low -= 6
+	}
+	if (low & 0x10) != 0 {
+		carryB = 1
+	}
+
+	high := (a >> 4) - (b >> 4) - carryB
+	if (high & 0x10) != 0 {
+		high -= 6
+	}
+
+	result := (low & 0x0F) | (high << 4)
+
+	c.setCarry((high & 0xFF) < 15)
+	c.setZero(result == 0)
+	c.setNegative(false) // BCD never sets negative
+	c.setOverflow(false) // BCD never sets overflow
+
+	c.A = result
+}
+
+func (c *Cpu) stackPush(data byte) {
+	c.Bus.Write(StackBase+uint16(c.SP), data)
+	c.SP -= 1
+}
+
+func (c *Cpu) stackPeek() byte {
+	return c.Bus.Read(StackBase + uint16(c.SP+1))
+}
+
+func (c *Cpu) stackPop() byte {
+	c.SP += 1
+	return c.Bus.Read(StackBase + uint16(c.SP))
+}
diff --git a/cpu_instructions.go b/cpu_instructions.go
deleted file mode 100644
index 11dcb9e..0000000
--- a/cpu_instructions.go
+++ /dev/null
@@ -1,271 +0,0 @@
-package i6502
-
-// Add Memory to Accumulator with Carry
-func (c *Cpu) ADC(in Instruction) {
-	operand := c.resolveOperand(in)
-	carryIn := c.getCarryInt()
-
-	if c.getDecimal() {
-		c.adcDecimal(c.A, operand, carryIn)
-	} else {
-		c.adcNormal(c.A, operand, carryIn)
-	}
-}
-
-// Substract memory from Accummulator with carry
-func (c *Cpu) SBC(in Instruction) {
-	operand := c.resolveOperand(in)
-	carryIn := c.getCarryInt()
-
-	// fmt.Printf("SBC: A: 0x%02X V: 0x%02X C: %b D: %v\n", c.A, operand, carryIn, c.getDecimal())
-
-	if c.getDecimal() {
-		c.sbcDecimal(c.A, operand, carryIn)
-	} else {
-		c.adcNormal(c.A, ^operand, carryIn)
-	}
-}
-
-func (c *Cpu) INC(in Instruction) {
-	address := c.memoryAddress(in)
-	value := c.bus.Read(address) + 1
-
-	c.bus.Write(address, value)
-	c.setArithmeticFlags(value)
-}
-
-func (c *Cpu) DEC(in Instruction) {
-	address := c.memoryAddress(in)
-	value := c.bus.Read(address) - 1
-
-	c.bus.Write(address, value)
-	c.setArithmeticFlags(value)
-}
-
-func (c *Cpu) LDA(in Instruction) {
-	value := c.resolveOperand(in)
-	c.setA(value)
-}
-
-func (c *Cpu) LDX(in Instruction) {
-	value := c.resolveOperand(in)
-	c.setX(value)
-}
-
-func (c *Cpu) LDY(in Instruction) {
-	value := c.resolveOperand(in)
-	c.setY(value)
-}
-
-func (c *Cpu) ORA(in Instruction) {
-	value := c.resolveOperand(in)
-	c.setA(c.A | value)
-}
-
-func (c *Cpu) AND(in Instruction) {
-	value := c.resolveOperand(in)
-	c.setA(c.A & value)
-}
-
-func (c *Cpu) EOR(in Instruction) {
-	value := c.resolveOperand(in)
-	c.setA(c.A ^ value)
-}
-
-func (c *Cpu) STA(in Instruction) {
-	address := c.memoryAddress(in)
-	c.bus.Write(address, c.A)
-}
-
-func (c *Cpu) STX(in Instruction) {
-	address := c.memoryAddress(in)
-	c.bus.Write(address, c.X)
-}
-
-func (c *Cpu) STY(in Instruction) {
-	address := c.memoryAddress(in)
-	c.bus.Write(address, c.Y)
-}
-
-func (c *Cpu) ASL(in Instruction) {
-	switch in.addressingId {
-	case accumulator:
-		c.setCarry((c.A >> 7) == 1)
-		c.A <<= 1
-		c.setArithmeticFlags(c.A)
-	default:
-		address := c.memoryAddress(in)
-		value := c.bus.Read(address)
-		c.setCarry((value >> 7) == 1)
-		value <<= 1
-		c.bus.Write(address, value)
-		c.setArithmeticFlags(value)
-	}
-}
-
-func (c *Cpu) LSR(in Instruction) {
-	switch in.addressingId {
-	case accumulator:
-		c.setCarry((c.A & 0x01) == 1)
-		c.A >>= 1
-		c.setArithmeticFlags(c.A)
-	default:
-		address := c.memoryAddress(in)
-		value := c.bus.Read(address)
-		c.setCarry((value & 0x01) == 1)
-		value >>= 1
-		c.bus.Write(address, value)
-		c.setArithmeticFlags(value)
-	}
-}
-
-func (c *Cpu) ROL(in Instruction) {
-	carry := c.getCarryInt()
-
-	switch in.addressingId {
-	case accumulator:
-		c.setCarry((c.A & 0x80) != 0)
-		c.A = c.A<<1 | carry
-		c.setArithmeticFlags(c.A)
-	default:
-		address := c.memoryAddress(in)
-		value := c.bus.Read(address)
-		c.setCarry((value & 0x80) != 0)
-		value = value<<1 | carry
-		c.bus.Write(address, value)
-		c.setArithmeticFlags(value)
-	}
-}
-
-func (c *Cpu) ROR(in Instruction) {
-	carry := c.getCarryInt()
-
-	switch in.addressingId {
-	case accumulator:
-		c.setCarry(c.A&0x01 == 1)
-		c.A = c.A>>1 | carry<<7
-		c.setArithmeticFlags(c.A)
-	default:
-		address := c.memoryAddress(in)
-		value := c.bus.Read(address)
-		c.setCarry(value&0x01 == 1)
-		value = value>>1 | carry<<7
-		c.bus.Write(address, value)
-		c.setArithmeticFlags(value)
-	}
-}
-
-func (c *Cpu) CMP(in Instruction) {
-	value := c.resolveOperand(in)
-	// fmt.Printf("CMP A: 0x%02X V: 0x%02X\n", c.A, value)
-	c.setCarry(c.A >= value)
-	c.setArithmeticFlags(c.A - value)
-}
-
-func (c *Cpu) CPX(in Instruction) {
-	value := c.resolveOperand(in)
-	c.setCarry(c.X >= value)
-	c.setArithmeticFlags(c.X - value)
-}
-
-func (c *Cpu) CPY(in Instruction) {
-	value := c.resolveOperand(in)
-	c.setCarry(c.Y >= value)
-	c.setArithmeticFlags(c.Y - value)
-}
-
-func (c *Cpu) BRK() {
-	c.setBreak(true)
-	c.handleIrq(c.PC + 1)
-}
-
-func (c *Cpu) BIT(in Instruction) {
-	value := c.resolveOperand(in)
-	c.setNegative((value & 0x80) != 0)
-	c.setOverflow((value & 0x40) != 0)
-	c.setZero((c.A & value) == 0)
-}
-
-func (c *Cpu) JMP(in Instruction) {
-	c.PC = c.memoryAddress(in)
-}
-
-func (c *Cpu) JSR(in Instruction) {
-	c.stackPush(byte((c.PC - 1) >> 8))
-	c.stackPush(byte(c.PC - 1))
-	c.PC = c.memoryAddress(in)
-}
-
-// Performs regular, 8-bit addition
-func (c *Cpu) adcNormal(a uint8, b uint8, carryIn uint8) {
-	result16 := uint16(a) + uint16(b) + uint16(carryIn)
-	result := uint8(result16)
-	carryOut := (result16 & 0x100) != 0
-	overflow := (a^result)&(b^result)&0x80 != 0
-
-	// Set the carry flag if we exceed 8-bits
-	c.setCarry(carryOut)
-	// Set the overflow bit
-	c.setOverflow(overflow)
-	// Store the resulting value (8-bits)
-	c.setA(result)
-}
-
-// Performs addition in decimal mode
-func (c *Cpu) adcDecimal(a uint8, b uint8, carryIn uint8) {
-	var carryB uint8 = 0
-
-	low := (a & 0x0F) + (b & 0x0F) + carryIn
-	if (low & 0xFF) > 9 {
-		low += 6
-	}
-	if low > 15 {
-		carryB = 1
-	}
-
-	high := (a >> 4) + (b >> 4) + carryB
-	if (high & 0xFF) > 9 {
-		high += 6
-	}
-
-	result := (low & 0x0F) | (high<<4)&0xF0
-
-	c.setCarry(high > 15)
-	c.setZero(result == 0)
-	c.setNegative(false) // BCD never sets negative
-	c.setOverflow(false) // BCD never sets overflow
-
-	c.A = result
-}
-
-func (c *Cpu) sbcDecimal(a uint8, b uint8, carryIn uint8) {
-	var carryB uint8 = 0
-
-	if carryIn == 0 {
-		carryIn = 1
-	} else {
-		carryIn = 0
-	}
-
-	low := (a & 0x0F) - (b & 0x0F) - carryIn
-	if (low & 0x10) != 0 {
-		low -= 6
-	}
-	if (low & 0x10) != 0 {
-		carryB = 1
-	}
-
-	high := (a >> 4) - (b >> 4) - carryB
-	if (high & 0x10) != 0 {
-		high -= 6
-	}
-
-	result := (low & 0x0F) | (high << 4)
-
-	c.setCarry((high & 0xFF) < 15)
-	c.setZero(result == 0)
-	c.setNegative(false) // BCD never sets negative
-	c.setOverflow(false) // BCD never sets overflow
-
-	c.A = result
-}
diff --git a/cpu_stack.go b/cpu_stack.go
deleted file mode 100644
index 35d12cd..0000000
--- a/cpu_stack.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package i6502
-
-const (
-	StackBase = 0x0100
-)
-
-func (c *Cpu) stackPush(data byte) {
-	c.bus.Write(StackBase+uint16(c.SP), data)
-	c.SP -= 1
-}
-
-func (c *Cpu) stackPeek() byte {
-	return c.bus.Read(StackBase + uint16(c.SP+1))
-}
-
-func (c *Cpu) stackPop() byte {
-	c.SP += 1
-	return c.bus.Read(StackBase + uint16(c.SP))
-}
diff --git a/cpu_stack_test.go b/cpu_stack_test.go
deleted file mode 100644
index c9c5834..0000000
--- a/cpu_stack_test.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package i6502
-
-import (
-	"github.com/stretchr/testify/assert"
-	"testing"
-)
-
-func TestStackPushPopPeek(t *testing.T) {
-	assert := assert.New(t)
-	cpu, _, _ := NewRamMachine()
-
-	assert.Equal(0xFF, cpu.SP)
-
-	cpu.stackPush(0x42)
-	cpu.stackPush(0xA0)
-
-	assert.Equal(0xFD, cpu.SP)
-	assert.Equal(0x42, cpu.bus.Read(0x1FF))
-	assert.Equal(0xA0, cpu.bus.Read(0x1FE))
-
-	peekValue := cpu.stackPeek()
-	assert.Equal(0xFD, cpu.SP)
-	assert.Equal(0xA0, peekValue)
-
-	popValue := cpu.stackPop()
-	assert.Equal(0xFE, cpu.SP)
-	assert.Equal(0xA0, popValue)
-}
diff --git a/cpu_test.go b/cpu_test.go
index ffd6ec2..0bf88d3 100644
--- a/cpu_test.go
+++ b/cpu_test.go
@@ -35,18 +35,41 @@ func TestNewCpu(t *testing.T) {
 	assert.Nil(t, err)
 }
 
+func TestStackPushPopPeek(t *testing.T) {
+	assert := assert.New(t)
+	cpu, _, _ := NewRamMachine()
+
+	assert.Equal(0xFF, cpu.SP)
+
+	cpu.stackPush(0x42)
+	cpu.stackPush(0xA0)
+
+	assert.Equal(0xFD, cpu.SP)
+	assert.Equal(0x42, cpu.Bus.Read(0x1FF))
+	assert.Equal(0xA0, cpu.Bus.Read(0x1FE))
+
+	peekValue := cpu.stackPeek()
+	assert.Equal(0xFD, cpu.SP)
+	assert.Equal(0xA0, peekValue)
+
+	popValue := cpu.stackPop()
+	assert.Equal(0xFE, cpu.SP)
+	assert.Equal(0xA0, popValue)
+}
+
 func TestCpuAddressBus(t *testing.T) {
 	assert := assert.New(t)
 
-	cpu, _, _ := NewRamMachine()
-	assert.True(cpu.HasAddressBus())
+	cpu, bus, _ := NewRamMachine()
+	assert.Equal(cpu.Bus, bus)
+	assert.NotNil(cpu.Bus)
 }
 
 func TestCpuReset(t *testing.T) {
 	assert := assert.New(t)
 
 	cpu, _, _ := NewRamMachine()
-	cpu.bus.Write16(0xFFFC, 0x1234)
+	cpu.Bus.Write16(0xFFFC, 0x1234)
 
 	cpu.Reset()
 
@@ -61,7 +84,7 @@ func TestCpuReset(t *testing.T) {
 func TestCpuInterrupt(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 
-	cpu.bus.Write16(0xFFFE, 0x1234) // Write the IRQ vector
+	cpu.Bus.Write16(0xFFFE, 0x1234) // Write the IRQ vector
 	cpu.setIrqDisable(false)        // Enable interrupts
 	cpu.SP = 0xFF                   // Set the stack pointer
 	cpu.PC = 0x0380                 // Some fake point of execution
@@ -74,9 +97,9 @@ func TestCpuInterrupt(t *testing.T) {
 	cpu.Interrupt()
 
 	assert.Equal(t, 0x1234, cpu.PC)
-	assert.Equal(t, 0x03, cpu.bus.Read(0x01FF))
-	assert.Equal(t, 0x80, cpu.bus.Read(0x01FE))
-	assert.Equal(t, status, cpu.bus.Read(0x01FD))
+	assert.Equal(t, 0x03, cpu.Bus.Read(0x01FF))
+	assert.Equal(t, 0x80, cpu.Bus.Read(0x01FE))
+	assert.Equal(t, status, cpu.Bus.Read(0x01FD))
 	assert.True(t, cpu.getIrqDisable())
 }
 
@@ -137,9 +160,9 @@ func TestCLC(t *testing.T) {
 	cpu.LoadProgram([]byte{0x18}, 0x0300)
 	cpu.setCarry(true)
 
-	assert.True(t, cpu.getStatus(sCarry))
+	assert.True(t, cpu.getCarry())
 	cpu.Step()
-	assert.False(t, cpu.getStatus(sCarry))
+	assert.False(t, cpu.getCarry())
 }
 
 func TestCLD(t *testing.T) {
@@ -183,7 +206,7 @@ func TestADCImmediate(t *testing.T) {
 
 	assert.Equal(t, 0x0302, cpu.PC)
 	assert.Equal(t, 0x95, cpu.A)
-	assert.False(t, cpu.getStatus(sCarry))
+	assert.False(t, cpu.getCarry())
 }
 
 func TestADCWithCarry(t *testing.T) {
@@ -195,21 +218,21 @@ func TestADCWithCarry(t *testing.T) {
 
 	assert.Equal(t, 0x0302, cpu.PC)
 	assert.Equal(t, 0x13, cpu.A)
-	assert.True(t, cpu.getStatus(sCarry))
+	assert.True(t, cpu.getCarry())
 }
 
 func TestADCWithCarryOver(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x69, 0x04}, 0x0300)
 
-	cpu.setStatus(sCarry, true)
+	cpu.setCarry(true)
 	cpu.A = 0x05
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
 	assert.Equal(t, 0x0A, cpu.A)
-	assert.False(t, cpu.getStatus(sCarry))
+	assert.False(t, cpu.getCarry())
 }
 
 func TestADCWithOverflow(t *testing.T) {
@@ -225,8 +248,8 @@ func TestADCWithOverflow(t *testing.T) {
 
 	assert.Equal(t, 0x0302, cpu.PC)
 	assert.Equal(t, 0x60, cpu.A)
-	assert.True(t, cpu.getStatus(sCarry))
-	assert.True(t, cpu.getStatus(sOverflow))
+	assert.True(t, cpu.getCarry())
+	assert.True(t, cpu.getOverflow())
 }
 
 func TestADCZero(t *testing.T) {
@@ -238,7 +261,7 @@ func TestADCZero(t *testing.T) {
 
 	assert.Equal(t, 0x0302, cpu.PC)
 	assert.Equal(t, 0x00, cpu.A)
-	assert.True(t, cpu.getStatus(sZero))
+	assert.True(t, cpu.getZero())
 }
 
 func TestADCNegative(t *testing.T) {
@@ -250,13 +273,13 @@ func TestADCNegative(t *testing.T) {
 
 	assert.Equal(t, 0x0302, cpu.PC)
 	assert.Equal(t, 0xF7, cpu.A)
-	assert.True(t, cpu.getStatus(sNegative))
+	assert.True(t, cpu.getNegative())
 }
 
 func TestADCDecimal(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x69, 0x28}, 0x0300)
-	cpu.setStatus(sDecimal, true)
+	cpu.setDecimal(true)
 	cpu.A = 0x19
 
 	cpu.Step()
@@ -269,7 +292,7 @@ func TestADCZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x65, 0x53}, 0x0300)
 	cpu.A = 0x42
-	cpu.bus.Write(0x53, 0x12)
+	cpu.Bus.Write(0x53, 0x12)
 
 	cpu.Step()
 
@@ -282,7 +305,7 @@ func TestADCZeropageX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x75, 0x53}, 0x0300)
 	cpu.A = 0x42
 	cpu.X = 0x01
-	cpu.bus.Write(0x54, 0x12)
+	cpu.Bus.Write(0x54, 0x12)
 
 	cpu.Step()
 
@@ -294,7 +317,7 @@ func TestADCAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x6D, 0x00, 0x80}, 0x0300)
 	cpu.A = 0x42
-	cpu.bus.Write(0x8000, 0x12)
+	cpu.Bus.Write(0x8000, 0x12)
 
 	cpu.Step()
 
@@ -307,7 +330,7 @@ func TestADCAbsoluteX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x7D, 0x00, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x12)
+	cpu.Bus.Write(0x8002, 0x12)
 
 	cpu.Step()
 
@@ -320,7 +343,7 @@ func TestADCAbsoluteY(t *testing.T) {
 	cpu.LoadProgram([]byte{0x79, 0x00, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.Y = 0x02
-	cpu.bus.Write(0x8002, 0x12)
+	cpu.Bus.Write(0x8002, 0x12)
 
 	cpu.Step()
 
@@ -333,8 +356,8 @@ func TestADCIndirectX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x61, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write16(0x82, 0xC000)
-	cpu.bus.Write(0xC000, 0x12)
+	cpu.Bus.Write16(0x82, 0xC000)
+	cpu.Bus.Write(0xC000, 0x12)
 
 	cpu.Step()
 
@@ -347,8 +370,8 @@ func TestADCIndirectY(t *testing.T) {
 	cpu.LoadProgram([]byte{0x71, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.Y = 0x02
-	cpu.bus.Write16(0x80, 0xC000)
-	cpu.bus.Write(0xC002, 0x12)
+	cpu.Bus.Write16(0x80, 0xC000)
+	cpu.Bus.Write(0xC002, 0x12)
 
 	cpu.Step()
 
@@ -368,7 +391,7 @@ func TestSBCImmediate(t *testing.T) {
 
 	assert.Equal(t, 0x0302, cpu.PC)
 	assert.Equal(t, 0x41, cpu.A)
-	assert.True(t, cpu.getStatus(sCarry))
+	assert.True(t, cpu.getCarry())
 }
 
 func TestSBCWithoutCarry(t *testing.T) {
@@ -381,7 +404,7 @@ func TestSBCWithoutCarry(t *testing.T) {
 
 	assert.Equal(t, 0x0302, cpu.PC)
 	assert.Equal(t, 0x40, cpu.A)
-	assert.True(t, cpu.getStatus(sCarry))
+	assert.True(t, cpu.getCarry())
 }
 
 func TestSBCNegativeNoCarry(t *testing.T) {
@@ -401,7 +424,7 @@ func TestSBCNegativeNoCarry(t *testing.T) {
 func TestSBCDecimal(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xE9, 0x03}, 0x0300)
-	cpu.setStatus(sDecimal, true)
+	cpu.setDecimal(true)
 	cpu.A = 0x32
 
 	cpu.Step()
@@ -428,7 +451,7 @@ func TestSBCZeropage(t *testing.T) {
 	cpu.LoadProgram([]byte{0xE5, 0x53}, 0x0300)
 	cpu.setCarry(true)
 	cpu.A = 0x42
-	cpu.bus.Write(0x53, 0x12)
+	cpu.Bus.Write(0x53, 0x12)
 
 	cpu.Step()
 
@@ -442,7 +465,7 @@ func TestZeropageX(t *testing.T) {
 	cpu.setCarry(true)
 	cpu.A = 0x42
 	cpu.X = 0x01
-	cpu.bus.Write(0x54, 0x12)
+	cpu.Bus.Write(0x54, 0x12)
 
 	cpu.Step()
 
@@ -455,7 +478,7 @@ func TestSBCAbsolute(t *testing.T) {
 	cpu.LoadProgram([]byte{0xED, 0x00, 0x80}, 0x0300)
 	cpu.setCarry(true)
 	cpu.A = 0x42
-	cpu.bus.Write(0x8000, 0x12)
+	cpu.Bus.Write(0x8000, 0x12)
 
 	cpu.Step()
 
@@ -469,7 +492,7 @@ func TestSBCAbsoluteX(t *testing.T) {
 	cpu.setCarry(true)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x12)
+	cpu.Bus.Write(0x8002, 0x12)
 
 	cpu.Step()
 
@@ -483,7 +506,7 @@ func TestSBCAbsoluteY(t *testing.T) {
 	cpu.setCarry(true)
 	cpu.A = 0x42
 	cpu.Y = 0x02
-	cpu.bus.Write(0x8002, 0x12)
+	cpu.Bus.Write(0x8002, 0x12)
 
 	cpu.Step()
 
@@ -497,8 +520,8 @@ func TestSBCIndirectX(t *testing.T) {
 	cpu.setCarry(true)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write16(0x82, 0xC000)
-	cpu.bus.Write(0xC000, 0x12)
+	cpu.Bus.Write16(0x82, 0xC000)
+	cpu.Bus.Write(0xC000, 0x12)
 
 	cpu.Step()
 
@@ -512,8 +535,8 @@ func TestSBCIndirectY(t *testing.T) {
 	cpu.setCarry(true)
 	cpu.A = 0x42
 	cpu.Y = 0x02
-	cpu.bus.Write16(0x80, 0xC000)
-	cpu.bus.Write(0xC002, 0x12)
+	cpu.Bus.Write16(0x80, 0xC000)
+	cpu.Bus.Write(0xC002, 0x12)
 
 	cpu.Step()
 
@@ -574,47 +597,47 @@ func TestINYRollover(t *testing.T) {
 func TestINCZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xE6, 0x42}, 0x0300)
-	cpu.bus.Write(0x42, 0x01)
+	cpu.Bus.Write(0x42, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x42))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x42))
 }
 
 func TestINCZeropageX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xF6, 0x42}, 0x0300)
 	cpu.X = 0x01
-	cpu.bus.Write(0x43, 0x01)
+	cpu.Bus.Write(0x43, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x43))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x43))
 }
 
 func TestINCAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xEE, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x01)
+	cpu.Bus.Write(0x8000, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x8000))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x8000))
 }
 
 func TestINCAbsoluteX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xFE, 0x00, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x01)
+	cpu.Bus.Write(0x8002, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x8002))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x8002))
 }
 
 //// DEX
@@ -670,47 +693,47 @@ func TestDEYRollover(t *testing.T) {
 func TestDECZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xC6, 0x42}, 0x0300)
-	cpu.bus.Write(0x42, 0x01)
+	cpu.Bus.Write(0x42, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x00, cpu.bus.Read(0x42))
+	assert.Equal(t, 0x00, cpu.Bus.Read(0x42))
 }
 
 func TestDECZeropageX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xD6, 0x42}, 0x0300)
 	cpu.X = 0x01
-	cpu.bus.Write(0x43, 0x01)
+	cpu.Bus.Write(0x43, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x00, cpu.bus.Read(0x43))
+	assert.Equal(t, 0x00, cpu.Bus.Read(0x43))
 }
 
 func TestDECAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xCE, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x01)
+	cpu.Bus.Write(0x8000, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x00, cpu.bus.Read(0x8000))
+	assert.Equal(t, 0x00, cpu.Bus.Read(0x8000))
 }
 
 func TestDECAbsoluteX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xDE, 0x00, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x01)
+	cpu.Bus.Write(0x8002, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x00, cpu.bus.Read(0x8002))
+	assert.Equal(t, 0x00, cpu.Bus.Read(0x8002))
 }
 
 //// LDA
@@ -750,7 +773,7 @@ func TestLDAZero(t *testing.T) {
 func TestLDAZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xA5, 0x42}, 0x0300)
-	cpu.bus.Write(0x42, 0xF8)
+	cpu.Bus.Write(0x42, 0xF8)
 
 	cpu.Step()
 
@@ -762,7 +785,7 @@ func TestLDAZeropageX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xB5, 0x41}, 0x0300)
 	cpu.X = 0x01
-	cpu.bus.Write(0x42, 0xF8)
+	cpu.Bus.Write(0x42, 0xF8)
 
 	cpu.Step()
 
@@ -773,7 +796,7 @@ func TestLDAZeropageX(t *testing.T) {
 func TestLDAAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xAD, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write16(0x8000, 0xF8)
+	cpu.Bus.Write16(0x8000, 0xF8)
 
 	cpu.Step()
 
@@ -785,7 +808,7 @@ func TestLDAAbsoluteX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xBD, 0x00, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write16(0x8002, 0xF8)
+	cpu.Bus.Write16(0x8002, 0xF8)
 
 	cpu.Step()
 
@@ -797,7 +820,7 @@ func TestLDAAbsoluteY(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xB9, 0x00, 0x80}, 0x0300)
 	cpu.Y = 0x02
-	cpu.bus.Write16(0x8002, 0xF8)
+	cpu.Bus.Write16(0x8002, 0xF8)
 
 	cpu.Step()
 
@@ -809,8 +832,8 @@ func TestLDAIndirectX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xA1, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write16(0x82, 0xC000)
-	cpu.bus.Write(0xC000, 0xF8)
+	cpu.Bus.Write16(0x82, 0xC000)
+	cpu.Bus.Write(0xC000, 0xF8)
 
 	cpu.Step()
 
@@ -822,8 +845,8 @@ func TestLDAIndirectY(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xB1, 0x80}, 0x0300)
 	cpu.Y = 0x02
-	cpu.bus.Write16(0x80, 0xC000)
-	cpu.bus.Write(0xC002, 0xF8)
+	cpu.Bus.Write16(0x80, 0xC000)
+	cpu.Bus.Write(0xC002, 0xF8)
 
 	cpu.Step()
 
@@ -868,7 +891,7 @@ func TestLDXZero(t *testing.T) {
 func TestLDXZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xA6, 0x42}, 0x0300)
-	cpu.bus.Write(0x42, 0xF8)
+	cpu.Bus.Write(0x42, 0xF8)
 
 	cpu.Step()
 
@@ -880,7 +903,7 @@ func TestLDXZeropageY(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xB6, 0x41}, 0x0300)
 	cpu.Y = 0x01
-	cpu.bus.Write(0x42, 0xF8)
+	cpu.Bus.Write(0x42, 0xF8)
 
 	cpu.Step()
 
@@ -891,7 +914,7 @@ func TestLDXZeropageY(t *testing.T) {
 func TestLDXAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xAE, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write16(0x8000, 0xF8)
+	cpu.Bus.Write16(0x8000, 0xF8)
 
 	cpu.Step()
 
@@ -903,7 +926,7 @@ func TestLDXAbsoluteY(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xBE, 0x00, 0x80}, 0x0300)
 	cpu.Y = 0x02
-	cpu.bus.Write16(0x8002, 0xF8)
+	cpu.Bus.Write16(0x8002, 0xF8)
 
 	cpu.Step()
 
@@ -948,7 +971,7 @@ func TestLDYZero(t *testing.T) {
 func TestLDYZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xA4, 0x42}, 0x0300)
-	cpu.bus.Write(0x42, 0xF8)
+	cpu.Bus.Write(0x42, 0xF8)
 
 	cpu.Step()
 
@@ -960,7 +983,7 @@ func TestLDYZeropageX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xB4, 0x41}, 0x0300)
 	cpu.X = 0x01
-	cpu.bus.Write(0x42, 0xF8)
+	cpu.Bus.Write(0x42, 0xF8)
 
 	cpu.Step()
 
@@ -971,7 +994,7 @@ func TestLDYZeropageX(t *testing.T) {
 func TestLDYAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xAC, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write16(0x8000, 0xF8)
+	cpu.Bus.Write16(0x8000, 0xF8)
 
 	cpu.Step()
 
@@ -983,7 +1006,7 @@ func TestLDYAbsoluteX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0xBC, 0x00, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write16(0x8002, 0xF8)
+	cpu.Bus.Write16(0x8002, 0xF8)
 
 	cpu.Step()
 
@@ -1032,7 +1055,7 @@ func TestORAZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x05, 0x42}, 0x0300)
 	cpu.A = 0xF0
-	cpu.bus.Write(0x0042, 0x02)
+	cpu.Bus.Write(0x0042, 0x02)
 
 	cpu.Step()
 
@@ -1045,7 +1068,7 @@ func TestORAZeropageX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x15, 0x40}, 0x0300)
 	cpu.A = 0xF0
 	cpu.X = 0x02
-	cpu.bus.Write(0x0042, 0x02)
+	cpu.Bus.Write(0x0042, 0x02)
 
 	cpu.Step()
 
@@ -1057,7 +1080,7 @@ func TestORAAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x0D, 0x00, 0x80}, 0x0300)
 	cpu.A = 0xF0
-	cpu.bus.Write(0x8000, 0x02)
+	cpu.Bus.Write(0x8000, 0x02)
 
 	cpu.Step()
 
@@ -1070,7 +1093,7 @@ func TestORAAbsoluteX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x1D, 0x00, 0x80}, 0x0300)
 	cpu.A = 0xF0
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x02)
+	cpu.Bus.Write(0x8002, 0x02)
 
 	cpu.Step()
 
@@ -1083,7 +1106,7 @@ func TestORAAbsoluteY(t *testing.T) {
 	cpu.LoadProgram([]byte{0x19, 0x00, 0x80}, 0x0300)
 	cpu.A = 0xF0
 	cpu.Y = 0x02
-	cpu.bus.Write(0x8002, 0x02)
+	cpu.Bus.Write(0x8002, 0x02)
 
 	cpu.Step()
 
@@ -1096,8 +1119,8 @@ func TestORAIndirectX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x01, 0x40}, 0x0300)
 	cpu.A = 0xF0
 	cpu.X = 0x02
-	cpu.bus.Write16(0x42, 0xC000)
-	cpu.bus.Write(0xC000, 0x02)
+	cpu.Bus.Write16(0x42, 0xC000)
+	cpu.Bus.Write(0xC000, 0x02)
 
 	cpu.Step()
 
@@ -1110,8 +1133,8 @@ func TestORAIndirectY(t *testing.T) {
 	cpu.LoadProgram([]byte{0x11, 0x40}, 0x0300)
 	cpu.A = 0xF0
 	cpu.Y = 0x02
-	cpu.bus.Write16(0x40, 0xC000)
-	cpu.bus.Write(0xC002, 0x02)
+	cpu.Bus.Write16(0x40, 0xC000)
+	cpu.Bus.Write(0xC002, 0x02)
 
 	cpu.Step()
 
@@ -1160,7 +1183,7 @@ func TestANDZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x25, 0x42}, 0x0300)
 	cpu.A = 0xE9
-	cpu.bus.Write(0x0042, 0x0f)
+	cpu.Bus.Write(0x0042, 0x0f)
 
 	cpu.Step()
 
@@ -1173,7 +1196,7 @@ func TestANDZeropageX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x35, 0x40}, 0x0300)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write(0x0042, 0x0F)
+	cpu.Bus.Write(0x0042, 0x0F)
 
 	cpu.Step()
 
@@ -1185,7 +1208,7 @@ func TestANDAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x2D, 0x00, 0x80}, 0x0300)
 	cpu.A = 0x42
-	cpu.bus.Write(0x8000, 0x0F)
+	cpu.Bus.Write(0x8000, 0x0F)
 
 	cpu.Step()
 
@@ -1198,7 +1221,7 @@ func TestANDAbsoluteX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x3D, 0x00, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x0F)
+	cpu.Bus.Write(0x8002, 0x0F)
 
 	cpu.Step()
 
@@ -1211,7 +1234,7 @@ func TestANDAbsoluteY(t *testing.T) {
 	cpu.LoadProgram([]byte{0x39, 0x00, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.Y = 0x02
-	cpu.bus.Write(0x8002, 0x0F)
+	cpu.Bus.Write(0x8002, 0x0F)
 
 	cpu.Step()
 
@@ -1224,8 +1247,8 @@ func TestANDIndirectX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x21, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write16(0x82, 0xC000)
-	cpu.bus.Write(0xC000, 0x0F)
+	cpu.Bus.Write16(0x82, 0xC000)
+	cpu.Bus.Write(0xC000, 0x0F)
 
 	cpu.Step()
 
@@ -1238,8 +1261,8 @@ func TestANDIndirectY(t *testing.T) {
 	cpu.LoadProgram([]byte{0x31, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.Y = 0x02
-	cpu.bus.Write16(0x80, 0xC000)
-	cpu.bus.Write(0xC002, 0x0F)
+	cpu.Bus.Write16(0x80, 0xC000)
+	cpu.Bus.Write(0xC002, 0x0F)
 
 	cpu.Step()
 
@@ -1288,7 +1311,7 @@ func TestEORZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x45, 0x80}, 0x0300)
 	cpu.A = 0x42
-	cpu.bus.Write(0x0080, 0x7f)
+	cpu.Bus.Write(0x0080, 0x7f)
 
 	cpu.Step()
 
@@ -1301,7 +1324,7 @@ func TestEORZeropageX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x55, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write(0x0082, 0x7F)
+	cpu.Bus.Write(0x0082, 0x7F)
 
 	cpu.Step()
 
@@ -1313,7 +1336,7 @@ func TestEORAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x4D, 0x00, 0x80}, 0x0300)
 	cpu.A = 0x42
-	cpu.bus.Write(0x8000, 0x7F)
+	cpu.Bus.Write(0x8000, 0x7F)
 
 	cpu.Step()
 
@@ -1326,7 +1349,7 @@ func TestEORAbsoluteX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x5D, 0x00, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x7F)
+	cpu.Bus.Write(0x8002, 0x7F)
 
 	cpu.Step()
 
@@ -1339,7 +1362,7 @@ func TestEORAbsoluteY(t *testing.T) {
 	cpu.LoadProgram([]byte{0x59, 0x00, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.Y = 0x02
-	cpu.bus.Write(0x8002, 0x7F)
+	cpu.Bus.Write(0x8002, 0x7F)
 
 	cpu.Step()
 
@@ -1352,8 +1375,8 @@ func TestEORIndirectX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x41, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write16(0x82, 0xC000)
-	cpu.bus.Write(0xC000, 0x7F)
+	cpu.Bus.Write16(0x82, 0xC000)
+	cpu.Bus.Write(0xC000, 0x7F)
 
 	cpu.Step()
 
@@ -1366,8 +1389,8 @@ func TestEORIndirectY(t *testing.T) {
 	cpu.LoadProgram([]byte{0x51, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.Y = 0x02
-	cpu.bus.Write16(0x80, 0xC000)
-	cpu.bus.Write(0xC002, 0x7F)
+	cpu.Bus.Write16(0x80, 0xC000)
+	cpu.Bus.Write(0xC002, 0x7F)
 
 	cpu.Step()
 
@@ -1385,7 +1408,7 @@ func TestSTAZeropage(t *testing.T) {
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x0080))
 }
 
 func TestSTAZeropageX(t *testing.T) {
@@ -1397,7 +1420,7 @@ func TestSTAZeropageX(t *testing.T) {
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x0082))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x0082))
 }
 
 func TestSTAAbsolute(t *testing.T) {
@@ -1408,7 +1431,7 @@ func TestSTAAbsolute(t *testing.T) {
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x8000))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x8000))
 }
 
 func TestSTAAbsoluteX(t *testing.T) {
@@ -1420,7 +1443,7 @@ func TestSTAAbsoluteX(t *testing.T) {
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x8002))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x8002))
 }
 
 func TestSTAAbsoluteY(t *testing.T) {
@@ -1428,12 +1451,12 @@ func TestSTAAbsoluteY(t *testing.T) {
 	cpu.LoadProgram([]byte{0x99, 0x00, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.Y = 0x02
-	cpu.bus.Write(0x8002, 0x7F)
+	cpu.Bus.Write(0x8002, 0x7F)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x8002))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x8002))
 }
 
 func TestSTAIndirectX(t *testing.T) {
@@ -1441,12 +1464,12 @@ func TestSTAIndirectX(t *testing.T) {
 	cpu.LoadProgram([]byte{0x81, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.X = 0x02
-	cpu.bus.Write16(0x82, 0xC000)
+	cpu.Bus.Write16(0x82, 0xC000)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0xC000))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0xC000))
 }
 
 func TestSTAIndirectY(t *testing.T) {
@@ -1454,12 +1477,12 @@ func TestSTAIndirectY(t *testing.T) {
 	cpu.LoadProgram([]byte{0x91, 0x80}, 0x0300)
 	cpu.A = 0x42
 	cpu.Y = 0x02
-	cpu.bus.Write16(0x80, 0xC000)
+	cpu.Bus.Write16(0x80, 0xC000)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0xC002))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0xC002))
 }
 
 //// STX
@@ -1472,7 +1495,7 @@ func TestSTXZeropage(t *testing.T) {
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x0080))
 }
 
 func TestSTXZeropageY(t *testing.T) {
@@ -1484,7 +1507,7 @@ func TestSTXZeropageY(t *testing.T) {
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x0082))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x0082))
 }
 
 func TestSTXAbsolute(t *testing.T) {
@@ -1495,7 +1518,7 @@ func TestSTXAbsolute(t *testing.T) {
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x8000))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x8000))
 }
 
 //// STY
@@ -1508,7 +1531,7 @@ func TestSTYZeropage(t *testing.T) {
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x0080))
 }
 
 func TestSTYZeropageX(t *testing.T) {
@@ -1520,7 +1543,7 @@ func TestSTYZeropageX(t *testing.T) {
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x0082))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x0082))
 }
 
 func TestSTYAbsolute(t *testing.T) {
@@ -1531,7 +1554,7 @@ func TestSTYAbsolute(t *testing.T) {
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x42, cpu.bus.Read(0x8000))
+	assert.Equal(t, 0x42, cpu.Bus.Read(0x8000))
 }
 
 //// TAX
@@ -1784,47 +1807,47 @@ func TestASLAccumulatorCarry(t *testing.T) {
 func TestASLzeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x06, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x01)
+	cpu.Bus.Write(0x0080, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x0080))
 }
 
 func TestASLzeropageNegative(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x06, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x40)
+	cpu.Bus.Write(0x0080, 0x40)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x80, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x80, cpu.Bus.Read(0x0080))
 	assert.True(t, cpu.getNegative())
 }
 
 func TestASLzeropageZero(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x06, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x80)
+	cpu.Bus.Write(0x0080, 0x80)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x00, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x00, cpu.Bus.Read(0x0080))
 	assert.True(t, cpu.getZero())
 }
 
 func TestASLzeropageCarry(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x06, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0xAA)
+	cpu.Bus.Write(0x0080, 0xAA)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x54, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x54, cpu.Bus.Read(0x0080))
 	assert.True(t, cpu.getCarry())
 }
 
@@ -1832,35 +1855,35 @@ func TestASLzeropageX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x16, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write(0x0082, 0x01)
+	cpu.Bus.Write(0x0082, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x0082))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x0082))
 }
 
 func TestASLabsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x0E, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x01)
+	cpu.Bus.Write(0x8000, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x8000))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x8000))
 }
 
 func TestASLabsoluteX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x1E, 0x00, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x01)
+	cpu.Bus.Write(0x8002, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x8002))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x8002))
 }
 
 //// LSR
@@ -1903,35 +1926,35 @@ func TestLSRAccumulatorCarry(t *testing.T) {
 func TestLSRzeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x46, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x02)
+	cpu.Bus.Write(0x0080, 0x02)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x01, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x01, cpu.Bus.Read(0x0080))
 }
 
 func TestLSRzeropageZero(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x46, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x01)
+	cpu.Bus.Write(0x0080, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x00, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x00, cpu.Bus.Read(0x0080))
 	assert.True(t, cpu.getZero())
 }
 
 func TestLSRzeropageCarry(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x46, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x01)
+	cpu.Bus.Write(0x0080, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x00, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x00, cpu.Bus.Read(0x0080))
 	assert.True(t, cpu.getCarry())
 }
 
@@ -1939,35 +1962,35 @@ func TestLSRzeropageX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x56, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write(0x0082, 0x04)
+	cpu.Bus.Write(0x0082, 0x04)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x0082))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x0082))
 }
 
 func TestLSRabsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x4E, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x04)
+	cpu.Bus.Write(0x8000, 0x04)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x8000))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x8000))
 }
 
 func TestLSRabsoluteX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x5E, 0x00, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x04)
+	cpu.Bus.Write(0x8002, 0x04)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x8002))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x8002))
 }
 
 //// ROL
@@ -2015,47 +2038,47 @@ func TestROLAccumulatorNegative(t *testing.T) {
 func TestROLZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x26, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x01)
+	cpu.Bus.Write(0x0080, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x0080))
 }
 
 func TestROLZeropageX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x36, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write(0x0082, 0x01)
+	cpu.Bus.Write(0x0082, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x0082))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x0082))
 }
 
 func TestROLAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x2E, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x01)
+	cpu.Bus.Write(0x8000, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x8000))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x8000))
 }
 
 func TestROLAbsoluteX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x3E, 0x00, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x01)
+	cpu.Bus.Write(0x8002, 0x01)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x02, cpu.bus.Read(0x8002))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x8002))
 }
 
 //// ROR
@@ -2103,47 +2126,47 @@ func TestRORAccumulatorNegative(t *testing.T) {
 func TestRORZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x66, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x02)
+	cpu.Bus.Write(0x0080, 0x02)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x01, cpu.bus.Read(0x0080))
+	assert.Equal(t, 0x01, cpu.Bus.Read(0x0080))
 }
 
 func TestRORZeropageX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x76, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write(0x0082, 0x02)
+	cpu.Bus.Write(0x0082, 0x02)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0302, cpu.PC)
-	assert.Equal(t, 0x01, cpu.bus.Read(0x0082))
+	assert.Equal(t, 0x01, cpu.Bus.Read(0x0082))
 }
 
 func TestRORAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x6E, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x02)
+	cpu.Bus.Write(0x8000, 0x02)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x01, cpu.bus.Read(0x8000))
+	assert.Equal(t, 0x01, cpu.Bus.Read(0x8000))
 }
 
 func TestRORAbsoluteX(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x7E, 0x00, 0x80}, 0x0300)
 	cpu.X = 0x02
-	cpu.bus.Write(0x8002, 0x02)
+	cpu.Bus.Write(0x8002, 0x02)
 
 	cpu.Step()
 
 	assert.Equal(t, 0x0303, cpu.PC)
-	assert.Equal(t, 0x01, cpu.bus.Read(0x8002))
+	assert.Equal(t, 0x01, cpu.Bus.Read(0x8002))
 }
 
 /// CMP
@@ -2187,7 +2210,7 @@ func TestCMPZeropage(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xC5, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x42)
+	cpu.Bus.Write(0x0080, 0x42)
 	cpu.A = 0x42
 	cpu.Step()
 
@@ -2198,7 +2221,7 @@ func TestCMPZeropage(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xC5, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x42)
+	cpu.Bus.Write(0x0080, 0x42)
 	cpu.A = 0x43
 	cpu.Step()
 
@@ -2209,7 +2232,7 @@ func TestCMPZeropage(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xC5, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x0A)
+	cpu.Bus.Write(0x0080, 0x0A)
 	cpu.A = 0x08
 	cpu.Step()
 
@@ -2224,7 +2247,7 @@ func TestCMPZeropageX(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xD5, 0x80}, 0x0300)
-	cpu.bus.Write(0x0082, 0x42)
+	cpu.Bus.Write(0x0082, 0x42)
 	cpu.X = 0x02
 	cpu.A = 0x42
 	cpu.Step()
@@ -2236,7 +2259,7 @@ func TestCMPZeropageX(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xD5, 0x80}, 0x0300)
-	cpu.bus.Write(0x0082, 0x42)
+	cpu.Bus.Write(0x0082, 0x42)
 	cpu.X = 0x02
 	cpu.A = 0x43
 	cpu.Step()
@@ -2248,7 +2271,7 @@ func TestCMPZeropageX(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xD5, 0x80}, 0x0300)
-	cpu.bus.Write(0x0082, 0x0A)
+	cpu.Bus.Write(0x0082, 0x0A)
 	cpu.X = 0x02
 	cpu.A = 0x08
 	cpu.Step()
@@ -2264,7 +2287,7 @@ func TestCMPAbsolute(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xCD, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x42)
+	cpu.Bus.Write(0x8000, 0x42)
 	cpu.A = 0x42
 	cpu.Step()
 
@@ -2275,7 +2298,7 @@ func TestCMPAbsolute(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xCD, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x42)
+	cpu.Bus.Write(0x8000, 0x42)
 	cpu.A = 0x43
 	cpu.Step()
 
@@ -2286,7 +2309,7 @@ func TestCMPAbsolute(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xCD, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x0A)
+	cpu.Bus.Write(0x8000, 0x0A)
 	cpu.A = 0x08
 	cpu.Step()
 
@@ -2301,7 +2324,7 @@ func TestCMPAbsoluteX(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xDD, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8002, 0x42)
+	cpu.Bus.Write(0x8002, 0x42)
 	cpu.X = 0x02
 	cpu.A = 0x42
 	cpu.Step()
@@ -2313,7 +2336,7 @@ func TestCMPAbsoluteX(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xDD, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8002, 0x42)
+	cpu.Bus.Write(0x8002, 0x42)
 	cpu.X = 0x02
 	cpu.A = 0x43
 	cpu.Step()
@@ -2325,7 +2348,7 @@ func TestCMPAbsoluteX(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xDD, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8002, 0x0A)
+	cpu.Bus.Write(0x8002, 0x0A)
 	cpu.X = 0x02
 	cpu.A = 0x08
 	cpu.Step()
@@ -2341,7 +2364,7 @@ func TestCMPAbsoluteY(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xD9, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8002, 0x42)
+	cpu.Bus.Write(0x8002, 0x42)
 	cpu.Y = 0x02
 	cpu.A = 0x42
 	cpu.Step()
@@ -2353,7 +2376,7 @@ func TestCMPAbsoluteY(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xD9, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8002, 0x42)
+	cpu.Bus.Write(0x8002, 0x42)
 	cpu.Y = 0x02
 	cpu.A = 0x43
 	cpu.Step()
@@ -2365,7 +2388,7 @@ func TestCMPAbsoluteY(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xD9, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8002, 0x0A)
+	cpu.Bus.Write(0x8002, 0x0A)
 	cpu.Y = 0x02
 	cpu.A = 0x08
 	cpu.Step()
@@ -2381,8 +2404,8 @@ func TestCMPIndirectX(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xC1, 0x80}, 0x0300)
-	cpu.bus.Write16(0x0082, 0xC000)
-	cpu.bus.Write(0xC000, 0x42)
+	cpu.Bus.Write16(0x0082, 0xC000)
+	cpu.Bus.Write(0xC000, 0x42)
 	cpu.X = 0x02
 	cpu.A = 0x42
 	cpu.Step()
@@ -2394,8 +2417,8 @@ func TestCMPIndirectX(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xC1, 0x80}, 0x0300)
-	cpu.bus.Write16(0x0082, 0xC000)
-	cpu.bus.Write(0xC000, 0x42)
+	cpu.Bus.Write16(0x0082, 0xC000)
+	cpu.Bus.Write(0xC000, 0x42)
 	cpu.X = 0x02
 	cpu.A = 0x43
 	cpu.Step()
@@ -2407,8 +2430,8 @@ func TestCMPIndirectX(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xC1, 0x80}, 0x0300)
-	cpu.bus.Write16(0x0082, 0xC000)
-	cpu.bus.Write(0xC000, 0x0A)
+	cpu.Bus.Write16(0x0082, 0xC000)
+	cpu.Bus.Write(0xC000, 0x0A)
 	cpu.X = 0x02
 	cpu.A = 0x08
 	cpu.Step()
@@ -2424,8 +2447,8 @@ func TestCMPIndirectY(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xD1, 0x80}, 0x0300)
-	cpu.bus.Write16(0x0080, 0xC000)
-	cpu.bus.Write(0xC002, 0x42)
+	cpu.Bus.Write16(0x0080, 0xC000)
+	cpu.Bus.Write(0xC002, 0x42)
 	cpu.Y = 0x02
 	cpu.A = 0x42
 	cpu.Step()
@@ -2437,8 +2460,8 @@ func TestCMPIndirectY(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xD1, 0x80}, 0x0300)
-	cpu.bus.Write16(0x0080, 0xC000)
-	cpu.bus.Write(0xC002, 0x42)
+	cpu.Bus.Write16(0x0080, 0xC000)
+	cpu.Bus.Write(0xC002, 0x42)
 	cpu.X = 0x02
 	cpu.A = 0x43
 	cpu.Step()
@@ -2450,8 +2473,8 @@ func TestCMPIndirectY(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xD1, 0x80}, 0x0300)
-	cpu.bus.Write16(0x0080, 0xC000)
-	cpu.bus.Write(0xC002, 0x0A)
+	cpu.Bus.Write16(0x0080, 0xC000)
+	cpu.Bus.Write(0xC002, 0x0A)
 	cpu.X = 0x02
 	cpu.A = 0x08
 	cpu.Step()
@@ -2503,7 +2526,7 @@ func TestCPXZeropage(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xE4, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x42)
+	cpu.Bus.Write(0x0080, 0x42)
 	cpu.X = 0x42
 	cpu.Step()
 
@@ -2514,7 +2537,7 @@ func TestCPXZeropage(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xE4, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x42)
+	cpu.Bus.Write(0x0080, 0x42)
 	cpu.X = 0x43
 	cpu.Step()
 
@@ -2525,7 +2548,7 @@ func TestCPXZeropage(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xE4, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x0A)
+	cpu.Bus.Write(0x0080, 0x0A)
 	cpu.X = 0x08
 	cpu.Step()
 
@@ -2540,7 +2563,7 @@ func TestCPXAbsolute(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xEC, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x42)
+	cpu.Bus.Write(0x8000, 0x42)
 	cpu.X = 0x42
 	cpu.Step()
 
@@ -2551,7 +2574,7 @@ func TestCPXAbsolute(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xEC, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x42)
+	cpu.Bus.Write(0x8000, 0x42)
 	cpu.X = 0x43
 	cpu.Step()
 
@@ -2562,7 +2585,7 @@ func TestCPXAbsolute(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xEC, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x0A)
+	cpu.Bus.Write(0x8000, 0x0A)
 	cpu.X = 0x08
 	cpu.Step()
 
@@ -2613,7 +2636,7 @@ func TestCPYZeropage(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xC4, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x42)
+	cpu.Bus.Write(0x0080, 0x42)
 	cpu.Y = 0x42
 	cpu.Step()
 
@@ -2624,7 +2647,7 @@ func TestCPYZeropage(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xC4, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x42)
+	cpu.Bus.Write(0x0080, 0x42)
 	cpu.Y = 0x43
 	cpu.Step()
 
@@ -2635,7 +2658,7 @@ func TestCPYZeropage(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xC4, 0x80}, 0x0300)
-	cpu.bus.Write(0x0080, 0x0A)
+	cpu.Bus.Write(0x0080, 0x0A)
 	cpu.Y = 0x08
 	cpu.Step()
 
@@ -2650,7 +2673,7 @@ func TestCPYAbsolute(t *testing.T) {
 
 	// Equality
 	cpu.LoadProgram([]byte{0xCC, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x42)
+	cpu.Bus.Write(0x8000, 0x42)
 	cpu.Y = 0x42
 	cpu.Step()
 
@@ -2661,7 +2684,7 @@ func TestCPYAbsolute(t *testing.T) {
 
 	// Greater Than
 	cpu.LoadProgram([]byte{0xCC, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x42)
+	cpu.Bus.Write(0x8000, 0x42)
 	cpu.Y = 0x43
 	cpu.Step()
 
@@ -2672,7 +2695,7 @@ func TestCPYAbsolute(t *testing.T) {
 
 	// Less Than
 	cpu.LoadProgram([]byte{0xCC, 0x00, 0x80}, 0x0300)
-	cpu.bus.Write(0x8000, 0x0A)
+	cpu.Bus.Write(0x8000, 0x0A)
 	cpu.Y = 0x08
 	cpu.Step()
 
@@ -2687,16 +2710,16 @@ func TestCPYAbsolute(t *testing.T) {
 func TestBRK(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x00}, 0x0300)
-	cpu.bus.Write16(IrqVector, 0x1234)
+	cpu.Bus.Write16(IrqVector, 0x1234)
 	cpu.SP = 0xFF
 	status := cpu.P
 
 	cpu.Step()
 
 	assert.Equal(t, 0x1234, cpu.PC)
-	assert.Equal(t, 0x03, cpu.bus.Read(0x01FF))
-	assert.Equal(t, 0x02, cpu.bus.Read(0x01FE))
-	assert.Equal(t, status, cpu.bus.Read(0x01FD))
+	assert.Equal(t, 0x03, cpu.Bus.Read(0x01FF))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x01FE))
+	assert.Equal(t, status, cpu.Bus.Read(0x01FD))
 	assert.True(t, cpu.getBreak())
 
 }
@@ -2978,9 +3001,9 @@ func TestBVS(t *testing.T) {
 func TestBITZeropage(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 
-	cpu.bus.Write(0x0000, 0xC0)
-	cpu.bus.Write(0x0010, 0x40)
-	cpu.bus.Write(0x0020, 0x80)
+	cpu.Bus.Write(0x0000, 0xC0)
+	cpu.Bus.Write(0x0010, 0x40)
+	cpu.Bus.Write(0x0020, 0x80)
 
 	cpu.LoadProgram([]byte{0x24, 0x00}, 0x0300)
 	cpu.A = 0x01
@@ -3021,9 +3044,9 @@ func TestBITZeropage(t *testing.T) {
 func TestBITAbsolute(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 
-	cpu.bus.Write(0xC000, 0xC0)
-	cpu.bus.Write(0xC010, 0x40)
-	cpu.bus.Write(0xC020, 0x80)
+	cpu.Bus.Write(0xC000, 0xC0)
+	cpu.Bus.Write(0xC010, 0x40)
+	cpu.Bus.Write(0xC020, 0x80)
 
 	cpu.LoadProgram([]byte{0x2C, 0x00, 0xC0}, 0x0300)
 	cpu.A = 0x01
@@ -3073,7 +3096,7 @@ func TestPHP(t *testing.T) {
 
 	assert.Equal(t, 0x0301, cpu.PC)
 	assert.Equal(t, 0xFE, cpu.SP)
-	assert.Equal(t, 0xB5, cpu.bus.Read(0x01FF))
+	assert.Equal(t, 0xB5, cpu.Bus.Read(0x01FF))
 }
 
 //// PLP
@@ -3103,7 +3126,7 @@ func TestPHA(t *testing.T) {
 
 	assert.Equal(t, 0x0301, cpu.PC)
 	assert.Equal(t, 0xFE, cpu.SP)
-	assert.Equal(t, 0xB5, cpu.bus.Read(0x01FF))
+	assert.Equal(t, 0xB5, cpu.Bus.Read(0x01FF))
 }
 
 //// PLP
@@ -3150,7 +3173,7 @@ func TestJMPAbsolute(t *testing.T) {
 func TestJMPIndirect(t *testing.T) {
 	cpu, _, _ := NewRamMachine()
 	cpu.LoadProgram([]byte{0x6C, 0x00, 0xC0}, 0x0300)
-	cpu.bus.Write16(0xC000, 0x1234)
+	cpu.Bus.Write16(0xC000, 0x1234)
 
 	cpu.Step()
 
@@ -3170,8 +3193,8 @@ func TestJSR(t *testing.T) {
 	assert.Equal(t, 0xFD, cpu.SP)
 
 	// We expect PC - 1 (e.g. 3rd byte of JSR) to be on the stack
-	assert.Equal(t, 0x03, cpu.bus.Read(0x1FF))
-	assert.Equal(t, 0x02, cpu.bus.Read(0x1FE))
+	assert.Equal(t, 0x03, cpu.Bus.Read(0x1FF))
+	assert.Equal(t, 0x02, cpu.Bus.Read(0x1FE))
 }
 
 //// RTS
diff --git a/instruction.go b/instruction.go
index 061eb9b..f4ae53d 100644
--- a/instruction.go
+++ b/instruction.go
@@ -30,24 +30,3 @@ func (i Instruction) String() (output string) {
 
 	return
 }
-
-func (c *Cpu) readNextInstruction() Instruction {
-	// Read the opcode
-	opcode := c.bus.Read(c.PC)
-
-	optype, ok := opTypes[opcode]
-	if !ok {
-		panic(fmt.Sprintf("Unknown or unimplemented opcode 0x%02X\n%s", opcode, c.String()))
-	}
-
-	instruction := Instruction{OpType: optype, Address: c.PC}
-	switch instruction.Size {
-	case 1: // Zero operand instruction
-	case 2: // 8-bit operand
-		instruction.Op8 = c.bus.Read(c.PC + 1)
-	case 3: // 16-bit operand
-		instruction.Op16 = c.bus.Read16(c.PC + 1)
-	}
-
-	return instruction
-}
diff --git a/opcodes.go b/opcodes.go
index b4e2276..3cbfab9 100644
--- a/opcodes.go
+++ b/opcodes.go
@@ -1,5 +1,40 @@
 package i6502
 
+// Addressing modes
+const (
+	_ = iota
+	absolute
+	absoluteX
+	absoluteY
+	accumulator
+	immediate
+	implied
+	indirect
+	indirectX
+	indirectY
+	relative
+	zeropage
+	zeropageX
+	zeropageY
+)
+
+var addressingNames = [...]string{
+	"",
+	"absolute",
+	"absoluteX",
+	"absoluteY",
+	"accumulator",
+	"immediate",
+	"implied",
+	"(indirect)",
+	"(indirect,X)",
+	"(indirect),Y",
+	"relative",
+	"zeropage",
+	"zeropageX",
+	"zeropageY",
+}
+
 // OpCode table
 const (
 	_ = iota