From c3097ea5ed03d524492048bad8bdb4257cdaaffe Mon Sep 17 00:00:00 2001
From: Stefan Arentz <stefan@arentz.ca>
Date: Sat, 23 Sep 2017 21:45:19 -0400
Subject: [PATCH] Performance Improvements Part III

---
 src/cpu_bench.c |  26 +++-
 src/ins.c       | 349 +++++++++++++++++++++++++++++++-----------------
 src/mem.c       | 112 +---------------
 src/mem.h       |  52 ++++----
 src/mem_bench.c |   4 +
 src/two.c       |   5 +-
 src/two.h       |   2 +
 7 files changed, 285 insertions(+), 265 deletions(-)

diff --git a/src/cpu_bench.c b/src/cpu_bench.c
index 08db3fc..70ff5c1 100644
--- a/src/cpu_bench.c
+++ b/src/cpu_bench.c
@@ -20,6 +20,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
+#include <sys/utsname.h>
+
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
@@ -30,13 +32,26 @@
 #include "mem.h"
 #include "utl.h"
 
-#define CPU_BENCH_ITERATIONS (10 * 1000 * 1000)
+uint64_t get_iterations() {
+   struct utsname name;
+   if (uname(&name) == 0) {
+      if (strcmp(name.machine, "x86_64") == 0) {
+         return 1000 * 1000 * 1000;
+      }
+      if (strcmp(name.machine, "armv6l") == 0) {
+         return 100 * 1000 * 1000;
+      }
+   }
+   return 10 * 1000 * 1000;
+}
 
 void test(struct cpu_t *cpu, uint8_t opcode) {
    uint64_t runs[3];
 
    struct cpu_instruction_t *ins = &cpu->instructions[opcode];
 
+   uint64_t iterations = get_iterations();
+
    for (int run = 0; run < 3; run++) {
       struct timespec start;
       if (clock_gettime(CLOCK_REALTIME, &start) != 0) {
@@ -44,19 +59,22 @@ void test(struct cpu_t *cpu, uint8_t opcode) {
          exit(1);
       }
 
+      cpu->state.x = 0x12;
+      cpu->state.y = 0x12;
+
       switch (ins->bytes) {
          case 1:
-            for (uint64_t i = 0; i < CPU_BENCH_ITERATIONS; i++) {
+            for (uint64_t i = 0; i < iterations; i++) {
                ((cpu_instruction_handler_t) ins->handler)(cpu);
             }
             break;
          case 2:
-            for (uint64_t i = 0; i < CPU_BENCH_ITERATIONS; i++) {
+            for (uint64_t i = 0; i < iterations; i++) {
                ((cpu_instruction_handler_byte_t) ins->handler)(cpu, 0x12);
             }
             break;
          case 3:
-            for (uint64_t i = 0; i < CPU_BENCH_ITERATIONS; i++) {
+            for (uint64_t i = 0; i < iterations; i++) {
                ((cpu_instruction_handler_word_t) ins->handler)(cpu, 0x1234);
             }
             break;
diff --git a/src/ins.c b/src/ins.c
index ad10b00..b35fbf5 100644
--- a/src/ins.c
+++ b/src/ins.c
@@ -31,7 +31,110 @@
 #include "cpu.h"
 #include "mem.h"
 
-static void update_zn(struct cpu_t *cpu, uint8_t v) {
+// Getters
+
+static inline uint8_t get_byte_abs(struct cpu_t *cpu, uint16_t addr) {
+  return mem_get_byte(cpu, addr);
+}
+
+static inline uint8_t get_byte_absx(struct cpu_t *cpu, uint16_t addr) {
+   return mem_get_byte(cpu, addr + cpu->state.x);
+}
+
+static inline uint8_t get_byte_absy(struct cpu_t *cpu, uint16_t addr) {
+  return mem_get_byte(cpu, addr + cpu->state.y);
+}
+
+static inline uint8_t get_byte_zpg(struct cpu_t *cpu, uint8_t addr) {
+   return cpu->ram[addr];
+}
+
+static inline uint8_t get_byte_zpgx(struct cpu_t *cpu, uint8_t addr) {
+   return cpu->ram[((uint16_t) addr + cpu->state.x) & 0x00ff];
+}
+
+static inline uint8_t get_byte_zpgy(struct cpu_t *cpu, uint8_t addr) {
+   return cpu->ram[((uint16_t) addr + cpu->state.y) & 0x00ff];
+}
+
+static inline uint8_t get_byte_indx(struct cpu_t *cpu, uint8_t addr) {
+   uint16_t a = *((uint16_t*) &cpu->ram[(addr + cpu->state.x) & 0x00ff]);
+   return mem_get_byte(cpu, a);
+}
+
+static inline uint8_t get_byte_indy(struct cpu_t *cpu, uint8_t addr) {
+   uint16_t a = *((uint16_t*) &cpu->ram[addr]) + cpu->state.y;
+   return mem_get_byte(cpu, a);
+}
+
+static inline uint8_t get_byte_ind(struct cpu_t *cpu, uint8_t addr) {
+   uint16_t a = *((uint16_t*) &cpu->ram[addr]);
+   return mem_get_byte(cpu, a);
+}
+
+// Setters
+
+static inline void set_byte_zpg(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+   cpu->ram[addr] = v;
+}
+
+static inline void set_byte_zpgx(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+   cpu->ram[((uint16_t) addr + cpu->state.x) & 0x00ff] = v;
+}
+
+static inline void set_byte_zpgy(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+   cpu->ram[((uint16_t) addr + cpu->state.y) & 0x00ff] = v;
+}
+
+static inline void set_byte_abs(struct cpu_t *cpu, uint16_t addr, uint8_t v) {
+  mem_set_byte(cpu, addr, v);
+}
+
+static inline void set_byte_absx(struct cpu_t *cpu, uint16_t addr, uint8_t v) {
+  mem_set_byte(cpu, addr+cpu->state.x, v);
+}
+
+static inline void set_byte_absy(struct cpu_t *cpu, uint16_t addr, uint8_t v) {
+  mem_set_byte(cpu, addr+cpu->state.y, v);
+}
+
+static inline void set_byte_indx(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+   uint16_t a = *((uint16_t*) &cpu->ram[(addr + cpu->state.x) & 0x0ff]);
+   mem_set_byte(cpu, a, v);
+}
+
+static inline void set_byte_indy(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+   uint16_t a = *((uint16_t*) &cpu->ram[addr]) + cpu->state.y;
+   mem_set_byte(cpu, a, v);
+}
+
+static inline void set_byte_ind(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
+   uint16_t a = *((uint16_t*) &cpu->ram[addr]);
+   mem_set_byte(cpu, a, v);
+}
+
+// Modifiers
+
+static inline void mod_byte_zpg(struct cpu_t *cpu, uint8_t addr, mem_mod_t op) {
+   cpu->ram[addr] = op(cpu, cpu->ram[addr]);
+}
+
+static inline void mod_byte_zpgx(struct cpu_t *cpu, uint8_t addr, mem_mod_t op) {
+   uint8_t a = ((uint16_t) addr + cpu->state.x) & 0x00ff;
+   cpu->ram[a] = op(cpu, cpu->ram[a]);
+}
+
+static inline void mod_byte_abs(struct cpu_t *cpu, uint16_t addr, mem_mod_t op) {
+  set_byte_abs(cpu, addr, op(cpu, get_byte_abs(cpu, addr)));
+}
+
+static inline void mod_byte_absx(struct cpu_t *cpu, uint16_t addr, mem_mod_t op) {
+  set_byte_absx(cpu, addr, op(cpu, get_byte_absx(cpu, addr)));
+}
+
+// Utilities
+
+static inline void update_zn(struct cpu_t *cpu, uint8_t v) {
   cpu->state.z = (v == 0x00);
   cpu->state.n = (v & 0x80);
 }
@@ -80,31 +183,31 @@ static void adc_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void adc_zpg(struct cpu_t *cpu, uint8_t oper) {
-  adc(cpu, mem_get_byte_zpg(cpu, oper));
+  adc(cpu, get_byte_zpg(cpu, oper));
 }
 
 static void adc_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  adc(cpu, mem_get_byte_zpgx(cpu, oper));
+  adc(cpu, get_byte_zpgx(cpu, oper));
 }
 
 static void adc_abs(struct cpu_t *cpu, uint16_t oper) {
-  adc(cpu, mem_get_byte_abs(cpu, oper));
+  adc(cpu, get_byte_abs(cpu, oper));
 }
 
 static void adc_absx(struct cpu_t *cpu, uint16_t oper) {
-  adc(cpu, mem_get_byte_absx(cpu, oper));
+  adc(cpu, get_byte_absx(cpu, oper));
 }
 
 static void adc_absy(struct cpu_t *cpu, uint16_t oper) {
-  adc(cpu, mem_get_byte_absy(cpu, oper));
+  adc(cpu, get_byte_absy(cpu, oper));
 }
 
 static void adc_indx(struct cpu_t *cpu, uint8_t oper) {
-  adc(cpu, mem_get_byte_indx(cpu, oper));
+  adc(cpu, get_byte_indx(cpu, oper));
 }
 
 static void adc_indy(struct cpu_t *cpu, uint8_t oper) {
-  adc(cpu, mem_get_byte_indy(cpu, oper));
+  adc(cpu, get_byte_indy(cpu, oper));
 }
 
 /* AND */
@@ -119,31 +222,31 @@ static void and_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void and_zpg(struct cpu_t *cpu, uint8_t oper) {
-  and(cpu, mem_get_byte_zpg(cpu, oper));
+  and(cpu, get_byte_zpg(cpu, oper));
 }
 
 static void and_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  and(cpu, mem_get_byte_zpgx(cpu, oper));
+  and(cpu, get_byte_zpgx(cpu, oper));
 }
 
 static void and_abs(struct cpu_t *cpu, uint16_t oper) {
-  and(cpu, mem_get_byte_abs(cpu, oper));
+  and(cpu, get_byte_abs(cpu, oper));
 }
 
 static void and_absx(struct cpu_t *cpu, uint16_t oper) {
-  and(cpu, mem_get_byte_absx(cpu, oper));
+  and(cpu, get_byte_absx(cpu, oper));
 }
 
 static void and_absy(struct cpu_t *cpu, uint16_t oper) {
-  and(cpu, mem_get_byte_absy(cpu, oper));
+  and(cpu, get_byte_absy(cpu, oper));
 }
 
 static void and_indx(struct cpu_t *cpu, uint8_t oper) {
-  and(cpu, mem_get_byte_indx(cpu, oper));
+  and(cpu, get_byte_indx(cpu, oper));
 }
 
 static void and_indy(struct cpu_t *cpu, uint8_t oper) {
-  and(cpu, mem_get_byte_indy(cpu, oper));
+  and(cpu, get_byte_indy(cpu, oper));
 }
 
 /* ASL */
@@ -161,19 +264,19 @@ static void asl_acc(struct cpu_t *cpu) {
 }
 
 static void asl_zpg(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpg(cpu, oper, asl);
+  mod_byte_zpg(cpu, oper, asl);
 }
 
 static void asl_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpgx(cpu, oper, asl);
+  mod_byte_zpgx(cpu, oper, asl);
 }
 
 static void asl_abs(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_abs(cpu, oper, asl);
+  mod_byte_abs(cpu, oper, asl);
 }
 
 static void asl_absx(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_absx(cpu, oper, asl);
+  mod_byte_absx(cpu, oper, asl);
 }
 
 /* BIT */
@@ -186,11 +289,11 @@ static void bit(struct cpu_t *cpu, uint8_t m) {
 }
 
 static void bit_zpg(struct cpu_t *cpu, uint8_t oper) {
-  bit(cpu, mem_get_byte_zpg(cpu, oper));
+  bit(cpu, get_byte_zpg(cpu, oper));
 }
 
 static void bit_abs(struct cpu_t *cpu, uint16_t oper) {
-  bit(cpu, mem_get_byte_abs(cpu, oper));
+  bit(cpu, get_byte_abs(cpu, oper));
 }
 
 /* Bxx Branches */
@@ -285,31 +388,31 @@ static void cmp_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void cmp_zpg(struct cpu_t *cpu, uint8_t oper) {
-  cmp(cpu, mem_get_byte_zpg(cpu, oper));
+  cmp(cpu, get_byte_zpg(cpu, oper));
 }
 
 static void cmp_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  cmp(cpu, mem_get_byte_zpgx(cpu, oper));
+  cmp(cpu, get_byte_zpgx(cpu, oper));
 }
 
 static void cmp_abs(struct cpu_t *cpu, uint16_t oper) {
-  cmp(cpu, mem_get_byte_abs(cpu, oper));
+  cmp(cpu, get_byte_abs(cpu, oper));
 }
 
 static void cmp_absx(struct cpu_t *cpu, uint16_t oper) {
-  cmp(cpu, mem_get_byte_absx(cpu, oper));
+  cmp(cpu, get_byte_absx(cpu, oper));
 }
 
 static void cmp_absy(struct cpu_t *cpu, uint16_t oper) {
-  cmp(cpu, mem_get_byte_absy(cpu, oper));
+  cmp(cpu, get_byte_absy(cpu, oper));
 }
 
 static void cmp_indx(struct cpu_t *cpu, uint8_t oper) {
-  cmp(cpu, mem_get_byte_indx(cpu, oper));
+  cmp(cpu, get_byte_indx(cpu, oper));
 }
 
 static void cmp_indy(struct cpu_t *cpu, uint8_t oper) {
-  cmp(cpu, mem_get_byte_indy(cpu, oper));
+  cmp(cpu, get_byte_indy(cpu, oper));
 }
 
 /* CPX */
@@ -325,11 +428,11 @@ static void cpx_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void cpx_zpg(struct cpu_t *cpu, uint8_t oper) {
-  cpx(cpu, mem_get_byte_zpg(cpu, oper));
+  cpx(cpu, get_byte_zpg(cpu, oper));
 }
 
 static void cpx_abs(struct cpu_t *cpu, uint16_t oper) {
-  cpx(cpu, mem_get_byte_abs(cpu, oper));
+  cpx(cpu, get_byte_abs(cpu, oper));
 }
 
 /* CPY */
@@ -345,11 +448,11 @@ static void cpy_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void cpy_zpg(struct cpu_t *cpu, uint8_t oper) {
-  cpy(cpu, mem_get_byte_zpg(cpu, oper));
+  cpy(cpu, get_byte_zpg(cpu, oper));
 }
 
 static void cpy_abs(struct cpu_t *cpu, uint16_t oper) {
-  cpy(cpu, mem_get_byte_abs(cpu, oper));
+  cpy(cpu, get_byte_abs(cpu, oper));
 }
 
 /* DEx */
@@ -361,19 +464,19 @@ static uint8_t dec(struct cpu_t *cpu, uint8_t b) {
 }
 
 static void dec_zpg(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpg(cpu, oper, dec);
+  mod_byte_zpg(cpu, oper, dec);
 }
 
 static void dec_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpgx(cpu, oper, dec);
+  mod_byte_zpgx(cpu, oper, dec);
 }
 
 static void dec_abs(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_abs(cpu, oper, dec);
+  mod_byte_abs(cpu, oper, dec);
 }
 
 static void dec_absx(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_absx(cpu, oper, dec);
+  mod_byte_absx(cpu, oper, dec);
 }
 
 static void dex(struct cpu_t *cpu) {
@@ -398,31 +501,31 @@ static void eor_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void eor_zpg(struct cpu_t *cpu, uint8_t oper) {
-  eor(cpu, mem_get_byte_zpg(cpu, oper));
+  eor(cpu, get_byte_zpg(cpu, oper));
 }
 
 static void eor_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  eor(cpu, mem_get_byte_zpgx(cpu, oper));
+  eor(cpu, get_byte_zpgx(cpu, oper));
 }
 
 static void eor_abs(struct cpu_t *cpu, uint16_t oper) {
-  eor(cpu, mem_get_byte_abs(cpu, oper));
+  eor(cpu, get_byte_abs(cpu, oper));
 }
 
 static void eor_absx(struct cpu_t *cpu, uint16_t oper) {
-  eor(cpu, mem_get_byte_absx(cpu, oper));
+  eor(cpu, get_byte_absx(cpu, oper));
 }
 
 static void eor_absy(struct cpu_t *cpu, uint16_t oper) {
-  eor(cpu, mem_get_byte_absy(cpu, oper));
+  eor(cpu, get_byte_absy(cpu, oper));
 }
 
 static void eor_indx(struct cpu_t *cpu, uint8_t oper) {
-  eor(cpu, mem_get_byte_indx(cpu, oper));
+  eor(cpu, get_byte_indx(cpu, oper));
 }
 
 static void eor_indy(struct cpu_t *cpu, uint8_t oper) {
-  eor(cpu, mem_get_byte_indy(cpu, oper));
+  eor(cpu, get_byte_indy(cpu, oper));
 }
 
 /* INx */
@@ -434,19 +537,19 @@ static uint8_t inc(struct cpu_t *cpu, uint8_t b) {
 }
 
 static void inc_zpg(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpg(cpu, oper, inc);
+  mod_byte_zpg(cpu, oper, inc);
 }
 
 static void inc_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpgx(cpu, oper, inc);
+  mod_byte_zpgx(cpu, oper, inc);
 }
 
 static void inc_abs(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_abs(cpu, oper, inc);
+  mod_byte_abs(cpu, oper, inc);
 }
 
 static void inc_absx(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_absx(cpu, oper, inc);
+  mod_byte_absx(cpu, oper, inc);
 }
 
 static void inx(struct cpu_t *cpu) {
@@ -484,37 +587,37 @@ static void lda_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void lda_zpg(struct cpu_t *cpu, uint8_t oper) {
-  cpu->state.a = mem_get_byte_zpg(cpu, oper);
+  cpu->state.a = 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);
+  cpu->state.a = 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);
+  cpu->state.a = 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);
+  cpu->state.a = 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);
+  cpu->state.a = 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);
+  cpu->state.a = 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);
+  cpu->state.a = get_byte_indy(cpu, oper);
   update_zn(cpu, cpu->state.a);
 }
 
