From c16b34f14a84e4556d5c25f1f59e5ae2cbe4b133 Mon Sep 17 00:00:00 2001
From: Stefan Arentz <stefan@arentz.ca>
Date: Tue, 13 Jan 2015 19:42:14 -0500
Subject: [PATCH] Initial import

---
 Makefile |   18 +
 cpu.c    |  340 +++++++++++++++++
 cpu.h    |   76 ++++
 ewm.c    |   80 ++++
 ins.c    | 1092 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ins.h    |   38 ++
 mem.c    |  162 ++++++++
 mem.h    |   62 ++++
 pia.c    |  119 ++++++
 pia.h    |   42 +++
 10 files changed, 2029 insertions(+)
 create mode 100644 Makefile
 create mode 100644 cpu.c
 create mode 100644 cpu.h
 create mode 100644 ewm.c
 create mode 100644 ins.c
 create mode 100644 ins.h
 create mode 100644 mem.c
 create mode 100644 mem.h
 create mode 100644 pia.c
 create mode 100644 pia.h

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..eca4483
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,18 @@
+
+CC=clang
+CFLAGS=-O3 -std=c11 -Werror -Wall -Wshadow -Wpointer-arith -Wcast-qual -Wstrict-prototypes -Wmissing-prototypes
+SOURCES=cpu.c ins.c pia.c mem.c ewm.c
+OBJECTS=$(SOURCES:.c=.o)
+LIBS=-lcurses
+EXECUTABLE=ewm
+
+all: $(SOURCES) $(EXECUTABLE)
+
+clean:
+	rm -f $(OBJECTS) $(EXECUTABLE)
+
+$(EXECUTABLE): $(OBJECTS)
+	$(CC) $(LDFLAGS) $(OBJECTS) $(LIBS) -o $@
+
+.c.o:
+	$(CC) $(CFLAGS) $< -c -o $@
diff --git a/cpu.c b/cpu.c
new file mode 100644
index 0000000..daddf78
--- /dev/null
+++ b/cpu.c
@@ -0,0 +1,340 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Stefan Arentz - http://github.com/st3fan/ewm
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+
+#include "cpu.h"
+#include "ins.h"
+
+/* Private API */
+
+typedef void (*cpu_instruction_handler_t)(struct cpu_t *cpu);
+typedef void (*cpu_instruction_handler_byte_t)(struct cpu_t *cpu, uint8_t oper);
+typedef void (*cpu_instruction_handler_word_t)(struct cpu_t *cpu, uint16_t oper);
+
+static uint8_t _mem_get_byte(struct cpu_t *cpu, uint16_t addr) {
+   return cpu->memory[addr];
+}
+
+static uint16_t _mem_get_word(struct cpu_t *cpu, uint16_t addr) {
+   return *((uint16_t*) &cpu->memory[addr]);
+}
+
+#if 1
+static void cpu_format_instruction(struct cpu_t *cpu, char *buffer) {
+   *buffer = 0x00;
+
+   cpu_instruction_t *i = &instructions[cpu->memory[cpu->state.pc]];
+   uint8_t opcode = cpu->memory[cpu->state.pc];
+
+   /* Single byte instructions */
+   if (i->bytes == 1) {
+      sprintf(buffer, "%s", i->name);
+   }
+
+   /* JSR is the only exception */
+   else if (opcode == 0x20) {
+      sprintf(buffer, "%s $%.4X", i->name, _mem_get_word(cpu, cpu->state.pc+1));
+   }
+
+   /* Branches */
+   else if ((opcode & 0b00011111) == 0b00010000) {
+      int8_t offset = (int8_t) _mem_get_byte(cpu, cpu->state.pc+1);
+      uint16_t addr = cpu->state.pc + 2 + offset;
+      sprintf(buffer, "%s $%.4X", i->name, addr);
+   }
+
+   else if ((opcode & 0b00000011) == 0b00000001) {
+      switch ((opcode & 0b00011100) >> 2) {
+         case 0b000:
+            sprintf(buffer, "%s ($%.2X,X)", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b001:
+            sprintf(buffer, "%s $%.2X", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b010:
+            sprintf(buffer, "%s #$%.2X", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b011:
+            sprintf(buffer, "%s $%.2X%.2X", i->name, cpu->memory[cpu->state.pc+2], cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b100:
+            sprintf(buffer, "%s ($%.2X),Y", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b101:
+            sprintf(buffer, "%s $%.2X,X", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b110:
+            sprintf(buffer, "%s $%.2X%.2X,Y", i->name, cpu->memory[cpu->state.pc+2], cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b111:
+            sprintf(buffer, "%s $%.2X%.2X,X", i->name, cpu->memory[cpu->state.pc+2], cpu->memory[cpu->state.pc+1]);
+            break;
+      }
+   }
+
+   else if ((opcode & 0b00000011) == 0b00000010) {
+      switch ((opcode & 0b00011100) >> 2) {
+         case 0b000:
+            sprintf(buffer, "%s #$%.2X", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b001:
+            sprintf(buffer, "%s $%.2X", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b010:
+            sprintf(buffer, "%s", i->name);
+            break;
+         case 0b011:
+            sprintf(buffer, "%s $%.2X%.2X", i->name, cpu->memory[cpu->state.pc+2], cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b101:
+            sprintf(buffer, "%s $%.2X,X", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b111:
+            sprintf(buffer, "%s $%.2X%.2X,X", i->name, cpu->memory[cpu->state.pc+2], cpu->memory[cpu->state.pc+1]);
+            break;
+      }
+   }
+
+   else if ((opcode & 0b00000011) == 0b00000000) {
+      switch ((opcode & 0b00011100) >> 2) {
+         case 0b000:
+            sprintf(buffer, "%s #$%.2X", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b001:
+            sprintf(buffer, "%s $%.2X", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b011:
+            sprintf(buffer, "%s $%.2X%.2X", i->name, cpu->memory[cpu->state.pc+2], cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b101:
+            sprintf(buffer, "%s $%.2X,X", i->name, cpu->memory[cpu->state.pc+1]);
+            break;
+         case 0b111:
+            sprintf(buffer, "%s $%.2X%.2X,X", i->name, cpu->memory[cpu->state.pc+2], cpu->memory[cpu->state.pc+1]);
+            break;
+      }
+   }
+}
+
+static void cpu_format_state(struct cpu_t *cpu, char *buffer) {
+   sprintf(buffer, "A=%.2X X=%.2X Y=%.2X S=%.2X SP=%.4X %c%c%c%c%c%c%c%c",
+           cpu->state.a, cpu->state.x, cpu->state.y, cpu->state.s, cpu->state.sp,
+
+           cpu->state.n ? 'N' : '-',
+           cpu->state.v ? 'V' : '-',
+           '-',
+           cpu->state.b ? 'B' : '-',
+           cpu->state.d ? 'D' : '-',
+           cpu->state.i ? 'I' : '-',
+           cpu->state.z ? 'Z' : '-',
+           cpu->state.c ? 'C' : '-');
+}
+
+static void cpu_format_stack(struct cpu_t *cpu, char *buffer) {
+   *buffer = 0x00;
+   for (uint16_t sp = cpu->state.sp; sp != 0x01ff; sp++) {
+      char tmp[8];
+      sprintf(tmp, " %.2X", _mem_get_byte(cpu, sp));
+      buffer = strcat(buffer, tmp);
+   }
+}
+#endif
+
+static mach_timebase_info_data_t timebase_info;
+
+static uint64_t abs_to_nanos(uint64_t abs) {
+   return abs * timebase_info.numer  / timebase_info.denom;
+}
+
+static uint64_t nanos_to_abs(uint64_t nanos) {
+   return nanos * timebase_info.denom / timebase_info.numer;
+}
+
+static int cpu_execute_instruction(struct cpu_t *cpu) {
+
+
+   /* Trace code - Refactor into its own function or module */
+   char trace_instruction[256];
+   char trace_state[256];
+   char trace_stack[256];
+
+   if (cpu->trace) {
+      cpu_format_instruction(cpu, trace_instruction);
+   }
+
+
+   uint64_t start_time = mach_absolute_time();
+
+   /* Fetch instruction */
+   cpu_instruction_t *i = &instructions[cpu->memory[cpu->state.pc]];
+
+   /* Remember the PC since some instructions modify it */
+   uint16_t pc = cpu->state.pc;
+
+   /* Advance PC */
+   if (pc == cpu->state.pc) {
+      cpu->state.pc += i->bytes;
+   }
+
+   /* Execute instruction */
+   switch (i->bytes) {
+      case 1:
+         ((cpu_instruction_handler_t) i->handler)(cpu);
+         break;
+      case 2:
+         ((cpu_instruction_handler_byte_t) i->handler)(cpu, _mem_get_byte(cpu, pc+1));
+         break;
+      case 3:
+         ((cpu_instruction_handler_word_t) i->handler)(cpu, _mem_get_word(cpu, pc+1));
+         break;
+   }
+
+
+   if (cpu->trace) {
+      cpu_format_state(cpu, trace_state);
+      cpu_format_stack(cpu, trace_stack); // TODO: This crashes on the hello world test
+
+      switch (i->bytes) {
+         case 1:
+            fprintf(stderr, "CPU: %.4X %-20s | %.2X           %-20s  STACK: %s\n",
+                    pc, trace_instruction, cpu->memory[pc], trace_state, trace_stack);
+            break;
+         case 2:
+            fprintf(stderr, "CPU: %.4X %-20s | %.2X %.2X        %-20s  STACK: %s\n",
+                    pc, trace_instruction, cpu->memory[pc], cpu->memory[pc+1], trace_state, trace_stack);
+            break;
+         case 3:
+            fprintf(stderr, "CPU: %.4X %-20s | %.2X %.2X %.2X     %-20s  STACK: %s\n",
+                    pc, trace_instruction, cpu->memory[pc], cpu->memory[pc+1], cpu->memory[pc+2], trace_state, trace_stack);
+            break;
+      }
+   }
+
+
+
+
+
+
+   /* Delay */
+
+   if (timebase_info.denom == 0) {
+      (void) mach_timebase_info(&timebase_info);
+   }
+
+   uint64_t now = mach_absolute_time();
+
+   uint64_t elapsed_nano = abs_to_nanos(now - start_time);
+   uint64_t expected_duration = (i->cycles * (1000000000 / 960000));
+   uint64_t delay_nano = expected_duration - elapsed_nano;
+
+   //fprintf(stderr, "Expected: %" PRId64 " Elapsed: %" PRId64 " Delay: %" PRId64 "\n", expected_duration, elapsed_nano, delay_nano);
+
+   mach_wait_until(now + nanos_to_abs(delay_nano));
+
+   return i->opcode;
+}
+
+static void iom_init(struct iom_t *iom, uint16_t start, uint16_t length, void *obj, iom_read_handler_t read_handler, iom_write_handler_t write_handler) {
+   memset(iom, 0x00, sizeof(struct iom_t));
+   iom->start = start;
+   iom->length = length;
+   iom->obj = obj;
+   iom->read_handler = read_handler;
+   iom->write_handler = write_handler;
+}
+
+/* Public API */
+
+void cpu_init(struct cpu_t *cpu) {
+   memset(cpu, 0x00, sizeof(struct cpu_t));
+   cpu->memory = malloc(64 * 1024);
+}
+
+void cpu_add_ram(struct cpu_t *cpu, uint16_t start, uint16_t length, uint8_t *data) {
+   if (data != NULL) {
+      memcpy(cpu->memory + start, data, length);
+   }
+   /* TODO: Mark pages as RAM */
+}
+
+void cpu_add_rom(struct cpu_t *cpu, uint16_t start, uint16_t length, uint8_t *data) {
+   if (data != NULL) {
+      memcpy(cpu->memory + start, data, length);
+   }
+   /* TODO: Mark pages as ROM */
+}
+
+void cpu_add_iom(struct cpu_t *cpu, uint16_t start, uint16_t length, void *obj, iom_read_handler_t read_handler, iom_write_handler_t write_handler) {
+   struct iom_t *iom = (struct iom_t*) malloc(sizeof(struct iom_t));
+   iom_init(iom, start, length, obj, read_handler, write_handler);
+   iom->next = (struct iom_t*) cpu->iom;
+   cpu->iom = iom;
+   /* TODO: Mark pages as IO */
+}
+
+void cpu_trace(struct cpu_t *cpu, uint8_t trace) {
+   cpu->trace = trace;
+}
+
+void cpu_reset(struct cpu_t *cpu) {
+   cpu->state.pc = _mem_get_word(cpu, 0xfffc);
+   cpu->state.sp = 0x01ff;
+}
+
+void cpu_brk(struct cpu_t *cpu) {
+
+}
+
+void cpu_irq(struct cpu_t *cpu) {
+   /* TODO: Implement support for IRQ triggering */
+}
+
+void cpu_nmi(struct cpu_t *cpu) {
+   /* TODO: Implement support for interrupt triggering */
+}
+
+void cpu_run(struct cpu_t *cpu) {
+   uint64_t instruction_count = 0;
+   while (cpu_execute_instruction(cpu) != 0x00) {
+      /* TODO: Tick? */
+      instruction_count++;
+   }
+   fprintf(stderr, "Executed %" PRId64 " instructions\n", instruction_count);
+}
+
+void cpu_boot(struct cpu_t *cpu) {
+   cpu_reset(cpu);
+   cpu_run(cpu);
+}
+
+void cpu_step(struct cpu_t *cpu) {
+   cpu_execute_instruction(cpu);
+}
diff --git a/cpu.h b/cpu.h
new file mode 100644
index 0000000..67682fa
--- /dev/null
+++ b/cpu.h
@@ -0,0 +1,76 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Stefan Arentz - http://github.com/st3fan/ewm
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef CPU_H
+#define CPU_H
+
+#include <stdint.h>
+
+struct iom_t {
+  uint16_t start;
+  uint16_t length;
+  void *obj;
+  void *read_handler;
+  void *write_handler;
+  struct iom_t *next;
+};
+
+struct cpu_state_t {
+  uint8_t a, x, y, s;
+  uint16_t sp;
+  uint16_t pc;
+  uint8_t n, v, b, d, i, z, c;
+};
+
+struct cpu_t {
+  struct cpu_state_t state;
+  uint8_t *memory;
+  uint8_t trace;
+  struct iom_t *iom;
+};
+
+typedef uint8_t (*iom_read_handler_t)(struct cpu_t *cpu, void *obj, uint16_t addr);
+typedef void (*iom_write_handler_t)(struct cpu_t *cpu, void *obj, uint16_t addr, uint8_t b);
+
+void cpu_init(struct cpu_t *cpu);
+void cpu_add_ram(struct cpu_t *cpu, uint16_t start, uint16_t length, uint8_t *data);
+void cpu_add_rom(struct cpu_t *cpu, uint16_t start, uint16_t length, uint8_t *data);
+void cpu_add_iom(struct cpu_t *cpu, uint16_t start, uint16_t length, void *obj, iom_read_handler_t read_handler, iom_write_handler_t write_handler);
+
+void cpu_trace(struct cpu_t *cpu, uint8_t trace);
+
+void cpu_reset(struct cpu_t *cpu);
+void cpu_brk(struct cpu_t *cpu);
+void cpu_irq(struct cpu_t *cpu);
+void cpu_nmi(struct cpu_t *cpu);
+
+void cpu_run(struct cpu_t *cpu);
+void cpu_boot(struct cpu_t *cpu);
+void cpu_step(struct cpu_t *cpu);
+
+uint16_t cpu_memory_get_word(struct cpu_t *cpu, uint16_t addr);
+uint8_t cpu_memory_get_byte(struct cpu_t *cpu, uint16_t addr);
+
+void cpu_memory_set_word(struct cpu_t *cpu, uint16_t addr, uint16_t v);
+void cpu_memory_set_byte(struct cpu_t *cpu, uint16_t addr, uint8_t v);
+
+#endif
diff --git a/ewm.c b/ewm.c
new file mode 100644
index 0000000..09c829f
--- /dev/null
+++ b/ewm.c
@@ -0,0 +1,80 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Stefan Arentz - http://github.com/st3fan/ewm
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "cpu.h"
+#include "mem.h"
+#include "pia.h"
+
+static uint8_t monitor[256] = {
+    0xD8, 0x58, 0xA0, 0x7F, 0x8C, 0x12, 0xD0, 0xA9,
+    0xA7, 0x8D, 0x11, 0xD0, 0x8D, 0x13, 0xD0, 0xC9,
+    0xDF, 0xF0, 0x13, 0xC9, 0x9B, 0xF0, 0x03, 0xC8,
+    0x10, 0x0F, 0xA9, 0xDC, 0x20, 0xEF, 0xFF, 0xA9,
+    0x8D, 0x20, 0xEF, 0xFF, 0xA0, 0x01, 0x88, 0x30,
+    0xF6, 0xAD, 0x11, 0xD0, 0x10, 0xFB, 0xAD, 0x10,
+    0xD0, 0x99, 0x00, 0x02, 0x20, 0xEF, 0xFF, 0xC9,
+    0x8D, 0xD0, 0xD4, 0xA0, 0xFF, 0xA9, 0x00, 0xAA,
+    0x0A, 0x85, 0x2B, 0xC8, 0xB9, 0x00, 0x02, 0xC9,
+    0x8D, 0xF0, 0xD4, 0xC9, 0xAE, 0x90, 0xF4, 0xF0,
+    0xF0, 0xC9, 0xBA, 0xF0, 0xEB, 0xC9, 0xD2, 0xF0,
+    0x3B, 0x86, 0x28, 0x86, 0x29, 0x84, 0x2A, 0xB9,
+    0x00, 0x02, 0x49, 0xB0, 0xC9, 0x0A, 0x90, 0x06,
+    0x69, 0x88, 0xC9, 0xFA, 0x90, 0x11, 0x0A, 0x0A,
+    0x0A, 0x0A, 0xA2, 0x04, 0x0A, 0x26, 0x28, 0x26,
+    0x29, 0xCA, 0xD0, 0xF8, 0xC8, 0xD0, 0xE0, 0xC4,
+    0x2A, 0xF0, 0x97, 0x24, 0x2B, 0x50, 0x10, 0xA5,
+    0x28, 0x81, 0x26, 0xE6, 0x26, 0xD0, 0xB5, 0xE6,
+    0x27, 0x4C, 0x44, 0xFF, 0x6C, 0x24, 0x00, 0x30,
+    0x2B, 0xA2, 0x02, 0xB5, 0x27, 0x95, 0x25, 0x95,
+    0x23, 0xCA, 0xD0, 0xF7, 0xD0, 0x14, 0xA9, 0x8D,
+    0x20, 0xEF, 0xFF, 0xA5, 0x25, 0x20, 0xDC, 0xFF,
+    0xA5, 0x24, 0x20, 0xDC, 0xFF, 0xA9, 0xBA, 0x20,
+    0xEF, 0xFF, 0xA9, 0xA0, 0x20, 0xEF, 0xFF, 0xA1,
+    0x24, 0x20, 0xDC, 0xFF, 0x86, 0x2B, 0xA5, 0x24,
+    0xC5, 0x28, 0xA5, 0x25, 0xE5, 0x29, 0xB0, 0xC1,
+    0xE6, 0x24, 0xD0, 0x02, 0xE6, 0x25, 0xA5, 0x24,
+    0x29, 0x07, 0x10, 0xC8, 0x48, 0x4A, 0x4A, 0x4A,
+    0x4A, 0x20, 0xE5, 0xFF, 0x68, 0x29, 0x0F, 0x09,
+    0xB0, 0xC9, 0xBA, 0x90, 0x02, 0x69, 0x06, 0x2C,
+    0x12, 0xD0, 0x30, 0xFB, 0x8D, 0x12, 0xD0, 0x60,
+    0x00, 0x00, 0x00, 0x0F, 0x00, 0xFF, 0x00, 0x00
+};
+
+int main(int argc, char **argv) {
+  struct pia_t pia;
+  pia_init(&pia);
+  pia_trace(&pia, 0);
+
+  struct cpu_t cpu;
+  cpu_init(&cpu);
+  cpu_add_ram(&cpu, 0x0000, 0x4000, NULL);
+  cpu_add_iom(&cpu, 0xd000, 0x1000, &pia, pia_read, pia_write);
+  cpu_add_rom(&cpu, 0xff00, 0x0100, monitor);
+  cpu_trace(&cpu, 0);
+  cpu_boot(&cpu);
+
+  return 0;
+}
diff --git a/ins.c b/ins.c
new file mode 100644
index 0000000..ea617ac
--- /dev/null
+++ b/ins.c
@@ -0,0 +1,1092 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Stefan Arentz - http://github.com/st3fan/ewm
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ins.h"
+#include "cpu.h"
+#include "mem.h"
+
+static void update_zn(struct cpu_t *cpu, uint8_t v) {
+  cpu->state.z = (v == 0x00);
+  cpu->state.n = (v & 0x80);
+}
+
+/* ADC */
+
+static void adc(struct cpu_t *cpu, uint8_t m) {
+  uint16_t t = (uint16_t)cpu->state.a + (uint16_t)m + (uint16_t)(cpu->state.c ? 1 : 0);
+  uint8_t r = (uint8_t) (t & 0xff);
+  cpu->state.c = (t & 0x0100) != 0;
+  cpu->state.v = (cpu->state.a^r) & (m^r) & 0x80;
+  cpu->state.a = r;
+  update_zn(cpu, cpu->state.a);
+}
+
+static void adc_imm(struct cpu_t *cpu, uint8_t oper) {
+  adc(cpu, oper);
+}
+
+static void adc_zpg(struct cpu_t *cpu, uint8_t oper) {
+  adc(cpu, mem_get_byte_zpg(cpu, oper));
+}
+
+static void adc_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  adc(cpu, mem_get_byte_zpgx(cpu, oper));
+}
+
+static void adc_abs(struct cpu_t *cpu, uint16_t oper) {
+  adc(cpu, mem_get_byte_abs(cpu, oper));
+}
+
+static void adc_absx(struct cpu_t *cpu, uint16_t oper) {
+  adc(cpu, mem_get_byte_absx(cpu, oper));
+}
+
+static void adc_absy(struct cpu_t *cpu, uint16_t oper) {
+  adc(cpu, mem_get_byte_absy(cpu, oper));
+}
+
+static void adc_indx(struct cpu_t *cpu, uint8_t oper) {
+  adc(cpu, mem_get_byte_indx(cpu, oper));
+}
+
+static void adc_indy(struct cpu_t *cpu, uint8_t oper) {
+  adc(cpu, mem_get_byte_indy(cpu, oper));
+}
+
+/* AND */
+
+static void and(struct cpu_t *cpu, uint8_t m) {
+  cpu->state.a &= m;
+  update_zn(cpu, cpu->state.a);
+}
+
+static void and_imm(struct cpu_t *cpu, uint8_t oper) {
+  and(cpu, oper);
+}
+
+static void and_zpg(struct cpu_t *cpu, uint8_t oper) {
+  and(cpu, mem_get_byte_zpg(cpu, oper));
+}
+
+static void and_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  and(cpu, mem_get_byte_zpgx(cpu, oper));
+}
+
+static void and_abs(struct cpu_t *cpu, uint16_t oper) {
+  and(cpu, mem_get_byte_abs(cpu, oper));
+}
+
+static void and_absx(struct cpu_t *cpu, uint16_t oper) {
+  and(cpu, mem_get_byte_absx(cpu, oper));
+}
+
+static void and_absy(struct cpu_t *cpu, uint16_t oper) {
+  and(cpu, mem_get_byte_absy(cpu, oper));
+}
+
+static void and_indx(struct cpu_t *cpu, uint8_t oper) {
+  and(cpu, mem_get_byte_indx(cpu, oper));
+}
+
+static void and_indy(struct cpu_t *cpu, uint8_t oper) {
+  and(cpu, mem_get_byte_indy(cpu, oper));
+}
+
+/* ASL */
+
+static uint8_t asl(struct cpu_t *cpu, uint8_t b) {
+  cpu->state.c = (b & 0x80);
+  b <<= 1;
+  cpu->state.n = (b & 0x80);
+  cpu->state.z = (b == 0);
+  return b;
+}
+
+static void asl_acc(struct cpu_t *cpu) {
+  cpu->state.a = asl(cpu, cpu->state.a);
+}
+
+static void asl_zpg(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpg(cpu, oper, asl);
+}
+
+static void asl_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpgx(cpu, oper, asl);
+}
+
+static void asl_abs(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_abs(cpu, oper, asl);
+}
+
+static void asl_absx(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_absx(cpu, oper, asl);
+}
+
+/* BIT */
+
+static void bit(struct cpu_t *cpu, uint8_t m) {
+  uint8_t t = cpu->state.a & m;
+  cpu->state.n = (m & 0x80);
+  cpu->state.v = (m & 0x40);
+  cpu->state.z = (t == 0);
+}
+
+static void bit_zpg(struct cpu_t *cpu, uint8_t oper) {
+  bit(cpu, mem_get_byte_zpg(cpu, oper));
+}
+
+static void bit_abs(struct cpu_t *cpu, uint16_t oper) {
+  bit(cpu, mem_get_byte_abs(cpu, oper));
+}
+
+/* Bxx Branches */
+
+static void bcc(struct cpu_t *cpu, uint8_t oper) {
+  if (cpu->state.c == 0) {
+    cpu->state.pc += (int8_t) oper;
+  }
+}
+
+static void bcs(struct cpu_t *cpu, uint8_t oper) {
+  if (cpu->state.c) {
+    cpu->state.pc += (int8_t) oper;
+  }
+}
+
+static void beq(struct cpu_t *cpu, uint8_t oper) {
+  if (cpu->state.z) {
+    cpu->state.pc += (int8_t) oper;
+  }
+}
+
+static void bmi(struct cpu_t *cpu, uint8_t oper) {
+  if (cpu->state.n) {
+    cpu->state.pc += (int8_t) oper;
+  }
+}
+
+static void bne(struct cpu_t *cpu, uint8_t oper) {
+  if (!cpu->state.z) {
+    cpu->state.pc += (int8_t) oper;
+  }
+}
+
+static void bpl(struct cpu_t *cpu, uint8_t oper) {
+  if (!cpu->state.n) {
+    cpu->state.pc += (int8_t) oper;
+  }
+}
+
+static void bvc(struct cpu_t *cpu, uint8_t oper) {
+  if (!cpu->state.v) {
+    cpu->state.pc += (int8_t) oper;
+  }
+}
+
+static void bvs(struct cpu_t *cpu, uint8_t oper) {
+  if (cpu->state.v) {
+    cpu->state.pc += (int8_t) oper;
+  }
+}
+
+/* BRK */
+
+static void brk(struct cpu_t *cpu) {
+  // TODO
+}
+
+/* CLx */
+
+static void clc(struct cpu_t *cpu) {
+  cpu->state.c = 0;
+}
+
+static void cld(struct cpu_t *cpu) {
+  cpu->state.d = 0;
+}
+
+static void cli(struct cpu_t *cpu) {
+  cpu->state.i = 0;
+}
+
+static void clv(struct cpu_t *cpu) {
+  cpu->state.v = 0;
+}
+
+/* CMP */
+
+static void cmp(struct cpu_t *cpu, uint8_t m) {
+  uint8_t t = cpu->state.a - m;
+  cpu->state.c = (cpu->state.a >= m);
+  cpu->state.n = (t & 0x80);
+  cpu->state.z = (t == 0);
+}
+
+static void cmp_imm(struct cpu_t *cpu, uint8_t oper) {
+  cmp(cpu, oper);
+}
+
+static void cmp_zpg(struct cpu_t *cpu, uint8_t oper) {
+  cmp(cpu, mem_get_byte_zpg(cpu, oper));
+}
+
+static void cmp_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  cmp(cpu, mem_get_byte_zpgx(cpu, oper));
+}
+
+static void cmp_abs(struct cpu_t *cpu, uint16_t oper) {
+  cmp(cpu, mem_get_byte_abs(cpu, oper));
+}
+
+static void cmp_absx(struct cpu_t *cpu, uint16_t oper) {
+  cmp(cpu, mem_get_byte_absx(cpu, oper));
+}
+
+static void cmp_absy(struct cpu_t *cpu, uint16_t oper) {
+  cmp(cpu, mem_get_byte_absy(cpu, oper));
+}
+
+static void cmp_indx(struct cpu_t *cpu, uint8_t oper) {
+  cmp(cpu, mem_get_byte_indx(cpu, oper));
+}
+
+static void cmp_indy(struct cpu_t *cpu, uint8_t oper) {
+  cmp(cpu, mem_get_byte_indy(cpu, oper));
+}
+
+/* CPX */
+
+static void cpx(struct cpu_t *cpu, uint8_t m) {
+  uint8_t t = cpu->state.x - m;
+  cpu->state.c = (cpu->state.x >= m);
+  update_zn(cpu, t);
+}
+
+static void cpx_imm(struct cpu_t *cpu, uint8_t oper) {
+  cpx(cpu, oper);
+}
+
+static void cpx_zpg(struct cpu_t *cpu, uint8_t oper) {
+  cpx(cpu, mem_get_byte_zpg(cpu, oper));
+}
+
+static void cpx_abs(struct cpu_t *cpu, uint16_t oper) {
+  cpx(cpu, mem_get_byte_abs(cpu, oper));
+}
+
+/* CPY */
+
+static void cpy(struct cpu_t *cpu, uint8_t m) {
+  uint8_t t = cpu->state.y - m;
+  cpu->state.c = (cpu->state.y >= m);
+  update_zn(cpu, t);
+}
+
+static void cpy_imm(struct cpu_t *cpu, uint8_t oper) {
+  cpy(cpu, oper);
+}
+
+static void cpy_zpg(struct cpu_t *cpu, uint8_t oper) {
+  cpy(cpu, mem_get_byte_zpg(cpu, oper));
+}
+
+static void cpy_abs(struct cpu_t *cpu, uint16_t oper) {
+  cpy(cpu, mem_get_byte_abs(cpu, oper));
+}
+
+/* DEx */
+
+static uint8_t dec(struct cpu_t *cpu, uint8_t b) {
+  uint8_t t = b - 1;
+  update_zn(cpu, t);
+  return t;
+}
+
+static void dec_zpg(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpg(cpu, oper, dec);
+}
+
+static void dec_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpgx(cpu, oper, dec);
+}
+
+static void dec_abs(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_abs(cpu, oper, dec);
+}
+
+static void dec_absx(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_absx(cpu, oper, dec);
+}
+
+static void dex(struct cpu_t *cpu) {
+  cpu->state.x--;
+  update_zn(cpu, cpu->state.x);
+}
+
+static void dey(struct cpu_t *cpu) {
+  cpu->state.y--;
+  update_zn(cpu, cpu->state.y);
+}
+
+/* EOR */
+
+static void eor(struct cpu_t *cpu, uint8_t m) {
+  cpu->state.a ^= m;
+  update_zn(cpu, cpu->state.a);
+}
+
+static void eor_imm(struct cpu_t *cpu, uint8_t oper) {
+  eor(cpu, oper);
+}
+
+static void eor_zpg(struct cpu_t *cpu, uint8_t oper) {
+  eor(cpu, mem_get_byte_zpg(cpu, oper));
+}
+
+static void eor_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  eor(cpu, mem_get_byte_zpgx(cpu, oper));
+}
+
+static void eor_abs(struct cpu_t *cpu, uint16_t oper) {
+  eor(cpu, mem_get_byte_abs(cpu, oper));
+}
+
+static void eor_absx(struct cpu_t *cpu, uint16_t oper) {
+  eor(cpu, mem_get_byte_absx(cpu, oper));
+}
+
+static void eor_absy(struct cpu_t *cpu, uint16_t oper) {
+  eor(cpu, mem_get_byte_absy(cpu, oper));
+}
+
+static void eor_indx(struct cpu_t *cpu, uint8_t oper) {
+  eor(cpu, mem_get_byte_indx(cpu, oper));
+}
+
+static void eor_indy(struct cpu_t *cpu, uint8_t oper) {
+  eor(cpu, mem_get_byte_indy(cpu, oper));
+}
+
+/* INx */
+
+static uint8_t inc(struct cpu_t *cpu, uint8_t b) {
+  uint8_t t = b + 1;
+  update_zn(cpu, t);
+  return t;
+}
+
+static void inc_zpg(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpg(cpu, oper, inc);
+}
+
+static void inc_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpgx(cpu, oper, inc);
+}
+
+static void inc_abs(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_abs(cpu, oper, inc);
+}
+
+static void inc_absx(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_absx(cpu, oper, inc);
+}
+
+static void inx(struct cpu_t *cpu) {
+  cpu->state.x++;
+  update_zn(cpu, cpu->state.x);
+}
+
+static void iny(struct cpu_t *cpu) {
+  cpu->state.y++;
+  update_zn(cpu, cpu->state.y);
+}
+
+/* JMP */
+
+static void jmp_abs(struct cpu_t *cpu, uint16_t oper) {
+  cpu->state.pc = oper;
+}
+
+static void jmp_ind(struct cpu_t *cpu, uint16_t oper) {
+  cpu->state.pc = mem_get_word(cpu, oper);
+}
+
+/* JSR */
+
+static void jsr_abs(struct cpu_t *cpu, uint16_t oper) {
+  cpu->state.sp -= 2;
+  mem_set_word(cpu, cpu->state.sp, cpu->state.pc-1);
+  cpu->state.pc = oper;
+}
+
+/* LDA */
+
+static void lda_imm(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.a = oper;
+  update_zn(cpu, cpu->state.a);
+}
+
+static void lda_zpg(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.a = mem_get_byte_zpg(cpu, oper);
+  update_zn(cpu, cpu->state.a);
+}
+
+static void lda_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.a = mem_get_byte_zpgx(cpu, oper);
+  update_zn(cpu, cpu->state.a);
+}
+
+static void lda_abs(struct cpu_t *cpu, uint16_t oper) {
+  cpu->state.a = mem_get_byte_abs(cpu, oper);
+  update_zn(cpu, cpu->state.a);
+}
+
+static void lda_absx(struct cpu_t *cpu, uint16_t oper) {
+  cpu->state.a = mem_get_byte_absx(cpu, oper);
+  update_zn(cpu, cpu->state.a);
+}
+
+static void lda_absy(struct cpu_t *cpu, uint16_t oper) {
+  cpu->state.a = mem_get_byte_absy(cpu, oper);
+  update_zn(cpu, cpu->state.a);
+}
+
+static void lda_indx(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.a = mem_get_byte_indx(cpu, oper);
+  update_zn(cpu, cpu->state.a);
+}
+
+static void lda_indy(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.a = mem_get_byte_indy(cpu, oper);
+  update_zn(cpu, cpu->state.a);
+}
+
+/* LDX */
+
+static void ldx_imm(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.x = oper;
+  update_zn(cpu, cpu->state.x);
+}
+
+static void ldx_zpg(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.x = mem_get_byte_zpg(cpu, oper);
+  update_zn(cpu, cpu->state.x);
+}
+
+static void ldx_zpgy(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.x = mem_get_byte_zpgy(cpu, oper);
+  update_zn(cpu, cpu->state.x);
+}
+
+static void ldx_abs(struct cpu_t *cpu, uint16_t oper) {
+  cpu->state.x = mem_get_byte_abs(cpu, oper);
+  update_zn(cpu, cpu->state.x);
+}
+
+static void ldx_absy(struct cpu_t *cpu, uint16_t oper) {
+  cpu->state.x = mem_get_byte_absy(cpu, oper);
+  update_zn(cpu, cpu->state.x);
+}
+
+/* LDY */
+
+static void ldy_imm(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.y = oper;
+  update_zn(cpu, cpu->state.y);
+}
+
+static void ldy_zpg(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.y = mem_get_byte_zpg(cpu, oper);
+  update_zn(cpu, cpu->state.y);
+}
+
+static void ldy_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  cpu->state.y = mem_get_byte_zpgx(cpu, oper);
+  update_zn(cpu, cpu->state.y);
+}
+
+static void ldy_abs(struct cpu_t *cpu, uint16_t oper) {
+  cpu->state.y = mem_get_byte_abs(cpu, oper);
+  update_zn(cpu, cpu->state.y);
+}
+
+static void ldy_absx(struct cpu_t *cpu, uint16_t oper) {
+  cpu->state.y = mem_get_byte_absx(cpu, oper);
+  update_zn(cpu, cpu->state.y);
+}
+
+/* LSR */
+
+static uint8_t lsr(struct cpu_t *cpu, uint8_t b) {
+  cpu->state.c = (b & 1);
+  b >>= 1;
+  update_zn(cpu, b);
+  return b;
+}
+
+static void lsr_acc(struct cpu_t *cpu) {
+  cpu->state.a = lsr(cpu, cpu->state.a);
+}
+
+static void lsr_zpg(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpg(cpu, oper, lsr);
+}
+
+static void lsr_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpgx(cpu, oper, lsr);
+}
+
+static void lsr_abs(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_abs(cpu, oper, lsr);
+}
+static void lsr_absx(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_absx(cpu, oper, lsr);
+}
+
+/* NOP */
+
+static void nop(struct cpu_t *cpu) {
+}
+
+/* ORA */
+
+static void ora(struct cpu_t *cpu, uint8_t m) {
+  cpu->state.a |= m;
+  update_zn(cpu, cpu->state.a);
+}
+
+static void ora_imm(struct cpu_t *cpu, uint8_t oper) {
+  ora(cpu, oper);
+}
+
+static void ora_zpg(struct cpu_t *cpu, uint8_t oper) {
+  ora(cpu, mem_get_byte_zpg(cpu, oper));
+}
+
+static void ora_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  ora(cpu, mem_get_byte_zpgx(cpu, oper));
+}
+
+static void ora_abs(struct cpu_t *cpu, uint16_t oper) {
+  ora(cpu, mem_get_byte_abs(cpu, oper));
+}
+
+static void ora_absx(struct cpu_t *cpu, uint16_t oper) {
+  ora(cpu, mem_get_byte_absx(cpu, oper));
+}
+
+static void ora_absy(struct cpu_t *cpu, uint16_t oper) {
+  ora(cpu, mem_get_byte_absy(cpu, oper));
+}
+
+static void ora_indx(struct cpu_t *cpu, uint8_t oper) {
+  ora(cpu, mem_get_byte_indx(cpu, oper));
+}
+
+static void ora_indy(struct cpu_t *cpu, uint8_t oper) {
+  ora(cpu, mem_get_byte_indy(cpu, oper));
+}
+
+
+/* P** */
+
+static void pha(struct cpu_t *cpu) {
+  cpu->state.sp--;
+  mem_set_byte(cpu, cpu->state.sp, cpu->state.a);
+}
+
+static void pla(struct cpu_t *cpu) {
+  cpu->state.a = mem_get_byte(cpu, cpu->state.sp);
+  cpu->state.sp++;
+  update_zn(cpu, cpu->state.a);
+}
+
+/* ROL */
+
+static uint8_t rol(struct cpu_t* cpu, uint8_t b) {
+  uint8_t carry = cpu->state.c ? 1 : 0;
+  cpu->state.c = (b & 0x80);
+  b = (b << 1) | carry;
+  update_zn(cpu, b);
+  return b;
+}
+
+static void rol_acc(struct cpu_t *cpu) {
+  cpu->state.a = rol(cpu, cpu->state.a);
+}
+
+static void rol_zpg(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpg(cpu, oper, rol);
+}
+
+static void rol_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpgx(cpu, oper, rol);
+}
+
+static void rol_abs(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_abs(cpu, oper, rol);
+}
+
+static void rol_absx(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_absx(cpu, oper, rol);
+}
+
+/* ROR */
+
+static uint8_t ror(struct cpu_t* cpu, uint8_t b) {
+  uint8_t carry = cpu->state.c ? 1 : 0;
+  cpu->state.c = (b & 0x01);
+  b = (b >> 1) | (carry << 7);
+  update_zn(cpu, b);
+  return b;
+}
+
+static void ror_acc(struct cpu_t *cpu) {
+  cpu->state.a = ror(cpu, cpu->state.a);
+}
+
+static void ror_zpg(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpg(cpu, oper, ror);
+}
+
+static void ror_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  mem_mod_byte_zpgx(cpu, oper, ror);
+}
+
+static void ror_abs(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_abs(cpu, oper, ror);
+}
+
+static void ror_absx(struct cpu_t *cpu, uint16_t oper) {
+  mem_mod_byte_absx(cpu, oper, ror);
+}
+
+/* RTS */
+
+static void rts(struct cpu_t *cpu) {
+  cpu->state.pc = mem_get_word(cpu, cpu->state.sp)+1;
+  cpu->state.sp += 2;
+}
+
+/* SBC */
+
+static void sbc(struct cpu_t *cpu, uint8_t m) {
+  adc(cpu, m ^ 0xff);
+}
+
+static void sbc_imm(struct cpu_t *cpu, uint8_t oper) {
+  sbc(cpu, oper);
+}
+
+static void sbc_zpg(struct cpu_t *cpu, uint8_t oper) {
+  sbc(cpu, mem_get_byte_zpg(cpu, oper));
+}
+
+static void sbc_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  sbc(cpu, mem_get_byte_zpgx(cpu, oper));
+}
+
+static void sbc_abs(struct cpu_t *cpu, uint16_t oper) {
+  sbc(cpu, mem_get_byte_abs(cpu, oper));
+}
+
+static void sbc_absx(struct cpu_t *cpu, uint16_t oper) {
+  sbc(cpu, mem_get_byte_absx(cpu, oper));
+}
+
+static void sbc_absy(struct cpu_t *cpu, uint16_t oper) {
+  sbc(cpu, mem_get_byte_absy(cpu, oper));
+}
+
+static void sbc_indx(struct cpu_t *cpu, uint8_t oper) {
+  sbc(cpu, mem_get_byte_indx(cpu, oper));
+}
+
+static void sbc_indy(struct cpu_t *cpu, uint8_t oper) {
+  sbc(cpu, mem_get_byte_indy(cpu, oper));
+}
+
+/* STA */
+
+static void sta_zpg(struct cpu_t *cpu, uint8_t oper) {
+  mem_set_byte_zpg(cpu, oper, cpu->state.a);
+}
+
+static void sta_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  mem_set_byte_zpgx(cpu, oper, cpu->state.a);
+}
+
+static void sta_abs(struct cpu_t *cpu, uint16_t oper) {
+  mem_set_byte_abs(cpu, oper, cpu->state.a);
+}
+
+static void sta_absx(struct cpu_t *cpu, uint16_t oper) {
+  mem_set_byte_absx(cpu, oper, cpu->state.a);
+}
+
+static void sta_absy(struct cpu_t *cpu, uint16_t oper) {
+  mem_set_byte_absy(cpu, oper, cpu->state.a);
+}
+
+static void sta_indx(struct cpu_t *cpu, uint8_t oper) {
+  mem_set_byte_indx(cpu, oper, cpu->state.a);
+}
+
+static void sta_indy(struct cpu_t *cpu, uint8_t oper) {
+  mem_set_byte_indy(cpu, oper, cpu->state.a);
+}
+
+/* STX */
+
+static void stx_zpg(struct cpu_t *cpu, uint8_t oper) {
+  mem_set_byte_zpg(cpu, oper, cpu->state.x);
+}
+
+static void stx_zpgy(struct cpu_t *cpu, uint8_t oper) {
+  mem_set_byte_zpgy(cpu, oper, cpu->state.x);
+}
+
+static void stx_abs(struct cpu_t *cpu, uint16_t oper) {
+  mem_set_byte_abs(cpu, oper, cpu->state.x);
+}
+
+/* STY */
+
+static void sty_zpg(struct cpu_t *cpu, uint8_t oper) {
+  mem_set_byte_zpg(cpu, oper, cpu->state.y);
+}
+
+static void sty_zpgx(struct cpu_t *cpu, uint8_t oper) {
+  mem_set_byte_zpgx(cpu, oper, cpu->state.y);
+}
+
+static void sty_abs(struct cpu_t *cpu, uint16_t oper) {
+  mem_set_byte_abs(cpu, oper, cpu->state.y);
+}
+
+/* Txx */
+
+static void tax(struct cpu_t *cpu) {
+  cpu->state.x = cpu->state.a;
+  update_zn(cpu, cpu->state.x);
+}
+
+static void tay(struct cpu_t *cpu) {
+  cpu->state.y = cpu->state.a;
+  update_zn(cpu, cpu->state.y);
+}
+
+static void tsx(struct cpu_t *cpu) {
+  cpu->state.x = cpu->state.sp & 0x00ff;
+  update_zn(cpu, cpu->state.x);
+}
+
+static void txa(struct cpu_t *cpu) {
+  cpu->state.a = cpu->state.x;
+  update_zn(cpu, cpu->state.a);
+}
+
+static void txs(struct cpu_t *cpu) {
+  cpu->state.sp = 0x0100 + cpu->state.x;
+}
+
+static void tya(struct cpu_t *cpu) {
+  cpu->state.a = cpu->state.y;
+  update_zn(cpu, cpu->state.a);
+}
+
+/* Unknown instruction handler */
+
+static void unknown_instruction(struct cpu_t *cpu) {
+  fprintf(stderr, "** ??? **\n");
+}
+
+/* Instruction dispatch table */
+
+cpu_instruction_t instructions[256] = {
+  /* 0x00 */ { "BRK", 0x00, 1, 2, (void*) brk },
+  /* 0x01 */ { "ORA", 0x01, 2, 6, (void*) ora_indx },
+  /* 0x02 */ { "???", 0x02, 1, 2, (void*) unknown_instruction },
+  /* 0x03 */ { "???", 0x03, 1, 2, (void*) unknown_instruction },
+  /* 0x04 */ { "???", 0x04, 1, 2, (void*) unknown_instruction },
+  /* 0x05 */ { "ORA", 0x05, 2, 2, (void*) ora_zpg },
+  /* 0x06 */ { "ASL", 0x06, 2, 5, (void*) asl_zpg },
+  /* 0x07 */ { "???", 0x07, 1, 2, (void*) unknown_instruction },
+  /* 0x08 */ { "???", 0x08, 1, 2, (void*) unknown_instruction },
+  /* 0x09 */ { "ORA", 0x09, 2, 2, (void*) ora_imm },
+  /* 0x0a */ { "ASL", 0x0a, 1, 2, (void*) asl_acc },
+  /* 0x0b */ { "???", 0x0b, 1, 2, (void*) unknown_instruction },
+  /* 0x0c */ { "???", 0x0c, 1, 2, (void*) unknown_instruction },
+  /* 0x0d */ { "ORA", 0x0d, 3, 4, (void*) ora_abs },
+  /* 0x0e */ { "ASL", 0x0e, 3, 6, (void*) asl_abs },
+  /* 0x0f */ { "???", 0x0f, 1, 2, (void*) unknown_instruction },
+  /* 0x10 */ { "BPL", 0x10, 2, 2, (void*) bpl },
+  /* 0x11 */ { "ORA", 0x11, 2, 5, (void*) ora_indy },
+  /* 0x12 */ { "???", 0x12, 1, 2, (void*) unknown_instruction },
+  /* 0x13 */ { "???", 0x13, 1, 2, (void*) unknown_instruction },
+  /* 0x14 */ { "???", 0x14, 1, 2, (void*) unknown_instruction },
+  /* 0x15 */ { "ORA", 0x15, 2, 3, (void*) ora_zpgx },
+  /* 0x16 */ { "ASL", 0x16, 2, 6, (void*) asl_zpgx },
+  /* 0x17 */ { "???", 0x17, 1, 2, (void*) unknown_instruction },
+  /* 0x18 */ { "CLC", 0x18, 1, 2, (void*) clc },
+  /* 0x19 */ { "ORA", 0x19, 3, 4, (void*) ora_absy },
+  /* 0x1a */ { "???", 0x1a, 1, 2, (void*) unknown_instruction },
+  /* 0x1b */ { "???", 0x1b, 1, 2, (void*) unknown_instruction },
+  /* 0x1c */ { "???", 0x1c, 1, 2, (void*) unknown_instruction },
+  /* 0x1d */ { "ORA", 0x1d, 3, 4, (void*) ora_absx },
+  /* 0x1e */ { "ASL", 0x1e, 3, 7, (void*) asl_absx },
+  /* 0x1f */ { "???", 0x1f, 1, 2, (void*) unknown_instruction },
+
+  /* 0x20 */ { "JSR", 0x20, 3, 6, (void*) jsr_abs },
+  /* 0x21 */ { "AND", 0x21, 2, 6, (void*) and_indx },
+  /* 0x22 */ { "???", 0x22, 1, 2, (void*) unknown_instruction },
+  /* 0x23 */ { "???", 0x23, 1, 2, (void*) unknown_instruction },
+  /* 0x24 */ { "BIT", 0x24, 2, 3, (void*) bit_zpg },
+  /* 0x25 */ { "AND", 0x25, 2, 3, (void*) and_zpg },
+  /* 0x26 */ { "ROL", 0x26, 2, 5, (void*) rol_zpg },
+  /* 0x27 */ { "???", 0x27, 1, 2, (void*) unknown_instruction },
+  /* 0x28 */ { "???", 0x28, 1, 2, (void*) unknown_instruction },
+  /* 0x29 */ { "AND", 0x29, 2, 2, (void*) and_imm },
+  /* 0x2a */ { "ROL", 0x2a, 1, 2, (void*) rol_acc },
+  /* 0x2b */ { "???", 0x2b, 1, 2, (void*) unknown_instruction },
+  /* 0x2c */ { "BIT", 0x2c, 3, 4, (void*) bit_abs },
+  /* 0x2d */ { "AND", 0x2d, 3, 4, (void*) and_abs },
+  /* 0x2e */ { "ROL", 0x2e, 3, 6, (void*) rol_abs },
+  /* 0x2f */ { "???", 0x2f, 1, 2, (void*) unknown_instruction },
+  /* 0x30 */ { "BMI", 0x30, 2, 2, (void*) bmi },
+  /* 0x31 */ { "AND", 0x31, 2, 5, (void*) and_indy },
+  /* 0x32 */ { "???", 0x32, 1, 2, (void*) unknown_instruction },
+  /* 0x33 */ { "???", 0x33, 1, 2, (void*) unknown_instruction },
+  /* 0x34 */ { "???", 0x34, 1, 2, (void*) unknown_instruction },
+  /* 0x35 */ { "AND", 0x35, 2, 4, (void*) and_zpgx },
+  /* 0x36 */ { "ROL", 0x36, 2, 6, (void*) rol_zpgx },
+  /* 0x37 */ { "???", 0x37, 1, 2, (void*) unknown_instruction },
+  /* 0x38 */ { "???", 0x38, 1, 2, (void*) unknown_instruction },
+  /* 0x39 */ { "AND", 0x39, 3, 4, (void*) and_absy },
+  /* 0x3a */ { "???", 0x3a, 1, 2, (void*) unknown_instruction },
+  /* 0x3b */ { "???", 0x3b, 1, 2, (void*) unknown_instruction },
+  /* 0x3c */ { "???", 0x3c, 1, 2, (void*) unknown_instruction },
+  /* 0x3d */ { "AND", 0x3d, 3, 4, (void*) and_absx },
+  /* 0x3e */ { "ROL", 0x3e, 3, 7, (void*) rol_absx },
+  /* 0x3f */ { "???", 0x3f, 1, 2, (void*) unknown_instruction },
+
+  /* 0x40 */ { "???", 0x40, 1, 2, (void*) unknown_instruction },
+  /* 0x41 */ { "EOR", 0x41, 2, 6, (void*) eor_indx },
+  /* 0x42 */ { "???", 0x42, 1, 2, (void*) unknown_instruction },
+  /* 0x43 */ { "???", 0x43, 1, 2, (void*) unknown_instruction },
+  /* 0x44 */ { "???", 0x44, 1, 2, (void*) unknown_instruction },
+  /* 0x45 */ { "EOR", 0x45, 2, 3, (void*) eor_zpg },
+  /* 0x46 */ { "LSR", 0x46, 2, 5, (void*) lsr_zpg },
+  /* 0x47 */ { "???", 0x47, 1, 2, (void*) unknown_instruction },
+  /* 0x48 */ { "PHA", 0x48, 1, 3, (void*) pha },
+  /* 0x49 */ { "EOR", 0x49, 2, 2, (void*) eor_imm },
+  /* 0x4a */ { "LSR", 0x4a, 1, 2, (void*) lsr_acc },
+  /* 0x4b */ { "???", 0x4b, 1, 2, (void*) unknown_instruction },
+  /* 0x4c */ { "JMP", 0x4c, 3, 3, (void*) jmp_abs },
+  /* 0x4d */ { "EOR", 0x4d, 3, 4, (void*) eor_abs },
+  /* 0x4e */ { "LSR", 0x4e, 3, 6, (void*) lsr_abs },
+  /* 0x4f */ { "???", 0x4f, 1, 2, (void*) unknown_instruction },
+  /* 0x50 */ { "BVC", 0x50, 2, 2, (void*) bvc },
+  /* 0x51 */ { "EOR", 0x51, 2, 5, (void*) eor_indy },
+  /* 0x52 */ { "???", 0x52, 1, 2, (void*) unknown_instruction },
+  /* 0x53 */ { "???", 0x53, 1, 2, (void*) unknown_instruction },
+  /* 0x54 */ { "???", 0x54, 1, 2, (void*) unknown_instruction },
+  /* 0x55 */ { "EOR", 0x55, 2, 4, (void*) eor_zpgx },
+  /* 0x56 */ { "LSR", 0x56, 2, 6, (void*) lsr_zpgx },
+  /* 0x57 */ { "???", 0x57, 1, 2, (void*) unknown_instruction },
+  /* 0x58 */ { "CLI", 0x58, 1, 2, (void*) cli },
+  /* 0x59 */ { "EOR", 0x59, 3, 4, (void*) eor_absy },
+  /* 0x5a */ { "???", 0x5a, 1, 2, (void*) unknown_instruction },
+  /* 0x5b */ { "???", 0x5b, 1, 2, (void*) unknown_instruction },
+  /* 0x5c */ { "???", 0x5c, 1, 2, (void*) unknown_instruction },
+  /* 0x5d */ { "EOR", 0x5d, 3, 4, (void*) eor_absx },
+  /* 0x5e */ { "LSR", 0x5e, 3, 7, (void*) lsr_absx },
+  /* 0x5f */ { "???", 0x5f, 1, 2, (void*) unknown_instruction },
+
+  /* 0x60 */ { "RTS", 0x60, 1, 6, (void*) rts },
+  /* 0x61 */ { "ADC", 0x61, 2, 6, (void*) adc_indx },
+  /* 0x62 */ { "???", 0x62, 1, 2, (void*) unknown_instruction },
+  /* 0x63 */ { "???", 0x63, 1, 2, (void*) unknown_instruction },
+  /* 0x64 */ { "???", 0x64, 1, 2, (void*) unknown_instruction },
+  /* 0x65 */ { "ADC", 0x65, 2, 3, (void*) adc_zpg },
+  /* 0x66 */ { "ROR", 0x66, 2, 5, (void*) ror_zpg },
+  /* 0x67 */ { "???", 0x67, 1, 2, (void*) unknown_instruction },
+  /* 0x68 */ { "PLA", 0x68, 1, 4, (void*) pla },
+  /* 0x69 */ { "ADC", 0x69, 2, 2, (void*) adc_imm },
+  /* 0x6a */ { "ROR", 0x6a, 1, 2, (void*) ror_acc },
+  /* 0x6b */ { "???", 0x6b, 1, 2, (void*) unknown_instruction },
+  /* 0x6c */ { "JMP", 0x6c, 3, 5, (void*) jmp_ind },
+  /* 0x6d */ { "ADC", 0x6d, 3, 4, (void*) adc_abs },
+  /* 0x6e */ { "ROR", 0x6e, 3, 6, (void*) ror_abs },
+  /* 0x6f */ { "???", 0x6f, 1, 2, (void*) unknown_instruction },
+  /* 0x70 */ { "BVS", 0x70, 2, 2, (void*) bvs },
+  /* 0x71 */ { "ADC", 0x71, 2, 5, (void*) adc_indy },
+  /* 0x72 */ { "???", 0x72, 1, 2, (void*) unknown_instruction },
+  /* 0x73 */ { "???", 0x73, 1, 2, (void*) unknown_instruction },
+  /* 0x74 */ { "???", 0x74, 1, 2, (void*) unknown_instruction },
+  /* 0x75 */ { "ADC", 0x75, 2, 4, (void*) adc_zpgx },
+  /* 0x76 */ { "ROR", 0x76, 2, 6, (void*) ror_zpgx },
+  /* 0x77 */ { "???", 0x77, 1, 2, (void*) unknown_instruction },
+  /* 0x78 */ { "???", 0x78, 1, 2, (void*) unknown_instruction },
+  /* 0x79 */ { "ADC", 0x79, 3, 4, (void*) adc_absy },
+  /* 0x7a */ { "???", 0x7a, 1, 2, (void*) unknown_instruction },
+  /* 0x7b */ { "???", 0x7b, 1, 2, (void*) unknown_instruction },
+  /* 0x7c */ { "???", 0x7c, 1, 2, (void*) unknown_instruction },
+  /* 0x7d */ { "ADC", 0x7d, 3, 4, (void*) adc_absx },
+  /* 0x7e */ { "ROR", 0x7e, 3, 7, (void*) ror_absx },
+  /* 0x7f */ { "???", 0x7f, 1, 2, (void*) unknown_instruction },
+
+  /* 0x80 */ { "???", 0x80, 1, 2, (void*) unknown_instruction },
+  /* 0x81 */ { "STA", 0x81, 2, 6, (void*) sta_indx },
+  /* 0x82 */ { "???", 0x82, 1, 2, (void*) unknown_instruction },
+  /* 0x83 */ { "???", 0x83, 1, 2, (void*) unknown_instruction },
+  /* 0x84 */ { "STY", 0x84, 2, 3, (void*) sty_zpg },
+  /* 0x85 */ { "STA", 0x85, 2, 3, (void*) sta_zpg },
+  /* 0x86 */ { "STX", 0x86, 2, 3, (void*) stx_zpg },
+  /* 0x87 */ { "???", 0x87, 1, 2, (void*) unknown_instruction },
+  /* 0x88 */ { "DEY", 0x88, 1, 2, (void*) dey },
+  /* 0x89 */ { "???", 0x89, 1, 2, (void*) unknown_instruction },
+  /* 0x8a */ { "TXA", 0x8a, 1, 2, (void*) txa },
+  /* 0x8b */ { "???", 0x8b, 1, 2, (void*) unknown_instruction },
+  /* 0x8c */ { "STY", 0x8c, 3, 4, (void*) sty_abs },
+  /* 0x8d */ { "STA", 0x8d, 3, 4, (void*) sta_abs },
+  /* 0x8e */ { "STX", 0x8e, 3, 4, (void*) stx_abs },
+  /* 0x8f */ { "???", 0x8f, 1, 2, (void*) unknown_instruction },
+  /* 0x90 */ { "BCC", 0x90, 2, 2, (void*) bcc },
+  /* 0x91 */ { "STA", 0x91, 2, 6, (void*) sta_indy },
+  /* 0x92 */ { "???", 0x92, 1, 2, (void*) unknown_instruction },
+  /* 0x93 */ { "???", 0x93, 1, 2, (void*) unknown_instruction },
+  /* 0x94 */ { "STY", 0x94, 2, 4, (void*) sty_zpgx },
+  /* 0x95 */ { "STA", 0x95, 2, 4, (void*) sta_zpgx },
+  /* 0x96 */ { "STX", 0x96, 2, 4, (void*) stx_zpgy },
+  /* 0x97 */ { "???", 0x97, 1, 2, (void*) unknown_instruction },
+  /* 0x98 */ { "TYA", 0x98, 1, 2, (void*) tya },
+  /* 0x99 */ { "STA", 0x99, 3, 5, (void*) sta_absy },
+  /* 0x9a */ { "TXS", 0x9a, 1, 2, (void*) txs },
+  /* 0x9b */ { "???", 0x9b, 1, 2, (void*) unknown_instruction },
+  /* 0x9c */ { "???", 0x9c, 1, 2, (void*) unknown_instruction },
+  /* 0x9d */ { "STA", 0x9d, 2, 5, (void*) sta_absx },
+  /* 0x9e */ { "???", 0x9e, 1, 2, (void*) unknown_instruction },
+  /* 0x9f */ { "???", 0x9f, 1, 2, (void*) unknown_instruction },
+
+  /* 0xa0 */ { "LDY", 0xa0, 2, 2, (void*) ldy_imm },
+  /* 0xa1 */ { "LDA", 0xa1, 2, 6, (void*) lda_indx },
+  /* 0xa2 */ { "LDX", 0xa2, 2, 2, (void*) ldx_imm },
+  /* 0xa3 */ { "???", 0xa3, 1, 2, (void*) unknown_instruction },
+  /* 0xa4 */ { "LDY", 0xa4, 2, 3, (void*) ldy_zpg },
+  /* 0xa5 */ { "LDA", 0xa5, 2, 3, (void*) lda_zpg },
+  /* 0xa6 */ { "LDX", 0xa6, 2, 3, (void*) ldx_zpg },
+  /* 0xa7 */ { "???", 0xa7, 1, 2, (void*) unknown_instruction },
+  /* 0xa8 */ { "TAY", 0xa8, 1, 2, (void*) tay },
+  /* 0xa9 */ { "LDA", 0xa9, 2, 2, (void*) lda_imm },
+  /* 0xaa */ { "TAX", 0xaa, 1, 2, (void*) tax },
+  /* 0xab */ { "???", 0xab, 1, 2, (void*) unknown_instruction },
+  /* 0xac */ { "LDY", 0xac, 3, 4, (void*) ldy_abs },
+  /* 0xad */ { "LDA", 0xad, 3, 4, (void*) lda_abs },
+  /* 0xae */ { "LDX", 0xae, 3, 4, (void*) ldx_abs },
+  /* 0xaf */ { "???", 0xaf, 1, 2, (void*) unknown_instruction },
+  /* 0xb0 */ { "BCS", 0xb0, 2, 2, (void*) bcs },
+  /* 0xb1 */ { "LDA", 0xb1, 2, 5, (void*) lda_indy },
+  /* 0xb2 */ { "???", 0xb2, 1, 2, (void*) unknown_instruction },
+  /* 0xb3 */ { "???", 0xb3, 1, 2, (void*) unknown_instruction },
+  /* 0xb4 */ { "LDY", 0xb4, 2, 4, (void*) ldy_zpgx },
+  /* 0xb5 */ { "LDA", 0xb5, 2, 4, (void*) lda_zpgx },
+  /* 0xb6 */ { "LDX", 0xb6, 2, 4, (void*) ldx_zpgy },
+  /* 0xb7 */ { "???", 0xb7, 1, 2, (void*) unknown_instruction },
+  /* 0xb8 */ { "CLV", 0xb8, 1, 2, (void*) clv },
+  /* 0xb9 */ { "LDA", 0xb9, 3, 4, (void*) lda_absy },
+  /* 0xba */ { "TSX", 0xba, 1, 2, (void*) tsx },
+  /* 0xbb */ { "???", 0xbb, 1, 2, (void*) unknown_instruction },
+  /* 0xbc */ { "LDY", 0xbc, 3, 4, (void*) ldy_absx },
+  /* 0xbd */ { "LDA", 0xbd, 3, 4, (void*) lda_absx },
+  /* 0xbe */ { "LDX", 0xbe, 3, 4, (void*) ldx_absy },
+  /* 0xbf */ { "???", 0xbf, 1, 2, (void*) unknown_instruction },
+
+  /* 0xc0 */ { "CPY", 0xc0, 2, 2, (void*) cpy_imm },
+  /* 0xc1 */ { "CMP", 0xc1, 2, 6, (void*) cmp_indx },
+  /* 0xc2 */ { "???", 0xc2, 1, 2, (void*) unknown_instruction },
+  /* 0xc3 */ { "???", 0xc3, 1, 2, (void*) unknown_instruction },
+  /* 0xc4 */ { "CPY", 0xc4, 2, 3, (void*) cpy_zpg },
+  /* 0xc5 */ { "CMP", 0xc5, 2, 3, (void*) cmp_zpg },
+  /* 0xc6 */ { "DEC", 0xc6, 2, 5, (void*) dec_zpg },
+  /* 0xc7 */ { "???", 0xc7, 1, 2, (void*) unknown_instruction },
+  /* 0xc8 */ { "INY", 0xc8, 1, 2, (void*) iny },
+  /* 0xc9 */ { "CMP", 0xc9, 2, 2, (void*) cmp_imm },
+  /* 0xca */ { "DEX", 0xca, 1, 2, (void*) dex },
+  /* 0xcb */ { "???", 0xcb, 1, 2, (void*) unknown_instruction },
+  /* 0xcc */ { "CPY", 0xcc, 3, 4, (void*) cpy_abs },
+  /* 0xcd */ { "CMP", 0xcd, 3, 4, (void*) cmp_abs },
+  /* 0xce */ { "DEC", 0xce, 3, 3, (void*) dec_abs },
+  /* 0xcf */ { "???", 0xcf, 1, 2, (void*) unknown_instruction },
+  /* 0xd0 */ { "BNE", 0xd0, 2, 2, (void*) bne },
+  /* 0xd1 */ { "CMP", 0xd1, 2, 5, (void*) cmp_indy },
+  /* 0xd2 */ { "???", 0xd2, 1, 2, (void*) unknown_instruction },
+  /* 0xd3 */ { "???", 0xd3, 1, 2, (void*) unknown_instruction },
+  /* 0xd4 */ { "???", 0xd4, 1, 2, (void*) unknown_instruction },
+  /* 0xd5 */ { "CMP", 0xd5, 2, 4, (void*) cmp_zpgx },
+  /* 0xd6 */ { "DEC", 0xd6, 2, 6, (void*) dec_zpgx },
+  /* 0xd7 */ { "???", 0xd7, 1, 2, (void*) unknown_instruction },
+  /* 0xd8 */ { "CLD", 0xd8, 1, 2, (void*) cld },
+  /* 0xd9 */ { "CMP", 0xd9, 3, 4, (void*) cmp_absy },
+  /* 0xda */ { "???", 0xda, 1, 2, (void*) unknown_instruction },
+  /* 0xdb */ { "???", 0xdb, 1, 2, (void*) unknown_instruction },
+  /* 0xdc */ { "???", 0xdc, 1, 2, (void*) unknown_instruction },
+  /* 0xdd */ { "CMP", 0xdd, 3, 4, (void*) cmp_absx },
+  /* 0xde */ { "DEC", 0xde, 3, 7, (void*) dec_absx },
+  /* 0xdf */ { "???", 0xdf, 1, 2, (void*) unknown_instruction },
+
+  /* 0xe0 */ { "CPX", 0xe0, 2, 2, (void*) cpx_imm },
+  /* 0xe1 */ { "SBC", 0xe1, 2, 2, (void*) sbc_indx },
+  /* 0xe2 */ { "???", 0xe2, 1, 2, (void*) unknown_instruction },
+  /* 0xe3 */ { "???", 0xe3, 1, 2, (void*) unknown_instruction },
+  /* 0xe4 */ { "CPX", 0xe4, 2, 3, (void*) cpx_zpg },
+  /* 0xe5 */ { "SBC", 0xe5, 2, 2, (void*) sbc_zpg },
+  /* 0xe6 */ { "INC", 0xe6, 2, 5, (void*) inc_zpg },
+  /* 0xe7 */ { "???", 0xe7, 1, 2, (void*) unknown_instruction },
+  /* 0xe8 */ { "INX", 0xe8, 1, 2, (void*) inx },
+  /* 0xe9 */ { "SBC", 0xe9, 2, 2, (void*) sbc_imm },
+  /* 0xea */ { "NOP", 0xea, 1, 2, (void*) nop },
+  /* 0xeb */ { "???", 0xeb, 1, 2, (void*) unknown_instruction },
+  /* 0xec */ { "CPX", 0xec, 3, 4, (void*) cpx_abs },
+  /* 0xed */ { "SBC", 0xed, 3, 2, (void*) sbc_abs },
+  /* 0xee */ { "INC", 0xee, 3, 6, (void*) inc_abs },
+  /* 0xef */ { "???", 0xef, 1, 2, (void*) unknown_instruction },
+  /* 0xf0 */ { "BEQ", 0xf0, 2, 2, (void*) beq },
+  /* 0xf1 */ { "SBC", 0xf1, 1, 2, (void*) sbc_indy },
+  /* 0xf2 */ { "???", 0xf2, 1, 2, (void*) unknown_instruction },
+  /* 0xf3 */ { "???", 0xf3, 1, 2, (void*) unknown_instruction },
+  /* 0xf4 */ { "???", 0xf4, 1, 2, (void*) unknown_instruction },
+  /* 0xf5 */ { "SBC", 0xf5, 1, 2, (void*) sbc_zpgx },
+  /* 0xf6 */ { "INC", 0xf6, 2, 6, (void*) inc_zpgx },
+  /* 0xf7 */ { "???", 0xf7, 1, 2, (void*) unknown_instruction },
+  /* 0xf8 */ { "???", 0xf8, 1, 2, (void*) unknown_instruction },
+  /* 0xf9 */ { "SBC", 0xf9, 3, 2, (void*) sbc_absy },
+  /* 0xfa */ { "???", 0xfa, 1, 2, (void*) unknown_instruction },
+  /* 0xfb */ { "???", 0xfb, 1, 2, (void*) unknown_instruction },
+  /* 0xfc */ { "???", 0xfc, 1, 2, (void*) unknown_instruction },
+  /* 0xfd */ { "SBC", 0xfd, 3, 2, (void*) sbc_absx },
+  /* 0xfe */ { "INC", 0xfe, 3, 7, (void*) inc_absx },
+  /* 0xff */ { "???", 0xff, 1, 2, (void*) unknown_instruction }
+};
diff --git a/ins.h b/ins.h
new file mode 100644
index 0000000..b5b8d50
--- /dev/null
+++ b/ins.h
@@ -0,0 +1,38 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Stefan Arentz - http://github.com/st3fan/ewm
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef INS_H
+#define INS_H
+
+#include <stdint.h>
+
+typedef struct {
+  char *name;
+  uint8_t opcode;
+  uint8_t bytes;
+  uint8_t cycles;
+  void *handler;
+} cpu_instruction_t;
+
+extern cpu_instruction_t instructions[256];
+
+#endif
diff --git a/mem.c b/mem.c
new file mode 100644
index 0000000..b9b777f
--- /dev/null
+++ b/mem.c
@@ -0,0 +1,162 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Stefan Arentz - http://github.com/st3fan/ewm
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "mem.h"
+
+/* Memory Access */
+
+uint8_t mem_get_byte(struct cpu_t *cpu, uint16_t addr) {
+  if (cpu->iom) {
+    /* TODO: Assuming there is only one area of memory mapped io */
+    if (addr >= cpu->iom->start && addr < (cpu->iom->start + cpu->iom->length)) {
+      uint8_t v = ((iom_read_handler_t) cpu->iom->read_handler)((struct cpu_t*) cpu, cpu->iom->obj, addr);
+      //fprintf(stderr, "MEM: GETTING BYTE AT %.4X -> %.2X\n", addr, v);
+      return v;
+    }
+  }
+  //fprintf(stderr, "MEM: GETTING BYTE AT %.4X -> %.2X\n", addr, cpu->memory[addr]);
+  return cpu->memory[addr];
+}
+
+uint8_t mem_get_byte_abs(struct cpu_t *cpu, uint16_t addr) {
+  return mem_get_byte(cpu, addr);
+}
+
+uint8_t mem_get_byte_absx(struct cpu_t *cpu, uint16_t addr) {
+  return mem_get_byte(cpu, addr + cpu->state.x); /* TODO: Carry? */
+}
+
+uint8_t mem_get_byte_absy(struct cpu_t *cpu, uint16_t addr) {
+  return mem_get_byte(cpu, addr + cpu->state.y); /* TODO: Carry? */
+}
+
+uint8_t mem_get_byte_zpg(struct cpu_t *cpu, uint8_t addr) {
+  return mem_get_byte(cpu, addr);
+}
+
+uint8_t mem_get_byte_zpgx(struct cpu_t *cpu, uint8_t addr) {
+  return mem_get_byte(cpu, ((uint16_t) addr + cpu->state.x) & 0x00ff);
+}
+
+uint8_t mem_get_byte_zpgy(struct cpu_t *cpu, uint8_t addr) {
+  return mem_get_byte(cpu, ((uint16_t) addr + cpu->state.y) & 0x00ff);
+}
+
+uint8_t mem_get_byte_indx(struct cpu_t *cpu, uint8_t addr) {
+  return mem_get_byte(cpu, mem_get_word(cpu, addr + cpu->state.x)); // TODO: Does this wrap?
+}
+
+uint8_t mem_get_byte_indy(struct cpu_t *cpu, uint8_t addr) {
+  return mem_get_byte(cpu, mem_get_word(cpu, addr) + cpu->state.y);
+}
+
+
+
+void mem_set_byte(struct cpu_t *cpu, uint16_t addr, uint8_t v) {
+  //fprintf(stderr, "MEM: SETTING BYTE AT %.4X -> %.2X (%c)\n", addr, v, v & 0x7f);
+  if (cpu->iom) {
+    /* TODO: Assuming there is only one area of memory mapped io */
+    if (addr >= cpu->iom->start && addr < (cpu->iom->start + cpu->iom->length)) {
+      ((iom_write_handler_t) cpu->iom->write_handler)((struct cpu_t*) cpu, cpu->iom->obj, addr, v);
+      return;
+    }
+  }
+  cpu->memory[addr] = v;
+}
+
+
+
+void mem_set_byte_zpg(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+  mem_set_byte(cpu, addr, v);
+}
+
+void mem_set_byte_zpgx(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+  mem_set_byte(cpu, ((uint16_t) addr + cpu->state.x) & 0x00ff, v);
+}
+
+void mem_set_byte_zpgy(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+  mem_set_byte(cpu, ((uint16_t) addr + cpu->state.y) & 0x00ff, v);
+}
+
+void mem_set_byte_abs(struct cpu_t *cpu, uint16_t addr, uint8_t v) {
+  mem_set_byte(cpu, addr, v);
+}
+
+void mem_set_byte_absx(struct cpu_t *cpu, uint16_t addr, uint8_t v) {
+  mem_set_byte(cpu, addr+cpu->state.x, v);
+}
+
+void mem_set_byte_absy(struct cpu_t *cpu, uint16_t addr, uint8_t v) {
+  mem_set_byte(cpu, addr+cpu->state.y, v);
+}
+
+void mem_set_byte_indx(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+  mem_set_byte(cpu, mem_get_word(cpu, addr+cpu->state.x), v); // TODO: Does this wrap?
+}
+
+void mem_set_byte_indy(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+  mem_set_byte(cpu, mem_get_word(cpu, addr)+cpu->state.y, v);
+}
+
+/* MOD */
+
+void mem_mod_byte_zpg(struct cpu_t *cpu, uint8_t addr, mem_mod_t op) {
+  mem_set_byte_zpg(cpu, addr, op(cpu, mem_get_byte_zpg(cpu, addr)));
+}
+
+void mem_mod_byte_zpgx(struct cpu_t *cpu, uint8_t addr, mem_mod_t op) {
+  mem_set_byte_zpgx(cpu, addr, op(cpu, mem_get_byte_zpgx(cpu, addr)));
+}
+
+void mem_mod_byte_zpgy(struct cpu_t *cpu, uint8_t addr, mem_mod_t op) {
+  mem_set_byte_zpgy(cpu, addr, op(cpu, mem_get_byte_zpgy(cpu, addr)));
+}
+
+void mem_mod_byte_abs(struct cpu_t *cpu, uint16_t addr, mem_mod_t op) {
+  mem_set_byte_abs(cpu, addr, op(cpu, mem_get_byte_abs(cpu, addr)));
+}
+
+void mem_mod_byte_absx(struct cpu_t *cpu, uint16_t addr, mem_mod_t op) {
+  mem_set_byte_absx(cpu, addr, op(cpu, mem_get_byte_absx(cpu, addr)));
+}
+
+void mem_mod_byte_absy(struct cpu_t *cpu, uint16_t addr, mem_mod_t op) {
+  mem_set_byte_absy(cpu, addr, op(cpu, mem_get_byte_absy(cpu, addr)));
+}
+
+void mem_mod_byte_indx(struct cpu_t *cpu, uint8_t addr, mem_mod_t op) {
+  mem_set_byte_indx(cpu, addr, op(cpu, mem_get_byte_indx(cpu, addr)));
+}
+
+void mem_mod_byte_indy(struct cpu_t *cpu, uint8_t addr, mem_mod_t op) {
+  mem_set_byte_indy(cpu, addr, op(cpu, mem_get_byte_indy(cpu, addr)));
+}
+
+/* Words */
+
+uint16_t mem_get_word(struct cpu_t *cpu, uint16_t addr) {
+  return *((uint16_t*) &cpu->memory[addr]);
+}
+
+void mem_set_word(struct cpu_t *cpu, uint16_t addr, uint16_t v) {
+   *((uint16_t*) &cpu->memory[addr]) = v;
+}
diff --git a/mem.h b/mem.h
new file mode 100644
index 0000000..737807d
--- /dev/null
+++ b/mem.h
@@ -0,0 +1,62 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Stefan Arentz - http://github.com/st3fan/ewm
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef MEM_H
+#define MEM_H
+
+#include "cpu.h"
+
+typedef uint8_t (*mem_mod_t)(struct cpu_t *cpu, uint8_t b);
+
+uint8_t mem_get_byte(struct cpu_t *cpu, uint16_t addr);
+uint8_t mem_get_byte_abs(struct cpu_t *cpu, uint16_t addr);
+uint8_t mem_get_byte_absx(struct cpu_t *cpu, uint16_t addr);
+uint8_t mem_get_byte_absy(struct cpu_t *cpu, uint16_t addr);
+uint8_t mem_get_byte_zpg(struct cpu_t *cpu, uint8_t addr);
+uint8_t mem_get_byte_zpgx(struct cpu_t *cpu, uint8_t addr);
+uint8_t mem_get_byte_zpgy(struct cpu_t *cpu, uint8_t addr);
+uint8_t mem_get_byte_indx(struct cpu_t *cpu, uint8_t addr);
+uint8_t mem_get_byte_indy(struct cpu_t *cpu, uint8_t addr);
+
+void mem_set_byte(struct cpu_t *cpu, uint16_t addr, uint8_t v);
+void mem_set_byte_zpg(struct cpu_t *cpu, uint8_t addr, uint8_t v);
+void mem_set_byte_zpgx(struct cpu_t *cpu, uint8_t addr, uint8_t v);
+void mem_set_byte_zpgy(struct cpu_t *cpu, uint8_t addr, uint8_t v);
+void mem_set_byte_abs(struct cpu_t *cpu, uint16_t addr, uint8_t v);
+void mem_set_byte_absx(struct cpu_t *cpu, uint16_t addr, uint8_t v);
+void mem_set_byte_absy(struct cpu_t *cpu, uint16_t addr, uint8_t v);
+void mem_set_byte_indx(struct cpu_t *cpu, uint8_t addr, uint8_t v);
+void mem_set_byte_indy(struct cpu_t *cpu, uint8_t addr, uint8_t v);
+
+void mem_mod_byte_zpg(struct cpu_t *cpu, uint8_t addr, mem_mod_t op);
+void mem_mod_byte_zpgx(struct cpu_t *cpu, uint8_t addr, mem_mod_t op);
+void mem_mod_byte_zpgy(struct cpu_t *cpu, uint8_t addr, mem_mod_t op);
+void mem_mod_byte_abs(struct cpu_t *cpu, uint16_t addr, mem_mod_t op);
+void mem_mod_byte_absx(struct cpu_t *cpu, uint16_t addr, mem_mod_t op);
+void mem_mod_byte_absy(struct cpu_t *cpu, uint16_t addr, mem_mod_t op);
+void mem_mod_byte_indx(struct cpu_t *cpu, uint8_t addr, mem_mod_t op);
+void mem_mod_byte_indy(struct cpu_t *cpu, uint8_t addr, mem_mod_t op);
+
+uint16_t mem_get_word(struct cpu_t *cpu, uint16_t addr);
+void mem_set_word(struct cpu_t *cpu, uint16_t addr, uint16_t v);
+
+#endif
diff --git a/pia.c b/pia.c
new file mode 100644
index 0000000..c335a53
--- /dev/null
+++ b/pia.c
@@ -0,0 +1,119 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Stefan Arentz - http://github.com/st3fan/ewm
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <curses.h>
+
+#include "cpu.h"
+#include "pia.h"
+
+static void pia_dsp_write(uint8_t b) {
+   //fprintf(stderr, "PIA: Sending to display: %.2x / %.2x\n", b, b & 0x7f);
+   b &= 0b01111111;
+   if (b == '\r') {
+      b = '\n';
+   }
+   addch(b);
+   refresh();
+}
+
+/* static int pia_kbd_read() { */
+/*    int c = getch(); */
+/* } */
+
+/* static uint8_t pia_kbd_read() { */
+/*    return getchar(); */
+/* } */
+
+void pia_init(struct pia_t *pia) {
+   initscr();
+   raw();
+   noecho();
+   pia->a = 0;
+   pia->cra = 0;
+   pia->b = 0;
+   pia->crb = 0;
+}
+
+void pia_trace(struct pia_t *pia, uint8_t trace) {
+   pia->trace = trace;
+}
+
+uint8_t pia_read(struct cpu_t *cpu, void *obj, uint16_t addr) {
+   struct pia_t *pia = (struct pia_t*) obj;
+   uint8_t result = 0;
+   switch (addr) {
+      case 0xd010: /* KBD */
+         result = pia->a;
+         break;
+      case 0xd011: /* KBDCR */ {
+         int c = getch();
+         if (c != ERR) {
+            /* TODO: Remove this, this is not how we want to stop the emulator */
+            if (c == 3) {
+               exit(1);
+            }
+            if (c == '\n') {
+               c = '\r';
+            }
+            pia->a = c | 0x80;
+         }
+         result = (c == ERR) ? 0x00 : 0x80;
+         break;
+      }
+      case 0xd012: /* DSP */
+         result = 0;
+         break;
+      case 0xd013: /* DSPCR */
+         result = 0;
+         break;
+   }
+   if (pia->trace) {
+      fprintf(stderr, "PIA: READ BYTE %.2X FROM %.4X\n", result, addr);
+   }
+   return result;
+}
+
+void pia_write(struct cpu_t *cpu, void *obj, uint16_t addr, uint8_t b) {
+   struct pia_t *pia = (struct pia_t*) obj;
+   if (pia->trace) {
+      fprintf(stderr, "PIA: WRITING BYTE %.2X TO %.4X\n", b, addr);
+   }
+   switch (addr) {
+      case 0xd010: /* KBD */
+         break;
+      case 0xd011: /* KBDCR */
+         pia->cra = b;
+         break;
+      case 0xd012: /* DSP */
+         if (pia->crb != 0x00) { /* TODO: Check the actual flag */
+            pia_dsp_write(b);
+         }
+         break;
+      case 0xd013: /* DSPCR */
+         pia->crb = b;
+         break;
+   }
+}
diff --git a/pia.h b/pia.h
new file mode 100644
index 0000000..365429b
--- /dev/null
+++ b/pia.h
@@ -0,0 +1,42 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Stefan Arentz - http://github.com/st3fan/ewm
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef PIA_H
+#define PIA_H
+
+#include <stdint.h>
+#include "cpu.h"
+
+struct pia_t {
+  uint8_t a;
+  uint8_t cra;
+  uint8_t b;
+  uint8_t crb;
+  uint8_t trace;
+};
+
+void pia_init(struct pia_t *pia);
+void pia_trace(struct pia_t *pia, uint8_t trace);
+uint8_t pia_read(struct cpu_t *cpu, void *obj, uint16_t addr);
+void pia_write(struct cpu_t *cpu, void *obj, uint16_t addr, uint8_t b);
+
+#endif