@@ -526,22 +629,22 @@ static void ldx_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void ldx_zpg(struct cpu_t *cpu, uint8_t oper) {
-  cpu->state.x = mem_get_byte_zpg(cpu, oper);
+  cpu->state.x = 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);
+  cpu->state.x = 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);
+  cpu->state.x = 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);
+  cpu->state.x = get_byte_absy(cpu, oper);
   update_zn(cpu, cpu->state.x);
 }
 
@@ -553,22 +656,22 @@ static void ldy_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void ldy_zpg(struct cpu_t *cpu, uint8_t oper) {
-  cpu->state.y = mem_get_byte_zpg(cpu, oper);
+  cpu->state.y = 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);
+  cpu->state.y = 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);
+  cpu->state.y = 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);
+  cpu->state.y = get_byte_absx(cpu, oper);
   update_zn(cpu, cpu->state.y);
 }
 
@@ -586,18 +689,18 @@ static void lsr_acc(struct cpu_t *cpu) {
 }
 
 static void lsr_zpg(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpg(cpu, oper, lsr);
+  mod_byte_zpg(cpu, oper, lsr);
 }
 
 static void lsr_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpgx(cpu, oper, lsr);
+  mod_byte_zpgx(cpu, oper, lsr);
 }
 
 static void lsr_abs(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_abs(cpu, oper, lsr);
+  mod_byte_abs(cpu, oper, lsr);
 }
 static void lsr_absx(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_absx(cpu, oper, lsr);
+  mod_byte_absx(cpu, oper, lsr);
 }
 
 /* NOP */
@@ -617,31 +720,31 @@ static void ora_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void ora_zpg(struct cpu_t *cpu, uint8_t oper) {
-  ora(cpu, mem_get_byte_zpg(cpu, oper));
+  ora(cpu, get_byte_zpg(cpu, oper));
 }
 
 static void ora_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  ora(cpu, mem_get_byte_zpgx(cpu, oper));
+  ora(cpu, get_byte_zpgx(cpu, oper));
 }
 
 static void ora_abs(struct cpu_t *cpu, uint16_t oper) {
-  ora(cpu, mem_get_byte_abs(cpu, oper));
+  ora(cpu, get_byte_abs(cpu, oper));
 }
 
 static void ora_absx(struct cpu_t *cpu, uint16_t oper) {
-  ora(cpu, mem_get_byte_absx(cpu, oper));
+  ora(cpu, get_byte_absx(cpu, oper));
 }
 
 static void ora_absy(struct cpu_t *cpu, uint16_t oper) {
-  ora(cpu, mem_get_byte_absy(cpu, oper));
+  ora(cpu, get_byte_absy(cpu, oper));
 }
 
 static void ora_indx(struct cpu_t *cpu, uint8_t oper) {
-  ora(cpu, mem_get_byte_indx(cpu, oper));
+  ora(cpu, get_byte_indx(cpu, oper));
 }
 
 static void ora_indy(struct cpu_t *cpu, uint8_t oper) {
-  ora(cpu, mem_get_byte_indy(cpu, oper));
+  ora(cpu, get_byte_indy(cpu, oper));
 }
 
 
@@ -679,19 +782,19 @@ static void rol_acc(struct cpu_t *cpu) {
 }
 
 static void rol_zpg(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpg(cpu, oper, rol);
+  mod_byte_zpg(cpu, oper, rol);
 }
 
 static void rol_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpgx(cpu, oper, rol);
+  mod_byte_zpgx(cpu, oper, rol);
 }
 
 static void rol_abs(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_abs(cpu, oper, rol);
+  mod_byte_abs(cpu, oper, rol);
 }
 
 static void rol_absx(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_absx(cpu, oper, rol);
+  mod_byte_absx(cpu, oper, rol);
 }
 
 /* ROR */
@@ -709,19 +812,19 @@ static void ror_acc(struct cpu_t *cpu) {
 }
 
 static void ror_zpg(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpg(cpu, oper, ror);
+  mod_byte_zpg(cpu, oper, ror);
 }
 
 static void ror_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  mem_mod_byte_zpgx(cpu, oper, ror);
+  mod_byte_zpgx(cpu, oper, ror);
 }
 
 static void ror_abs(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_abs(cpu, oper, ror);
+  mod_byte_abs(cpu, oper, ror);
 }
 
 static void ror_absx(struct cpu_t *cpu, uint16_t oper) {
-  mem_mod_byte_absx(cpu, oper, ror);
+  mod_byte_absx(cpu, oper, ror);
 }
 
 /* RTI */
@@ -781,31 +884,31 @@ static void sbc_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void sbc_zpg(struct cpu_t *cpu, uint8_t oper) {
-  sbc(cpu, mem_get_byte_zpg(cpu, oper));
+  sbc(cpu, get_byte_zpg(cpu, oper));
 }
 
 static void sbc_zpgx(struct cpu_t *cpu, uint8_t oper) {
-  sbc(cpu, mem_get_byte_zpgx(cpu, oper));
+  sbc(cpu, get_byte_zpgx(cpu, oper));
 }
 
 static void sbc_abs(struct cpu_t *cpu, uint16_t oper) {
-  sbc(cpu, mem_get_byte_abs(cpu, oper));
+  sbc(cpu, get_byte_abs(cpu, oper));
 }
 
 static void sbc_absx(struct cpu_t *cpu, uint16_t oper) {
-  sbc(cpu, mem_get_byte_absx(cpu, oper));
+  sbc(cpu, get_byte_absx(cpu, oper));
 }
 
 static void sbc_absy(struct cpu_t *cpu, uint16_t oper) {
-  sbc(cpu, mem_get_byte_absy(cpu, oper));
+  sbc(cpu, get_byte_absy(cpu, oper));
 }
 
 static void sbc_indx(struct cpu_t *cpu, uint8_t oper) {
-  sbc(cpu, mem_get_byte_indx(cpu, oper));
+  sbc(cpu, get_byte_indx(cpu, oper));
 }
 
 static void sbc_indy(struct cpu_t *cpu, uint8_t oper) {
-  sbc(cpu, mem_get_byte_indy(cpu, oper));
+  sbc(cpu, get_byte_indy(cpu, oper));
 }
 
 /* SEx */
@@ -825,59 +928,59 @@ static void sei(struct cpu_t *cpu) {
 /* STA */
 
 static void sta_zpg(struct cpu_t *cpu, uint8_t oper) {
-  mem_set_byte_zpg(cpu, oper, cpu->state.a);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  set_byte_abs(cpu, oper, cpu->state.y);
 }
 
 /* Txx */
@@ -1186,36 +1289,36 @@ struct cpu_instruction_t instructions[256] = {
 // EWM_CPU_MODEL_65C02
 
 static void ora_ind(struct cpu_t *cpu, uint8_t oper) {
-   ora(cpu, mem_get_byte_ind(cpu, oper));
+   ora(cpu, get_byte_ind(cpu, oper));
 }
 
 static void and_ind(struct cpu_t *cpu, uint8_t oper) {
-   and(cpu, mem_get_byte_ind(cpu, oper));
+   and(cpu, get_byte_ind(cpu, oper));
 }
 
 static void eor_ind(struct cpu_t *cpu, uint8_t oper) {
-   eor(cpu, mem_get_byte_ind(cpu, oper));
+   eor(cpu, get_byte_ind(cpu, oper));
 }
 
 static void adc_ind(struct cpu_t *cpu, uint8_t oper) {
-   adc(cpu, mem_get_byte_ind(cpu, oper));
+   adc(cpu, get_byte_ind(cpu, oper));
 }
 
 static void sta_ind(struct cpu_t *cpu, uint8_t oper) {
-   mem_set_byte_ind(cpu, oper, cpu->state.a);
+   set_byte_ind(cpu, oper, cpu->state.a);
 }
 
 static void lda_ind(struct cpu_t *cpu, uint8_t oper) {
-   cpu->state.a = mem_get_byte_ind(cpu, oper);
+   cpu->state.a = get_byte_ind(cpu, oper);
    update_zn(cpu, cpu->state.a);
 }
 
 static void cmp_ind(struct cpu_t *cpu, uint8_t oper) {
-   cmp(cpu, mem_get_byte_ind(cpu, oper));
+   cmp(cpu, get_byte_ind(cpu, oper));
 }
 
 static void sbc_ind(struct cpu_t *cpu, uint8_t oper) {
-   sbc(cpu, mem_get_byte_ind(cpu, oper));
+   sbc(cpu, get_byte_ind(cpu, oper));
 }
 
 static void bit_imm(struct cpu_t *cpu, uint8_t oper) {
@@ -1224,11 +1327,11 @@ static void bit_imm(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void bit_zpgx(struct cpu_t *cpu, uint8_t oper) {
-   bit(cpu, mem_get_byte_zpgx(cpu, oper));
+   bit(cpu, get_byte_zpgx(cpu, oper));
 }
 
 static void bit_absx(struct cpu_t *cpu, uint16_t oper) {
-   bit(cpu, mem_get_byte_absx(cpu, oper));
+   bit(cpu, get_byte_absx(cpu, oper));
 }
 
 static void dec_acc(struct cpu_t *cpu) {
@@ -1268,47 +1371,47 @@ static void ply(struct cpu_t *cpu) {
 }
 
 static void stz_zpg(struct cpu_t *cpu, uint8_t oper) {
-   mem_set_byte_zpg(cpu, oper, 0x00);
+   set_byte_zpg(cpu, oper, 0x00);
 }
 
 static void stz_zpgx(struct cpu_t *cpu, uint8_t oper) {
-   mem_set_byte_zpgx(cpu, oper, 0x00);
+   set_byte_zpgx(cpu, oper, 0x00);
 }
 
 static void stz_abs(struct cpu_t *cpu, uint16_t oper) {
-   mem_set_byte_abs(cpu, oper, 0x00);
+   set_byte_abs(cpu, oper, 0x00);
 }
 
 static void stz_absx(struct cpu_t *cpu, uint16_t oper) {
-   mem_set_byte_absx(cpu, oper, 0x00);
+   set_byte_absx(cpu, oper, 0x00);
 }
 
 static void trb_zpg(struct cpu_t *cpu, uint8_t oper) {
    cpu->state.z = (mem_get_byte(cpu, oper) & cpu->state.a) == 0;
    uint8_t r = mem_get_byte(cpu, oper) & ~cpu->state.a;
-   mem_set_byte_zpg(cpu, oper, r);
+   set_byte_zpg(cpu, oper, r);
 }
 
 static void trb_abs(struct cpu_t *cpu, uint16_t oper) {
    cpu->state.z = (mem_get_byte(cpu, oper) & cpu->state.a) == 0;
    uint8_t r = mem_get_byte(cpu, oper) & (cpu->state.a ^ 0xff);
-   mem_set_byte_abs(cpu, oper, r);
+   set_byte_abs(cpu, oper, r);
 }
 
 static void tsb_zpg(struct cpu_t *cpu, uint8_t oper) {
    cpu->state.z = (mem_get_byte(cpu, oper) & cpu->state.a) == 0;
    uint8_t r = mem_get_byte(cpu, oper) | cpu->state.a;
-   mem_set_byte_zpg(cpu, oper, r);
+   set_byte_zpg(cpu, oper, r);
 }
 
 static void tsb_abs(struct cpu_t *cpu, uint16_t oper) {
    cpu->state.z = (mem_get_byte(cpu, oper) & cpu->state.a) == 0;
    uint8_t r = mem_get_byte(cpu, oper) | cpu->state.a;
-   mem_set_byte_abs(cpu, oper, r);
+   set_byte_abs(cpu, oper, r);
 }
 
 static void bbr(struct cpu_t *cpu, uint8_t bit, uint8_t zp, int8_t label) {
-   if ((mem_get_byte_zpg(cpu, zp) & bit) == 0) {
+   if ((get_byte_zpg(cpu, zp) & bit) == 0) {
       cpu->state.pc += label;
    }
 }
@@ -1346,7 +1449,7 @@ static void bbr7(struct cpu_t *cpu, uint16_t oper) {
 }
 
 static void bbs(struct cpu_t *cpu, uint8_t bit, uint8_t zp, int8_t label) {
-   if ((mem_get_byte_zpg(cpu, zp) & bit) != 0) {
+   if ((get_byte_zpg(cpu, zp) & bit) != 0) {
       cpu->state.pc += label;
    }
 }
@@ -1384,7 +1487,7 @@ static void bbs7(struct cpu_t *cpu, uint16_t oper) {
 }
 
 static void rmb(struct cpu_t *cpu, uint8_t bit, uint8_t zp) {
-   mem_set_byte_zpg(cpu, zp, mem_get_byte(cpu, zp) & ~bit);
+   set_byte_zpg(cpu, zp, mem_get_byte(cpu, zp) & ~bit);
 }
 
 static void rmb0(struct cpu_t *cpu, uint8_t oper) {
@@ -1420,7 +1523,7 @@ static void rmb7(struct cpu_t *cpu, uint8_t oper) {
 }
 
 static void smb(struct cpu_t *cpu, uint8_t bit, uint8_t zp) {
-   mem_set_byte_zpg(cpu, zp, mem_get_byte(cpu, zp) | bit);
+   set_byte_zpg(cpu, zp, mem_get_byte(cpu, zp) | bit);
 }
 
 static void smb0(struct cpu_t *cpu, uint8_t oper) {
diff --git a/src/mem.c b/src/mem.c
index 2f1b80a..b916d86 100644
--- a/src/mem.c
+++ b/src/mem.c
@@ -50,8 +50,6 @@ uint8_t mem_get_byte(struct cpu_t *cpu, uint16_t addr) {
    return 0;
 }
 
-extern struct ewm_two_t *two;
-
 void mem_set_byte(struct cpu_t *cpu, uint16_t addr, uint8_t v) {
    if (addr < cpu->ram_size) {
       cpu->ram[addr] = v;
@@ -70,125 +68,17 @@ void mem_set_byte(struct cpu_t *cpu, uint16_t addr, uint8_t v) {
    }
 }
 
-// Getters
-
-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);
-}
-
-uint8_t mem_get_byte_absy(struct cpu_t *cpu, uint16_t addr) {
-  return mem_get_byte(cpu, addr + cpu->state.y);
-}
-
-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, (((uint16_t) cpu->ram[((uint16_t)addr+1+cpu->state.x)&0x00ff] << 8) | (uint16_t) cpu->ram[((uint16_t) addr+cpu->state.x) & 0x00ff]));
-}
-
-uint8_t mem_get_byte_indy(struct cpu_t *cpu, uint8_t addr) {
-   return mem_get_byte(cpu, (((uint16_t) cpu->ram[addr+1] << 8) | (uint16_t) cpu->ram[addr]) + cpu->state.y);
-}
-
-uint8_t mem_get_byte_ind(struct cpu_t *cpu, uint8_t addr) {
-   return mem_get_byte(cpu, ((uint16_t) cpu->ram[addr+1] << 8) | (uint16_t) cpu->ram[addr]);
-}
+// TODO Where are these used?
 
 uint16_t mem_get_word(struct cpu_t *cpu, uint16_t addr) {
   return ((uint16_t) mem_get_byte(cpu, addr+1) << 8) | (uint16_t) mem_get_byte(cpu, addr);
 }
 
-// Setters
-
-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, (((uint16_t) cpu->ram[((uint16_t)addr+1+cpu->state.x)&0x00ff] << 8) | (uint16_t) cpu->ram[((uint16_t) addr+cpu->state.x) & 0x00ff]), v);
-}
-
-void mem_set_byte_indy(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
-   mem_set_byte(cpu, (((uint16_t) cpu->ram[addr+1] << 8) | (uint16_t) cpu->ram[addr]) + cpu->state.y, v);
-}
-
-void mem_set_byte_ind(struct cpu_t *cpu, uint8_t addr, uint8_t v) {
-   mem_set_byte(cpu, (((uint16_t) cpu->ram[addr+1] << 8) | (uint16_t) cpu->ram[addr]), v);
-}
-
 void mem_set_word(struct cpu_t *cpu, uint16_t addr, uint16_t v) {
   mem_set_byte(cpu, addr+0, (uint8_t) v); // TODO Did I do this right?
   mem_set_byte(cpu, addr+1, (uint8_t) (v >> 8));
 }
 
-/* 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)));
-}
-
 // For parsing --memory options
 
 struct ewm_memory_option_t *parse_memory_option(char *s) {
diff --git a/src/mem.h b/src/mem.h
index 4470834..28053b0 100644
--- a/src/mem.h
+++ b/src/mem.h
@@ -32,34 +32,34 @@ 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);
 void mem_set_byte(struct cpu_t *cpu, uint16_t addr, uint8_t v);
 
-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);
-uint8_t mem_get_byte_ind(struct cpu_t *cpu, uint8_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); */
+/* uint8_t mem_get_byte_ind(struct cpu_t *cpu, uint8_t addr); */
 
-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_set_byte_ind(struct cpu_t *cpu, uint8_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_set_byte_ind(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);
+/* 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);
diff --git a/src/mem_bench.c b/src/mem_bench.c
index 97ab5a4..e5ee434 100644
--- a/src/mem_bench.c
+++ b/src/mem_bench.c
@@ -28,6 +28,7 @@
 #include "mem.h"
 #include "utl.h"
 
+#if 0
 #define MEM_BENCH_ITERATIONS (100 * 1000 * 1000)
 
 #define MEM_GET_TEST(NAME, ADDR) \
@@ -150,8 +151,10 @@ void test(struct cpu_t *cpu, char *name, test_run_t test_run) {
 
    printf("%-32s %8llu\n", name, duration_ms);
 }
+#endif
 
 int main(int argc, char **argv) {
+#if 0
    struct cpu_t *cpu = cpu_create(EWM_CPU_MODEL_6502);
    cpu_add_ram_data(cpu, 0, 0xffff, malloc(0xffff));
    cpu_reset(cpu);
@@ -185,4 +188,5 @@ int main(int argc, char **argv) {
    RUN_TEST(mem_set_byte_ind, 0x12);
    RUN_TEST(mem_set_byte_indx, 0x12);
    RUN_TEST(mem_set_byte_indy, 0x12);
+#endif
 }
diff --git a/src/two.c b/src/two.c
index d5b3164..7e8dc5d 100644
--- a/src/two.c
+++ b/src/two.c
@@ -509,6 +509,9 @@ static bool ewm_two_poll_event(struct ewm_two_t *two, SDL_Window *window) { // T
                      SDL_SetWindowSize(window, 40*7*3, 24*8*3 + (two->status_bar_visible ? (9*3) : 0));
                      SDL_RenderSetLogicalSize(two->scr->renderer, 40*7*3, 24*8*3 + (two->status_bar_visible ? (9*3) : 0));
                      break;
+                  case SDLK_p:
+                     two->paused = !two->paused;
+                     break;
                }
             } else if (event.key.keysym.mod == KMOD_NONE) {
                switch (event.key.keysym.sym) {
@@ -882,7 +885,7 @@ int ewm_two_main(int argc, char **argv) {
          break;
       }
 
-      if ((SDL_GetTicks() - ticks) >= (1000 / fps)) {
+      if (!two->paused && (SDL_GetTicks() - ticks) >= (1000 / fps)) {
          if (!ewm_two_step_cpu(two, EWM_TWO_SPEED / fps)) {
             break;
          }
diff --git a/src/two.h b/src/two.h
index 311588b..b225a9b 100644
--- a/src/two.h
+++ b/src/two.h
@@ -96,6 +96,8 @@ struct ewm_two_t {
 
    int lua_key_down_fn;
    int lua_key_up_fn;
+
+   bool paused;
 };
 
 struct ewm_two_t *ewm_two_create(int type, SDL_Renderer *renderer, SDL_Joystick *joystick);