From 0f63282931ff76c0ac9c925538d7529798837cd8 Mon Sep 17 00:00:00 2001
From: Steven Hugg <hugg@fasterlight.com>
Date: Wed, 21 Aug 2019 22:55:32 -0400
Subject: [PATCH] working on new emulator framework

---
 index.html                             |    3 +
 src/emu.ts                             |    2 +-
 src/nemu/cpu/MOS6502.ts                | 1949 ++++++++++++++++++++++++
 src/nemu/machine/apple2.ts             | 1103 ++++++++++++++
 src/nemu/nemu.ts                       |  165 ++
 src/platform/apple2.ts                 |   61 +-
 test/cli/6502/6502_functional_test.bin |  Bin 0 -> 65536 bytes
 test/cli/6502/test6502sim.js           |   68 +
 8 files changed, 3349 insertions(+), 2 deletions(-)
 create mode 100644 src/nemu/cpu/MOS6502.ts
 create mode 100644 src/nemu/machine/apple2.ts
 create mode 100644 src/nemu/nemu.ts
 create mode 100644 test/cli/6502/6502_functional_test.bin
 create mode 100644 test/cli/6502/test6502sim.js

diff --git a/index.html b/index.html
index b633b7f7..10c0019c 100644
--- a/index.html
+++ b/index.html
@@ -542,6 +542,9 @@ function require(modname) {
 <script src="gen/ui.js"></script>
 <!-- <script src="src/audio/votrax.js"></script> -->
 <!-- <script src="local/lzg.js"></script> -->
+<script src="gen/nemu/nemu.js"></script>
+<script src="gen/nemu/cpu/MOS6502.js"></script>
+<script src="gen/nemu/machine/apple2.js"></script>
 
 <script>
 // submenus open on click + hover
diff --git a/src/emu.ts b/src/emu.ts
index 09bbcba3..efcd4edc 100644
--- a/src/emu.ts
+++ b/src/emu.ts
@@ -125,7 +125,7 @@ export class RasterVideo {
 
   getContext() { return this.ctx; }
 
-  updateFrame(sx:number, sy:number, dx:number, dy:number, w?:number, h?:number) {
+  updateFrame(sx?:number, sy?:number, dx?:number, dy?:number, w?:number, h?:number) {
     if (w && h)
       this.ctx.putImageData(this.imageData, sx, sy, dx, dy, w, h);
     else
diff --git a/src/nemu/cpu/MOS6502.ts b/src/nemu/cpu/MOS6502.ts
new file mode 100644
index 00000000..afad2c40
--- /dev/null
+++ b/src/nemu/cpu/MOS6502.ts
@@ -0,0 +1,1949 @@
+
+import { CPU, Bus, ClockBased, SavesState, Interruptable } from "../nemu";
+
+// Copyright 2015 by Paulo Augusto Peccin. See license.txt distributed with this file.
+
+var _MOS6502 = function() {
+    var self = this;
+
+    this.powerOn = function() {
+        this.reset();
+    };
+
+    this.powerOff = function() {
+    };
+
+    this.clockPulse = function() {
+        if (!RDY) return;      // TODO Should be ignored in the last cycle of the instruction
+        T++;
+        instruction[T]();
+    };
+
+    this.connectBus = function(aBus) {
+        bus = aBus;
+    };
+
+    this.setRDY = function(boo) {
+        RDY = boo;
+    };
+
+    this.isRDY = function() {
+        return RDY;
+    }
+
+    this.reset = function() {
+        I = 1;
+        T = -1;
+        instruction = [ fetchOpcodeAndDecodeInstruction ];    // Bootstrap instruction
+        PC = bus.read(RESET_VECTOR) | (bus.read(RESET_VECTOR + 1) << 8);
+        this.setRDY(true);
+    };
+
+    // Interfaces
+    var bus : Bus;
+    var RDY : boolean = false;
+
+    // Registers
+    var PC : number = 0;
+    var SP : number = 0;
+    var A : number = 0;
+    var X : number = 0;
+    var Y : number = 0;
+
+    // Status Bits
+    var N : number = 0;
+    var V : number = 0;
+    var D : number = 0;
+    var I : number = 0;
+    var Z : number = 0;
+    var C : number = 0;
+
+    // Internal decoding registers
+    var T : number = -1;
+    var opcode : number = -1;
+    var instruction;
+    var data : number = 0;
+    var AD : number = 0;
+    var BA : number = 0;
+    var BALCrossed : boolean = false;
+    var IA : number = 0;
+    var branchOffset : number = 0;
+    var branchOffsetCrossAdjust : number = 0;
+
+    // Vectors
+    const NMI_VECTOR = 0xfffa;
+    const RESET_VECTOR = 0xfffc;
+    const IRQ_VECTOR = 0xfffe;
+
+    // Index registers names
+    const rX = 0;
+    const rY = 1;
+
+    // Status bits names
+    const bN = 7;
+    const bV = 6;
+    // const bE = 5;	// Not used
+    // const bB = 4;	// Not used
+    // const bD = 3;  // Not used
+    // const bI = 2;  // Not used
+    const bZ = 1;
+    const bC = 0;
+
+    // Auxiliary variables
+    //noinspection JSUnusedGlobalSymbols
+    this.debug = false;
+    //noinspection JSUnusedGlobalSymbols
+    this.trace = false;
+
+
+    // Internal operations
+
+    var fetchOpcodeAndDecodeInstruction = function() {
+        opcode = bus.read(PC);
+        instruction = instructions[opcode];
+        T = 0;
+
+        // if (self.trace) self.breakpoint("TRACE");
+        // console.log("PC: " + PC + ", op: " + opcode + ": " + opcodes[opcode]);
+
+        PC++;
+    };
+
+    var fetchNextOpcode = fetchOpcodeAndDecodeInstruction;
+
+    var fetchOpcodeAndDiscard = function() {
+        bus.read(PC);
+    };
+
+    var fetchBranchOffset = function() {
+        branchOffset = bus.read(PC);
+        PC++;
+    };
+
+    var fetchADL = function() {
+        AD = bus.read(PC);
+        PC++;
+    };
+
+    var fetchADH = function() {
+        AD |= bus.read(PC) << 8;
+        PC++;
+    };
+
+    var fetchADLFromBA = function() {
+        AD = bus.read(BA);
+    };
+
+    var fetchADHFromBA = function() {
+        AD |= bus.read(BA) << 8;
+    };
+
+    var fetchBAL = function() {
+        BA = bus.read(PC);
+        PC++;
+    };
+
+    var fetchBAH = function() {
+        BA |= bus.read(PC) << 8;
+        PC++;
+    };
+
+    var fetchBALFromIA = function() {
+        BA = bus.read(IA);
+    };
+
+    var fetchBAHFromIA = function() {
+        BA |= bus.read(IA) << 8;
+    };
+
+    var addXtoBAL = function() {
+        var low = (BA & 255) + X;
+        BALCrossed = low > 255;
+        BA = (BA & 0xff00) | (low & 255);
+    };
+
+    var addYtoBAL = function() {
+        var low = (BA & 255) + Y;
+        BALCrossed = low > 255;
+        BA = (BA & 0xff00) | (low & 255);
+    };
+
+    var add1toBAL = function() {
+        var low = (BA & 255) + 1;
+        BALCrossed = low > 255;
+        BA = (BA & 0xff00) | (low & 255);
+    };
+
+    var add1toBAHifBALCrossed = function() {
+        if (BALCrossed)
+            BA = (BA + 0x0100) & 0xffff;
+    };
+
+    var fetchIAL = function() {
+        IA = bus.read(PC);
+        PC++;
+    };
+
+    var fetchIAH = function() {
+        IA |= bus.read(PC) << 8;
+        PC++;
+    };
+
+    var add1toIAL = function() {
+        var low = (IA & 255) + 1;
+        IA = (IA & 0xff00) | (low & 255);
+    };
+
+    var fetchDataFromImmediate = function() {
+        data = bus.read(PC);
+        PC++;
+    };
+
+    var fetchDataFromAD = function() {
+        data = bus.read(AD);
+    };
+
+    var fetchDataFromBA = function() {
+        data = bus.read(BA);
+    };
+
+    var writeDataToAD = function() {
+        bus.write(AD, data);
+    };
+
+    var writeDataToBA = function() {
+        bus.write(BA, data);
+    };
+
+    var addBranchOffsetToPCL = function() {
+        var oldLow = (PC & 0x00ff);
+        var newLow = (oldLow + branchOffset) & 255;
+        // Negative offset?
+        if (branchOffset > 127)
+            branchOffsetCrossAdjust = (newLow > oldLow) ? -0x0100 : 0;
+        else
+            branchOffsetCrossAdjust = (newLow < oldLow) ? 0x0100 : 0;
+        PC = (PC & 0xff00) | newLow;
+    };
+
+    var adjustPCHForBranchOffsetCross = function() {
+        PC = (PC + branchOffsetCrossAdjust) & 0xffff;
+    };
+
+    var setZ = function(val) {
+        Z = (val === 0) ? 1 : 0;
+    };
+
+    var setN = function(val) {
+        N = (val & 0x080) ? 1 : 0;
+    };
+
+    var setV = function(boo) {
+        V = boo ? 1 : 0;
+    };
+
+    var setC = function(boo) {
+        C = boo ? 1 : 0;
+    };
+
+    var popFromStack = function() {
+        SP = (SP + 1) & 255;
+        return bus.read(0x0100 + SP);
+    };
+
+    var peekFromStack = function() {
+        return bus.read(0x0100 + SP);
+    };
+
+    var pushToStack = function(val) {
+        bus.write(0x0100 + SP, val);
+        SP = (SP - 1) & 255;
+    };
+
+    var getStatusBits = function() {
+        return N << 7 | V << 6 | 0x30                 // Always push with E (bit 5) and B (bit 4) ON
+            |  D << 3 | I << 2 | Z << 1 | C;
+    };
+
+    var setStatusBits = function(val) {
+        N = val >>> 7; V = val >>> 6 & 1;             // E and B flags actually do not exist as real flags, so ignore
+        D = val >>> 3 & 1; I = val >>> 2 & 1; Z = val >>> 1 & 1; C = val & 1;
+    };
+
+    var illegalOpcode = function(op) {
+        if (self.debug) self.breakpoint("Illegal Opcode: " + op);
+    };
+
+
+    // Addressing routines
+
+    var implied = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchOpcodeAndDiscard,
+            function() {
+                operation();
+                fetchNextOpcode();
+            }
+        ];
+    };
+
+    var immediateRead = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchDataFromImmediate,
+            function() {
+                operation();
+                fetchNextOpcode();
+            }
+        ];
+    };
+
+    var zeroPageRead = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchADL,                        // ADH will be zero
+            fetchDataFromAD,
+            function() {
+                operation();
+                fetchNextOpcode();
+            }
+        ];
+    };
+
+    var absoluteRead = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchADL,
+            fetchADH,
+            fetchDataFromAD,
+            function() {
+                operation();
+                fetchNextOpcode();
+            }
+        ];
+    };
+
+    var indirectXRead = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchBAL,                        // BAH will be zero
+            fetchDataFromBA,
+            function() {
+                addXtoBAL();
+                fetchADLFromBA();
+            },
+            function() {
+                add1toBAL();
+                fetchADHFromBA();
+            },
+            fetchDataFromAD,
+            function() {
+                operation();
+                fetchNextOpcode();
+            }
+        ];
+    };
+
+    var absoluteIndexedRead = function(index) {
+        var addIndex = index === rX ? addXtoBAL : addYtoBAL;
+        return function(operation) {
+            return [
+                fetchOpcodeAndDecodeInstruction,
+                fetchBAL,
+                fetchBAH,
+                function() {
+                    addIndex();
+                    fetchDataFromBA();
+                    add1toBAHifBALCrossed();
+                },
+                function() {
+                    if (BALCrossed) {
+                        fetchDataFromBA();
+                    } else {
+                        operation();
+                        fetchNextOpcode();
+                    }
+                },
+                function() {
+                    operation();
+                    fetchNextOpcode();
+                }
+            ];
+        };
+    };
+
+    var zeroPageIndexedRead = function(index) {
+        var addIndex = index === rX ? addXtoBAL : addYtoBAL;
+        return function(operation) {
+            return [
+                fetchOpcodeAndDecodeInstruction,
+                fetchBAL,                        // BAH will be zero
+                fetchDataFromBA,
+                function() {
+                    addIndex();
+                    fetchDataFromBA();
+                },
+                function() {
+                    operation();
+                    fetchNextOpcode();
+                }
+            ];
+        };
+    };
+
+    var indirectYRead = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchIAL,                           // IAH will be zero
+            fetchBALFromIA,
+            function() {
+                add1toIAL();
+                fetchBAHFromIA();
+            },
+            function() {
+                addYtoBAL();
+                fetchDataFromBA();
+                add1toBAHifBALCrossed();
+            },
+            function() {
+                if(BALCrossed) {
+                    fetchDataFromBA();
+                } else {
+                    operation();
+                    fetchNextOpcode();
+                }
+            },
+            function() {
+                operation();
+                fetchNextOpcode();
+            }
+        ];
+    };
+
+    var zeroPageWrite = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchADL,                        // ADH will be zero
+            function() {
+                operation();
+                writeDataToAD();
+            },
+            fetchNextOpcode
+        ];
+    };
+
+    var absoluteWrite = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchADL,
+            fetchADH,
+            function() {
+                operation();
+                writeDataToAD();
+            },
+            fetchNextOpcode
+        ];
+    };
+
+    var indirectXWrite = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchBAL,                        // BAH will be zero
+            fetchDataFromBA,
+            function() {
+                addXtoBAL();
+                fetchADLFromBA();
+            },
+            function() {
+                add1toBAL();
+                fetchADHFromBA();
+            },
+            function() {
+                operation();
+                writeDataToAD();
+            },
+            fetchNextOpcode
+        ];
+    };
+
+    var absoluteIndexedWrite = function(index) {
+        var addIndex = index === rX ? addXtoBAL : addYtoBAL;
+        return function(operation) {
+            return [
+                fetchOpcodeAndDecodeInstruction,
+                fetchBAL,
+                fetchBAH,
+                function() {
+                    addIndex();
+                    fetchDataFromBA();
+                    add1toBAHifBALCrossed();
+                },
+                function() {
+                    operation();
+                    writeDataToBA();
+                },
+                fetchNextOpcode
+            ];
+        };
+    };
+
+    var zeroPageIndexedWrite = function(index) {
+        var addIndex = index === rX ? addXtoBAL : addYtoBAL;
+        return function(operation) {
+            return [
+                fetchOpcodeAndDecodeInstruction,
+                fetchBAL,                        // BAH will be zero
+                fetchDataFromBA,
+                function() {
+                    addIndex();
+                    operation();
+                    writeDataToBA();
+                },
+                fetchNextOpcode
+            ];
+        };
+    };
+
+    var indirectYWrite = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchIAL,                           // IAH will be zero
+            fetchBALFromIA,
+            function() {
+                add1toIAL();
+                fetchBAHFromIA();
+            },
+            function() {
+                addYtoBAL();
+                fetchDataFromBA();
+                add1toBAHifBALCrossed();
+            },
+            function() {
+                operation();
+                writeDataToBA();
+            },
+            fetchNextOpcode
+        ];
+    };
+
+
+    var zeroPageReadModifyWrite = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchADL,                        // ADH will be zero
+            fetchDataFromAD,
+            writeDataToAD,
+            function() {
+                operation();
+                writeDataToAD();
+            },
+            fetchNextOpcode
+        ];
+    };
+
+    var absoluteReadModifyWrite = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchADL,
+            fetchADH,
+            fetchDataFromAD,
+            writeDataToAD,
+            function() {
+                operation();
+                writeDataToAD();
+            },
+            fetchNextOpcode
+        ];
+    };
+
+    var zeroPageIndexedReadModifyWrite = function(index) {
+        var addIndex = index === rX ? addXtoBAL : addYtoBAL;
+        return function(operation) {
+            return [
+                fetchOpcodeAndDecodeInstruction,
+                fetchBAL,                        // BAH will be zero
+                fetchDataFromBA,
+                function () {
+                    addIndex();
+                    fetchDataFromBA();
+                },
+                writeDataToBA,
+                function () {
+                    operation();
+                    writeDataToBA();
+                },
+                fetchNextOpcode
+            ];
+        };
+    };
+
+    var absoluteIndexedReadModifyWrite = function(index) {
+        var addIndex = index === rX ? addXtoBAL : addYtoBAL;
+        return function(operation) {
+            return [
+                fetchOpcodeAndDecodeInstruction,
+                fetchBAL,
+                fetchBAH,
+                function () {
+                    addIndex();
+                    fetchDataFromBA();
+                    add1toBAHifBALCrossed();
+                },
+                fetchDataFromBA,
+                writeDataToBA,
+                function () {
+                    operation();
+                    writeDataToBA();
+                },
+                fetchNextOpcode
+            ];
+        };
+    };
+
+    var indirectXReadModifyWrite = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchBAL,                        // BAH will be zero
+            fetchDataFromBA,
+            function() {
+                addXtoBAL();
+                fetchADLFromBA();
+            },
+            function() {
+                add1toBAL();
+                fetchADHFromBA();
+            },
+            fetchDataFromAD,
+            writeDataToAD,
+            function() {
+                operation();
+                writeDataToAD();
+            },
+            fetchNextOpcode
+        ];
+    };
+
+    var indirectYReadModifyWrite = function(operation) {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchIAL,                           // IAH will be zero
+            fetchBALFromIA,
+            function() {
+                add1toIAL();
+                fetchBAHFromIA();
+            },
+            function() {
+                addYtoBAL();
+                fetchDataFromBA();
+                add1toBAHifBALCrossed();
+            },
+            fetchDataFromBA,
+            writeDataToBA,
+            function() {
+                operation();
+                writeDataToBA();
+            },
+            fetchNextOpcode
+        ];
+    };
+
+
+    // Instructions  ========================================================================================
+
+    // Complete instruction set
+    var opcodes =      new Array(256);
+    var instructions = new Array(256);
+
+    opcodes[0x00] = "BRK";  instructions[0x00] = BRK();
+    opcodes[0x01] = "ORA";  instructions[0x01] = ORA(indirectXRead);
+    opcodes[0x02] = "uKIL"; instructions[0x02] = uKIL();
+    opcodes[0x03] = "uSLO"; instructions[0x03] = uSLO(indirectXReadModifyWrite);
+    opcodes[0x04] = "uNOP"; instructions[0x04] = uNOP(zeroPageRead);
+    opcodes[0x05] = "ORA";  instructions[0x05] = ORA(zeroPageRead);
+    opcodes[0x06] = "ASL";  instructions[0x06] = ASL(zeroPageReadModifyWrite);
+    opcodes[0x07] = "uSLO"; instructions[0x07] = uSLO(zeroPageReadModifyWrite);
+    opcodes[0x08] = "PHP";  instructions[0x08] = PHP();
+    opcodes[0x09] = "ORA";  instructions[0x09] = ORA(immediateRead);
+    opcodes[0x0a] = "ASL";  instructions[0x0a] = ASL_ACC();
+    opcodes[0x0b] = "uANC"; instructions[0x0b] = uANC(immediateRead);
+    opcodes[0x0c] = "uNOP"; instructions[0x0c] = uNOP(absoluteRead);
+    opcodes[0x0d] = "ORA";  instructions[0x0d] = ORA(absoluteRead);
+    opcodes[0x0e] = "ASL";  instructions[0x0e] = ASL(absoluteReadModifyWrite);
+    opcodes[0x0f] = "uSLO"; instructions[0x0f] = uSLO(absoluteReadModifyWrite);
+    opcodes[0x10] = "BPL";  instructions[0x10] = Bxx(bN, 0);                 // BPL
+    opcodes[0x11] = "ORA";  instructions[0x11] = ORA(indirectYRead);
+    opcodes[0x12] = "uKIL"; instructions[0x12] = uKIL();
+    opcodes[0x13] = "uSLO"; instructions[0x13] = uSLO(indirectYReadModifyWrite);
+    opcodes[0x14] = "uNOP"; instructions[0x14] = uNOP(zeroPageIndexedRead(rX));
+    opcodes[0x15] = "ORA";  instructions[0x15] = ORA(zeroPageIndexedRead(rX));
+    opcodes[0x16] = "ASL";  instructions[0x16] = ASL(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0x17] = "uSLO"; instructions[0x17] = uSLO(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0x18] = "CLC";  instructions[0x18] = CLC();
+    opcodes[0x19] = "ORA";  instructions[0x19] = ORA(absoluteIndexedRead(rY));
+    opcodes[0x1a] = "uNOP"; instructions[0x1a] = uNOP(implied);
+    opcodes[0x1b] = "uSLO"; instructions[0x1b] = uSLO(absoluteIndexedReadModifyWrite(rY));
+    opcodes[0x1c] = "uNOP"; instructions[0x1c] = uNOP(absoluteIndexedRead(rX));
+    opcodes[0x1d] = "ORA";  instructions[0x1d] = ORA(absoluteIndexedRead(rX));
+    opcodes[0x1e] = "ASL";  instructions[0x1e] = ASL(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0x1f] = "uSLO"; instructions[0x1f] = uSLO(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0x20] = "JSR";  instructions[0x20] = JSR();
+    opcodes[0x21] = "AND";  instructions[0x21] = AND(indirectXRead);
+    opcodes[0x22] = "uKIL"; instructions[0x22] = uKIL();
+    opcodes[0x23] = "uRLA"; instructions[0x23] = uRLA(indirectXReadModifyWrite);
+    opcodes[0x24] = "BIT";  instructions[0x24] = BIT(zeroPageRead);
+    opcodes[0x25] = "AND";  instructions[0x25] = AND(zeroPageRead);
+    opcodes[0x26] = "ROL";  instructions[0x26] = ROL(zeroPageReadModifyWrite);
+    opcodes[0x27] = "uRLA"; instructions[0x27] = uRLA(zeroPageReadModifyWrite);
+    opcodes[0x28] = "PLP";  instructions[0x28] = PLP();
+    opcodes[0x29] = "AND";  instructions[0x29] = AND(immediateRead);
+    opcodes[0x2a] = "ROL";  instructions[0x2a] = ROL_ACC();
+    opcodes[0x2b] = "uANC"; instructions[0x2b] = uANC(immediateRead);
+    opcodes[0x2c] = "BIT";  instructions[0x2c] = BIT(absoluteRead);
+    opcodes[0x2d] = "AND";  instructions[0x2d] = AND(absoluteRead);
+    opcodes[0x2e] = "ROL";  instructions[0x2e] = ROL(absoluteReadModifyWrite);
+    opcodes[0x2f] = "uRLA"; instructions[0x2f] = uRLA(absoluteReadModifyWrite);
+    opcodes[0x30] = "BMI";  instructions[0x30] = Bxx(bN, 1);                 // BMI
+    opcodes[0x31] = "AND";  instructions[0x31] = AND(indirectYRead);
+    opcodes[0x32] = "uKIL"; instructions[0x32] = uKIL();
+    opcodes[0x33] = "uRLA"; instructions[0x33] = uRLA(indirectYReadModifyWrite);
+    opcodes[0x34] = "uNOP"; instructions[0x34] = uNOP(zeroPageIndexedRead(rX));
+    opcodes[0x35] = "AND";  instructions[0x35] = AND(zeroPageIndexedRead(rX));
+    opcodes[0x36] = "ROL";  instructions[0x36] = ROL(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0x37] = "uRLA"; instructions[0x37] = uRLA(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0x38] = "SEC";  instructions[0x38] = SEC();
+    opcodes[0x39] = "AND";  instructions[0x39] = AND(absoluteIndexedRead(rY));
+    opcodes[0x3a] = "uNOP"; instructions[0x3a] = uNOP(implied);
+    opcodes[0x3b] = "uRLA"; instructions[0x3b] = uRLA(absoluteIndexedReadModifyWrite(rY));
+    opcodes[0x3c] = "uNOP"; instructions[0x3c] = uNOP(absoluteIndexedRead(rX));
+    opcodes[0x3d] = "AND";  instructions[0x3d] = AND(absoluteIndexedRead(rX));
+    opcodes[0x3e] = "ROL";  instructions[0x3e] = ROL(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0x3f] = "uRLA"; instructions[0x3f] = uRLA(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0x40] = "RTI";  instructions[0x40] = RTI();
+    opcodes[0x41] = "EOR";  instructions[0x41] = EOR(indirectXRead);
+    opcodes[0x42] = "uKIL"; instructions[0x42] = uKIL();
+    opcodes[0x43] = "uSRE"; instructions[0x43] = uSRE(indirectXReadModifyWrite);
+    opcodes[0x44] = "uNOP"; instructions[0x44] = uNOP(zeroPageRead);
+    opcodes[0x45] = "EOR";  instructions[0x45] = EOR(zeroPageRead);
+    opcodes[0x46] = "LSR";  instructions[0x46] = LSR(zeroPageReadModifyWrite);
+    opcodes[0x47] = "uSRE"; instructions[0x47] = uSRE(zeroPageReadModifyWrite);
+    opcodes[0x48] = "PHA";  instructions[0x48] = PHA();
+    opcodes[0x49] = "EOR";  instructions[0x49] = EOR(immediateRead);
+    opcodes[0x4a] = "LSR";  instructions[0x4a] = LSR_ACC();
+    opcodes[0x4b] = "uASR"; instructions[0x4b] = uASR(immediateRead);
+    opcodes[0x4c] = "JMP";  instructions[0x4c] = JMP_ABS();
+    opcodes[0x4d] = "EOR";  instructions[0x4d] = EOR(absoluteRead);
+    opcodes[0x4e] = "LSR";  instructions[0x4e] = LSR(absoluteReadModifyWrite);
+    opcodes[0x4f] = "uSRE"; instructions[0x4f] = uSRE(absoluteReadModifyWrite);
+    opcodes[0x50] = "BVC";  instructions[0x50] = Bxx(bV, 0);                 // BVC
+    opcodes[0x51] = "EOR";  instructions[0x51] = EOR(indirectYRead);
+    opcodes[0x52] = "uKIL"; instructions[0x52] = uKIL();
+    opcodes[0x53] = "uSRE"; instructions[0x53] = uSRE(indirectYReadModifyWrite);
+    opcodes[0x54] = "uNOP"; instructions[0x54] = uNOP(zeroPageIndexedRead(rX));
+    opcodes[0x55] = "EOR";  instructions[0x55] = EOR(zeroPageIndexedRead(rX));
+    opcodes[0x56] = "LSR";  instructions[0x56] = LSR(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0x57] = "uSRE"; instructions[0x57] = uSRE(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0x58] = "CLI";  instructions[0x58] = CLI();
+    opcodes[0x59] = "EOR";  instructions[0x59] = EOR(absoluteIndexedRead(rY));
+    opcodes[0x5a] = "uNOP"; instructions[0x5a] = uNOP(implied);
+    opcodes[0x5b] = "uSRE"; instructions[0x5b] = uSRE(absoluteIndexedReadModifyWrite(rY));
+    opcodes[0x5c] = "uNOP"; instructions[0x5c] = uNOP(absoluteIndexedRead(rX));
+    opcodes[0x5d] = "EOR";  instructions[0x5d] = EOR(absoluteIndexedRead(rX));
+    opcodes[0x5e] = "LSR";  instructions[0x5e] = LSR(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0x5f] = "uSRE"; instructions[0x5f] = uSRE(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0x60] = "RTS";  instructions[0x60] = RTS();
+    opcodes[0x61] = "ADC";  instructions[0x61] = ADC(indirectXRead);
+    opcodes[0x62] = "uKIL"; instructions[0x62] = uKIL();
+    opcodes[0x63] = "uRRA"; instructions[0x63] = uRRA(indirectXReadModifyWrite);
+    opcodes[0x64] = "uNOP"; instructions[0x64] = uNOP(zeroPageRead);
+    opcodes[0x65] = "ADC";  instructions[0x65] = ADC(zeroPageRead);
+    opcodes[0x66] = "ROR";  instructions[0x66] = ROR(zeroPageReadModifyWrite);
+    opcodes[0x67] = "uRRA"; instructions[0x67] = uRRA(zeroPageReadModifyWrite);
+    opcodes[0x68] = "PLA";  instructions[0x68] = PLA();
+    opcodes[0x69] = "ADC";  instructions[0x69] = ADC(immediateRead);
+    opcodes[0x6a] = "ROR";  instructions[0x6a] = ROR_ACC();
+    opcodes[0x6b] = "uARR"; instructions[0x6b] = uARR(immediateRead);
+    opcodes[0x6c] = "JMP";  instructions[0x6c] = JMP_IND();
+    opcodes[0x6d] = "ADC";  instructions[0x6d] = ADC(absoluteRead);
+    opcodes[0x6e] = "ROR";  instructions[0x6e] = ROR(absoluteReadModifyWrite);
+    opcodes[0x6f] = "uRRA"; instructions[0x6f] = uRRA(absoluteReadModifyWrite);
+    opcodes[0x70] = "BVS";  instructions[0x70] = Bxx(bV, 1);                 // BVS
+    opcodes[0x71] = "ADC";  instructions[0x71] = ADC(indirectYRead);
+    opcodes[0x72] = "uKIL"; instructions[0x72] = uKIL();
+    opcodes[0x73] = "uRRA"; instructions[0x73] = uRRA(indirectYReadModifyWrite);
+    opcodes[0x74] = "uNOP"; instructions[0x74] = uNOP(zeroPageIndexedRead(rX));
+    opcodes[0x75] = "ADC";  instructions[0x75] = ADC(zeroPageIndexedRead(rX));
+    opcodes[0x76] = "ROR";  instructions[0x76] = ROR(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0x77] = "uRRA"; instructions[0x77] = uRRA(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0x78] = "SEI";  instructions[0x78] = SEI();
+    opcodes[0x79] = "ADC";  instructions[0x79] = ADC(absoluteIndexedRead(rY));
+    opcodes[0x7a] = "uNOP"; instructions[0x7a] = uNOP(implied);
+    opcodes[0x7b] = "uRRA"; instructions[0x7b] = uRRA(absoluteIndexedReadModifyWrite(rY));
+    opcodes[0x7c] = "uNOP"; instructions[0x7c] = uNOP(absoluteIndexedRead(rX));
+    opcodes[0x7d] = "ADC";  instructions[0x7d] = ADC(absoluteIndexedRead(rX));
+    opcodes[0x7e] = "ROR";  instructions[0x7e] = ROR(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0x7f] = "uRRA"; instructions[0x7f] = uRRA(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0x80] = "uNOP"; instructions[0x80] = uNOP(immediateRead);
+    opcodes[0x81] = "STA";  instructions[0x81] = STA(indirectXWrite);
+    opcodes[0x82] = "uNOP"; instructions[0x82] = uNOP(immediateRead);
+    opcodes[0x83] = "uSAX"; instructions[0x83] = uSAX(indirectXWrite);
+    opcodes[0x84] = "STY";  instructions[0x84] = STY(zeroPageWrite);
+    opcodes[0x85] = "STA";  instructions[0x85] = STA(zeroPageWrite);
+    opcodes[0x86] = "STX";  instructions[0x86] = STX(zeroPageWrite);
+    opcodes[0x87] = "uSAX"; instructions[0x87] = uSAX(zeroPageWrite);
+    opcodes[0x88] = "DEY";  instructions[0x88] = DEY();
+    opcodes[0x89] = "uNOP"; instructions[0x89] = uNOP(immediateRead);
+    opcodes[0x8a] = "TXA";  instructions[0x8a] = TXA();
+    opcodes[0x8b] = "uANE"; instructions[0x8b] = uANE(immediateRead);
+    opcodes[0x8c] = "STY";  instructions[0x8c] = STY(absoluteWrite);
+    opcodes[0x8d] = "STA";  instructions[0x8d] = STA(absoluteWrite);
+    opcodes[0x8e] = "STX";  instructions[0x8e] = STX(absoluteWrite);
+    opcodes[0x8f] = "uSAX"; instructions[0x8f] = uSAX(absoluteWrite);
+    opcodes[0x90] = "BCC";  instructions[0x90] = Bxx(bC, 0);                 // BCC
+    opcodes[0x91] = "STA";  instructions[0x91] = STA(indirectYWrite);
+    opcodes[0x92] = "uKIL"; instructions[0x92] = uKIL();
+    opcodes[0x93] = "uSHA"; instructions[0x93] = uSHA(indirectYWrite);
+    opcodes[0x94] = "STY";  instructions[0x94] = STY(zeroPageIndexedWrite(rX));
+    opcodes[0x95] = "STA";  instructions[0x95] = STA(zeroPageIndexedWrite(rX));
+    opcodes[0x96] = "STX";  instructions[0x96] = STX(zeroPageIndexedWrite(rY));
+    opcodes[0x97] = "uSAX"; instructions[0x97] = uSAX(zeroPageIndexedWrite(rY));
+    opcodes[0x98] = "TYA";  instructions[0x98] = TYA();
+    opcodes[0x99] = "STA";  instructions[0x99] = STA(absoluteIndexedWrite(rY));
+    opcodes[0x9a] = "TXS";  instructions[0x9a] = TXS();
+    opcodes[0x9b] = "uSHS"; instructions[0x9b] = uSHS(absoluteIndexedWrite(rY));
+    opcodes[0x9c] = "uSHY"; instructions[0x9c] = uSHY(absoluteIndexedWrite(rX));
+    opcodes[0x9d] = "STA";  instructions[0x9d] = STA(absoluteIndexedWrite(rX));
+    opcodes[0x9e] = "uSHX"; instructions[0x9e] = uSHX(absoluteIndexedWrite(rY));
+    opcodes[0x9f] = "uSHA"; instructions[0x9f] = uSHA(absoluteIndexedWrite(rY));
+    opcodes[0xa0] = "LDY";  instructions[0xa0] = LDY(immediateRead);
+    opcodes[0xa1] = "LDA";  instructions[0xa1] = LDA(indirectXRead);
+    opcodes[0xa2] = "LDX";  instructions[0xa2] = LDX(immediateRead);
+    opcodes[0xa3] = "uLAX"; instructions[0xa3] = uLAX(indirectXRead);
+    opcodes[0xa4] = "LDY";  instructions[0xa4] = LDY(zeroPageRead);
+    opcodes[0xa5] = "LDA";  instructions[0xa5] = LDA(zeroPageRead);
+    opcodes[0xa6] = "LDX";  instructions[0xa6] = LDX(zeroPageRead);
+    opcodes[0xa7] = "uLAX"; instructions[0xa7] = uLAX(zeroPageRead);
+    opcodes[0xa8] = "TAY";  instructions[0xa8] = TAY();
+    opcodes[0xa9] = "LDA";  instructions[0xa9] = LDA(immediateRead);
+    opcodes[0xaa] = "TAX";  instructions[0xaa] = TAX();
+    opcodes[0xab] = "uLXA"; instructions[0xab] = uLXA(immediateRead);
+    opcodes[0xac] = "LDY";  instructions[0xac] = LDY(absoluteRead);
+    opcodes[0xad] = "LDA";  instructions[0xad] = LDA(absoluteRead);
+    opcodes[0xae] = "LDX";  instructions[0xae] = LDX(absoluteRead);
+    opcodes[0xaf] = "uLAX"; instructions[0xaf] = uLAX(absoluteRead);
+    opcodes[0xb0] = "BCS";  instructions[0xb0] = Bxx(bC, 1);                 // BCS
+    opcodes[0xb1] = "LDA";  instructions[0xb1] = LDA(indirectYRead);
+    opcodes[0xb2] = "uKIL"; instructions[0xb2] = uKIL();
+    opcodes[0xb3] = "uLAX"; instructions[0xb3] = uLAX(indirectYRead);
+    opcodes[0xb4] = "LDY";  instructions[0xb4] = LDY(zeroPageIndexedRead(rX));
+    opcodes[0xb5] = "LDA";  instructions[0xb5] = LDA(zeroPageIndexedRead(rX));
+    opcodes[0xb6] = "LDX";  instructions[0xb6] = LDX(zeroPageIndexedRead(rY));
+    opcodes[0xb7] = "uLAX"; instructions[0xb7] = uLAX(zeroPageIndexedRead(rY));
+    opcodes[0xb8] = "CLV";  instructions[0xb8] = CLV();
+    opcodes[0xb9] = "LDA";  instructions[0xb9] = LDA(absoluteIndexedRead(rY));
+    opcodes[0xba] = "TSX";  instructions[0xba] = TSX();
+    opcodes[0xbb] = "uLAS"; instructions[0xbb] = uLAS(absoluteIndexedRead(rY));
+    opcodes[0xbc] = "LDY";  instructions[0xbc] = LDY(absoluteIndexedRead(rX));
+    opcodes[0xbd] = "LDA";  instructions[0xbd] = LDA(absoluteIndexedRead(rX));
+    opcodes[0xbe] = "LDX";  instructions[0xbe] = LDX(absoluteIndexedRead(rY));
+    opcodes[0xbf] = "uLAX"; instructions[0xbf] = uLAX(absoluteIndexedRead(rY));
+    opcodes[0xc0] = "CPY";  instructions[0xc0] = CPY(immediateRead);
+    opcodes[0xc1] = "CMP";  instructions[0xc1] = CMP(indirectXRead);
+    opcodes[0xc2] = "uNOP"; instructions[0xc2] = uNOP(immediateRead);
+    opcodes[0xc3] = "uDCP"; instructions[0xc3] = uDCP(indirectXReadModifyWrite);
+    opcodes[0xc4] = "CPY";  instructions[0xc4] = CPY(zeroPageRead);
+    opcodes[0xc5] = "CMP";  instructions[0xc5] = CMP(zeroPageRead);
+    opcodes[0xc6] = "DEC";  instructions[0xc6] = DEC(zeroPageReadModifyWrite);
+    opcodes[0xc7] = "uDCP"; instructions[0xc7] = uDCP(zeroPageReadModifyWrite);
+    opcodes[0xc8] = "INY";  instructions[0xc8] = INY();
+    opcodes[0xc9] = "CMP";  instructions[0xc9] = CMP(immediateRead);
+    opcodes[0xca] = "DEX";  instructions[0xca] = DEX();
+    opcodes[0xcb] = "uSBX"; instructions[0xcb] = uSBX(immediateRead);
+    opcodes[0xcc] = "CPY";  instructions[0xcc] = CPY(absoluteRead);
+    opcodes[0xcd] = "CMP";  instructions[0xcd] = CMP(absoluteRead);
+    opcodes[0xce] = "DEC";  instructions[0xce] = DEC(absoluteReadModifyWrite);
+    opcodes[0xcf] = "uDCP"; instructions[0xcf] = uDCP(absoluteReadModifyWrite);
+    opcodes[0xd0] = "BNE";  instructions[0xd0] = Bxx(bZ, 0);                 // BNE
+    opcodes[0xd1] = "CMP";  instructions[0xd1] = CMP(indirectYRead);
+    opcodes[0xd2] = "uKIL"; instructions[0xd2] = uKIL();
+    opcodes[0xd3] = "uDCP"; instructions[0xd3] = uDCP(indirectYReadModifyWrite);
+    opcodes[0xd4] = "uNOP"; instructions[0xd4] = uNOP(zeroPageIndexedRead(rX));
+    opcodes[0xd5] = "CMP";  instructions[0xd5] = CMP(zeroPageIndexedRead(rX));
+    opcodes[0xd6] = "DEC";  instructions[0xd6] = DEC(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0xd7] = "uDCP"; instructions[0xd7] = uDCP(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0xd8] = "CLD";  instructions[0xd8] = CLD();
+    opcodes[0xd9] = "CMP";  instructions[0xd9] = CMP(absoluteIndexedRead(rY));
+    opcodes[0xda] = "uNOP"; instructions[0xda] = uNOP(implied);
+    opcodes[0xdb] = "uDCP"; instructions[0xdb] = uDCP(absoluteIndexedReadModifyWrite(rY));
+    opcodes[0xdc] = "uNOP"; instructions[0xdc] = uNOP(absoluteIndexedRead(rX));
+    opcodes[0xdd] = "CMP";  instructions[0xdd] = CMP(absoluteIndexedRead(rX));
+    opcodes[0xde] = "DEC";  instructions[0xde] = DEC(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0xdf] = "uDCP"; instructions[0xdf] = uDCP(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0xe0] = "CPX";  instructions[0xe0] = CPX(immediateRead);
+    opcodes[0xe1] = "SBC";  instructions[0xe1] = SBC(indirectXRead);
+    opcodes[0xe2] = "uNOP"; instructions[0xe2] = uNOP(immediateRead);
+    opcodes[0xe3] = "uISB"; instructions[0xe3] = uISB(indirectXReadModifyWrite);
+    opcodes[0xe4] = "CPX";  instructions[0xe4] = CPX(zeroPageRead);
+    opcodes[0xe5] = "SBC";  instructions[0xe5] = SBC(zeroPageRead);
+    opcodes[0xe6] = "INC";  instructions[0xe6] = INC(zeroPageReadModifyWrite);
+    opcodes[0xe7] = "uISB"; instructions[0xe7] = uISB(zeroPageReadModifyWrite);
+    opcodes[0xe8] = "INX";  instructions[0xe8] = INX();
+    opcodes[0xe9] = "SBC";  instructions[0xe9] = SBC(immediateRead);
+    opcodes[0xea] = "NOP";  instructions[0xea] = NOP();
+    opcodes[0xeb] = "SBC";  instructions[0xeb] = SBC(immediateRead);
+    opcodes[0xec] = "CPX";  instructions[0xec] = CPX(absoluteRead);
+    opcodes[0xed] = "SBC";  instructions[0xed] = SBC(absoluteRead);
+    opcodes[0xee] = "INC";  instructions[0xee] = INC(absoluteReadModifyWrite);
+    opcodes[0xef] = "uISB"; instructions[0xef] = uISB(absoluteReadModifyWrite);
+    opcodes[0xf0] = "BEQ";  instructions[0xf0] = Bxx(bZ, 1);                 // BEQ
+    opcodes[0xf1] = "SBC";  instructions[0xf1] = SBC(indirectYRead);
+    opcodes[0xf2] = "uKIL"; instructions[0xf2] = uKIL();
+    opcodes[0xf3] = "uISB"; instructions[0xf3] = uISB(indirectYReadModifyWrite);
+    opcodes[0xf4] = "uNOP"; instructions[0xf4] = uNOP(zeroPageIndexedRead(rX));
+    opcodes[0xf5] = "SBC";  instructions[0xf5] = SBC(zeroPageIndexedRead(rX));
+    opcodes[0xf6] = "INC";  instructions[0xf6] = INC(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0xf7] = "uISB"; instructions[0xf7] = uISB(zeroPageIndexedReadModifyWrite(rX));
+    opcodes[0xf8] = "SED";  instructions[0xf8] = SED();
+    opcodes[0xf9] = "SBC";  instructions[0xf9] = SBC(absoluteIndexedRead(rY));
+    opcodes[0xfa] = "uNOP"; instructions[0xfa] = uNOP(implied);
+    opcodes[0xfb] = "uISB"; instructions[0xfb] = uISB(absoluteIndexedReadModifyWrite(rY));
+    opcodes[0xfc] = "uNOP"; instructions[0xfc] = uNOP(absoluteIndexedRead(rX));
+    opcodes[0xfd] = "SBC";  instructions[0xfd] = SBC(absoluteIndexedRead(rX));
+    opcodes[0xfe] = "INC";  instructions[0xfe] = INC(absoluteIndexedReadModifyWrite(rX));
+    opcodes[0xff] = "uISB"; instructions[0xff] = uISB(absoluteIndexedReadModifyWrite(rX));
+
+
+    // Single Byte instructions
+
+    function ASL_ACC() {
+        return implied(function() {
+            setC(A > 127);
+            A = (A << 1) & 255;
+            setZ(A);
+            setN(A);
+        });
+    }
+
+    function CLC() {
+        return implied(function() {
+            C = 0;
+        });
+    }
+
+    function CLD() {
+        return implied(function() {
+            D = 0;
+        });
+    }
+
+    function CLI() {
+        return implied(function() {
+            I = 0;
+        });
+    }
+
+    function CLV() {
+        return implied(function() {
+            V = 0;
+        });
+    }
+
+    function DEX() {
+        return implied(function() {
+            X = (X - 1) & 255;
+            setZ(X);
+            setN(X);
+        });
+    }
+
+    function DEY() {
+        return implied(function() {
+            Y = (Y - 1) & 255;
+            setZ(Y);
+            setN(Y);
+        });
+    }
+
+    function INX() {
+        return implied(function() {
+            X = (X + 1) & 255;
+            setZ(X);
+            setN(X);
+        });
+    }
+
+    function INY() {
+        return implied(function() {
+            Y = (Y + 1) & 255;
+            setZ(Y);
+            setN(Y);
+        });
+    }
+
+    function LSR_ACC() {
+        return implied(function() {
+            C = A & 0x01;
+            A >>>= 1;
+            setZ(A);
+            N = 0;
+        });
+    }
+
+    function NOP() {
+        return implied(function() {
+            // nothing
+        });
+    }
+
+    function ROL_ACC() {
+        return implied(function() {
+            var newC = A > 127;
+            A = ((A << 1) | C) & 255;
+            setC(newC);
+            setZ(A);
+            setN(A);
+        });
+    }
+
+    function ROR_ACC() {
+        return implied(function() {
+            var newC = A & 0x01;
+            A = (A >>> 1) | (C << 7);
+            setC(newC);
+            setZ(A);
+            setN(A);
+        });
+    }
+
+    function SEC() {
+        return implied(function() {
+            C = 1;
+        });
+    }
+
+    function SED() {
+        return implied(function() {
+            D = 1;
+        });
+    }
+
+    function SEI() {
+        return implied(function() {
+            I = 1;
+        });
+    }
+
+    function TAX() {
+        return implied(function() {
+            X = A;
+            setZ(X);
+            setN(X);
+        });
+    }
+
+    function TAY() {
+        return implied(function() {
+            Y = A;
+            setZ(Y);
+            setN(Y);
+        });
+    }
+
+    function TSX() {
+        return implied(function() {
+            X = SP;
+            setZ(X);
+            setN(X);
+        });
+    }
+
+    function TXA() {
+        return implied(function() {
+            A = X;
+            setZ(A);
+            setN(A);
+        });
+    }
+
+    function TXS() {
+        return implied(function() {
+            SP = X;
+        });
+    }
+
+    function TYA() {
+        return implied(function() {
+            A = Y;
+            setZ(A);
+            setN(A);
+        });
+    }
+
+    function uKIL() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            function() {
+                illegalOpcode("KIL/HLT/JAM");
+            },
+            function() {
+                T--;        // Causes the processor to be stuck in this instruction forever
+            }
+        ];
+    }
+
+    function uNOP(addressing) {
+        return addressing(function() {
+            illegalOpcode("NOP/DOP");
+            // nothing
+        });
+    }
+
+
+    // Internal Execution on Memory Data
+
+    function ADC(addressing) {
+        return addressing(function() {
+            if (D) {
+                var operand = data;
+                var AL = (A & 15) + (operand & 15) + C;
+                if (AL > 9) { AL += 6; }
+                var AH = ((A >> 4) + (operand >> 4) + ((AL > 15)?1:0)) << 4;
+                setZ((A + operand + C) & 255);
+                setN(AH);
+                setV(((A ^AH) & ~(A ^ operand)) & 128);
+                if (AH > 0x9f) { AH += 0x60; }
+                setC(AH > 255);
+                A = (AH | (AL & 15)) & 255;
+            } else {
+                var add = A + data + C;
+                setC(add > 255);
+                setV(((A ^ add) & (data ^ add)) & 0x80);
+                A = add & 255;
+                setZ(A);
+                setN(A);
+            }
+        });
+    }
+
+    function AND(addressing) {
+        return addressing(function() {
+            A &= data;
+            setZ(A);
+            setN(A);
+        });
+    }
+
+    function BIT(addressing) {
+        return addressing(function() {
+            var par = data;
+            setZ(A & par);
+            setV(par & 0x40);
+            setN(par);
+        });
+    }
+
+    function CMP(addressing) {
+        return addressing(function() {
+            var val = (A - data) & 255;
+            setC(A >= data);
+            setZ(val);
+            setN(val);
+        });
+    }
+
+    function CPX(addressing) {
+        return addressing(function() {
+            var val = (X - data) & 255;
+            setC(X >= data);
+            setZ(val);
+            setN(val);
+        });
+    }
+
+    function CPY(addressing) {
+        return addressing(function() {
+            var val = (Y - data) & 255;
+            setC(Y >= data);
+            setZ(val);
+            setN(val);
+        });
+    }
+
+    function EOR(addressing) {
+        return addressing(function() {
+            A ^= data;
+            setZ(A);
+            setN(A);
+        });
+    }
+
+    function LDA(addressing) {
+        return addressing(function() {
+            A = data;
+            setZ(A);
+            setN(A);
+        });
+    }
+
+    function LDX(addressing) {
+        return addressing(function() {
+            X = data;
+            setZ(X);
+            setN(X);
+        });
+    }
+
+    function LDY(addressing) {
+        return addressing(function() {
+            Y = data;
+            setZ(Y);
+            setN(Y);
+        });
+    }
+
+    function ORA(addressing) {
+        return addressing(function() {
+            A |= data;
+            setZ(A);
+            setN(A);
+        });
+    }
+
+    function SBC(addressing) {
+        return addressing(function() {
+            if (D) {
+                var operand = data;
+                var AL = (A & 15) - (operand & 15) - (1-C);
+                var AH = (A >> 4) - (operand >> 4) - ((AL < 0)?1:0);
+                if (AL < 0) { AL -= 6; }
+                if (AH < 0) { AH -= 6; }
+                var sub = A - operand - (1-C);
+                setC(~sub & 256);
+                setV(((A ^ operand) & (A ^ sub)) & 128);
+                setZ(sub & 255);
+                setN(sub);
+                A = ((AH << 4) | (AL & 15)) & 255;
+            } else {
+                operand = (~data) & 255;
+                sub = A + operand + C;
+                setC(sub > 255);
+                setV(((A ^ sub) & (operand ^ sub) & 0x80));
+                A = sub & 255;
+                setZ(A);
+                setN(A);
+            }
+        });
+    }
+
+    function uANC(addressing) {
+        return addressing(function() {
+            illegalOpcode("ANC");
+            A &= data;
+            setZ(A);
+            N = C = (A & 0x080) ? 1 : 0;
+        });
+    }
+
+    function uANE(addressing) {
+        return addressing(function() {
+            illegalOpcode("ANE");
+            // Exact operation unknown. Do nothing
+        });
+    }
+
+    function uARR(addressing) {
+        // Some sources say flags are affected per ROR, others say its more complex. The complex one is chosen
+        return addressing(function() {
+            illegalOpcode("ARR");
+            var val = A & data;
+            var oldC = C ? 0x80 : 0;
+            val = (val >>> 1) | oldC;
+            A = val;
+            setZ(val);
+            setN(val);
+            var comp = A & 0x60;
+            if (comp == 0x60) 		{ C = 1; V = 0; }
+            else if (comp == 0x00) 	{ C = 0; V = 0; }
+            else if (comp == 0x20) 	{ C = 0; V = 1; }
+            else if (comp == 0x40) 	{ C = 1; V = 1; }
+        });
+    }
+
+    function uASR(addressing) {
+        return addressing(function() {
+            illegalOpcode("ASR");
+            var val = A & data;
+            C = (val & 0x01);		// bit 0
+            val = val >>> 1;
+            A = val;
+            setZ(val);
+            N = 0;
+        });
+    }
+
+    function uLAS(addressing) {
+        return addressing(function() {
+            illegalOpcode("LAS");
+            var val = SP & data;
+            A = val;
+            X = val;
+            SP = val;
+            setZ(val);
+            setN(val);
+        });
+    }
+
+    function uLAX(addressing) {
+        return addressing(function() {
+            illegalOpcode("LAX");
+            var val = data;
+            A = val;
+            X = val;
+            setZ(val);
+            setN(val);
+        });
+    }
+
+    function uLXA(addressing) {
+        return addressing(function() {
+            // Some sources say its an OR with $EE then AND with IMM, others exclude the OR,
+            // others exclude both the OR and the AND. Excluding just the OR...
+            illegalOpcode("LXA");
+            var val = A /* | 0xEE) */ & data;
+            A = val;
+            X = val;
+            setZ(val);
+            setN(val);
+        });
+    }
+
+    function uSBX(addressing) {
+        return addressing(function() {
+            illegalOpcode("SBX");
+            var par = A & X;
+            var val = data;
+            var newX = (par - val) & 255;
+            X = newX;
+            setC(par >= val);
+            setZ(newX);
+            setN(newX);
+        });
+    }
+
+
+    // Store operations
+
+    function STA(addressing) {
+        return addressing(function() {
+            data = A;
+        });
+    }
+
+    function STX(addressing) {
+        return addressing(function() {
+            data = X;
+        });
+    }
+
+    function STY(addressing) {
+        return addressing(function() {
+            data = Y;
+        });
+    }
+
+    function uSAX(addressing) {
+        return addressing(function() {
+            // Some sources say it would affect N and Z flags, some say it wouldn't. Chose not to affect
+            illegalOpcode("SAX");
+            data = A & X;
+        });
+    }
+
+    function uSHA(addressing) {
+        return addressing(function() {
+            illegalOpcode("SHA");
+            data = A & X & ((BA >>> 8) + 1) & 255; // A & X & (High byte of effective address + 1) !!!
+            // data would also be stored BAH if page boundary is crossed. Unobservable, not needed here
+        });
+    }
+
+    function uSHS(addressing) {
+        return addressing(function() {
+            illegalOpcode("SHS");
+            var val = A & X;
+            SP = val;
+            data = val & ((BA >>> 8) + 1) & 255; // A & X & (High byte of effective address + 1) !!!
+            // data would also be stored BAH if page boundary is crossed. Unobservable, not needed here
+        });
+    }
+
+    function uSHX(addressing) {
+        return addressing(function() {
+            illegalOpcode("SHX");
+            data = X & ((BA >>> 8) + 1) & 255; // X & (High byte of effective address + 1) !!!
+            // data would also be stored BAH if page boundary is crossed. Unobservable, not needed here
+        });
+    }
+
+    function uSHY(addressing) {
+        return addressing(function() {
+            illegalOpcode("SHY");
+            data = Y & ((BA >>> 8) + 1) & 255; // Y & (High byte of effective address + 1) !!!
+            // data would also be stored BAH if page boundary is crossed. Unobservable, not needed here
+        });
+    }
+
+
+    // Read-Modify-Write operations
+
+    function ASL(addressing) {
+        return addressing(function() {
+            setC(data > 127);
+            var par = (data << 1) & 255;
+            data = par;
+            setZ(par);
+            setN(par);
+        });
+    }
+
+    function DEC(addressing) {
+        return addressing(function() {
+            var par = (data - 1) & 255;
+            data = par;
+            setZ(par);
+            setN(par);
+        });
+    }
+
+    function INC(addressing) {
+        return addressing(function() {
+            var par = (data + 1) & 255;
+            data = par;
+            setZ(par);
+            setN(par);
+        });
+    }
+
+    function LSR(addressing) {
+        return addressing(function() {
+            C = data & 0x01;
+            data >>>= 1;
+            setZ(data);
+            N = 0;
+        });
+    }
+
+    function ROL(addressing) {
+        return addressing(function() {
+            var newC = data > 127;
+            var par = ((data << 1) | C) & 255;
+            data = par;
+            setC(newC);
+            setZ(par);
+            setN(par);
+        });
+    }
+
+    function ROR(addressing) {
+        return addressing(function() {
+            var newC = data & 0x01;
+            var par = (data >>> 1) | (C << 7);
+            data = par;
+            setC(newC);
+            setZ(par);
+            setN(par);
+        });
+    }
+
+    function uDCP(addressing) {
+        return addressing(function() {
+            illegalOpcode("DCP");
+            var par = (data - 1) & 255;
+            data = par;
+            par = A - par;
+            setC(par >= 0);
+            setZ(par);
+            setN(par);
+        });
+    }
+
+    function uISB(addressing) {
+        return addressing(function() {
+            illegalOpcode("ISB");
+            data = (data + 1) & 255;    // ISB is the same as SBC but incs the operand first
+            if (D) {
+                var operand = data;
+                var AL = (A & 15) - (operand & 15) - (1-C);
+                var AH = (A >> 4) - (operand >> 4) - ((AL < 0)?1:0);
+                if (AL < 0) { AL -= 6; }
+                if (AH < 0) { AH -= 6; }
+                var sub = A - operand - (1-C);
+                setC(~sub & 256);
+                setV(((A ^ operand) & (A ^ sub)) & 128);
+                setZ(sub & 255);
+                setN(sub);
+                A = ((AH << 4) | (AL & 15)) & 255;
+            } else {
+                operand = (~data) & 255;
+                sub = A + operand + C;
+                setC(sub > 255);
+                setV(((A ^ sub) & (operand ^ sub) & 0x80));
+                A = sub & 255;
+                setZ(A);
+                setN(A);
+            }
+        });
+    }
+
+    function uRLA(addressing) {
+        return addressing(function() {
+            illegalOpcode("RLA");
+            var val = data;
+            var oldC = C;
+            setC(val & 0x80);		// bit 7 was set
+            val = ((val << 1) | oldC) & 255;
+            data = val;
+            A &= val;
+            setZ(val);              // TODO Verify. May be A instead of val in the flags setting
+            setN(val);
+        });
+    }
+
+    function uRRA(addressing) {
+        return addressing(function() {
+            illegalOpcode("RRA");
+            var val = data;
+            var oldC = C ? 0x80 : 0;
+            setC(val & 0x01);		// bit 0 was set
+            val = (val >>> 1) | oldC;
+            data = val;
+            // RRA is the same as ADC from here
+            if (D) {
+                var operand = data;
+                var AL = (A & 15) + (operand & 15) + C;
+                if (AL > 9) { AL += 6; }
+                var AH = ((A >> 4) + (operand >> 4) + ((AL > 15)?1:0)) << 4;
+                setZ((A + operand + C) & 255);
+                setN(AH);
+                setV(((A ^AH) & ~(A ^ operand)) & 128);
+                if (AH > 0x9f) { AH += 0x60; }
+                setC(AH > 255);
+                A = (AH | (AL & 15)) & 255;
+            } else {
+                var add = A + data + C;
+                setC(add > 255);
+                setV(((A ^ add) & (data ^ add)) & 0x80);
+                A = add & 255;
+                setZ(A);
+                setN(A);
+            }
+        });
+    }
+
+    function uSLO(addressing) {
+        return addressing(function() {
+            illegalOpcode("SLO");
+            var val = data;
+            setC(val & 0x80);		// bit 7 was set
+            val = (val << 1) & 255;
+            data = val;
+            val = A | val;
+            A = val;
+            setZ(val);
+            setN(val);
+        });
+    }
+
+    function uSRE(addressing) {
+        return addressing(function() {
+            illegalOpcode("SRE");
+            var val = data;
+            setC(val & 0x01);		// bit 0 was set
+            val = val >>> 1;
+            data = val;
+            val = (A ^ val) & 255;
+            A = val;
+            setZ(val);
+            setN(val);
+        });
+    }
+
+
+    // Miscellaneous operations
+
+    function PHA() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchOpcodeAndDiscard,
+            function() { pushToStack(A); },
+            fetchNextOpcode
+        ];
+    }
+
+    function PHP() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchOpcodeAndDiscard,
+            function() { pushToStack(getStatusBits()); },
+            fetchNextOpcode
+        ];
+    }
+
+    function PLA() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchOpcodeAndDiscard,
+            peekFromStack,
+            function() {
+                A = popFromStack();
+                setZ(A);
+                setN(A);
+            },
+            fetchNextOpcode
+        ];
+    }
+
+    function PLP() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchOpcodeAndDiscard,
+            peekFromStack,
+            function() { setStatusBits(popFromStack()); },
+            fetchNextOpcode
+        ];
+    }
+
+    function JSR() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchADL,
+            peekFromStack,
+            function() { pushToStack((PC >>> 8)  & 0xff); },
+            function() { pushToStack(PC & 0xff); },
+            fetchADH,
+            function() { PC = AD; fetchNextOpcode(); }
+        ];
+    }
+
+    function BRK() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchDataFromImmediate,                 // For debugging purposes, use operand as an arg for BRK!
+            function() {
+                if (self.debug) self.breakpoint("BRK " + data);
+                pushToStack((PC >>> 8) & 0xff);
+            },
+            function() { pushToStack(PC & 0xff); },
+            function() { pushToStack(getStatusBits()); }, // set B flag
+            function() { AD = bus.read(IRQ_VECTOR); },
+            function() { AD |= bus.read(IRQ_VECTOR + 1) << 8; },
+            function() { PC = AD; I = 1; fetchNextOpcode(); }
+        ];
+    }
+
+    function IRQ() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchDataFromImmediate,                 // For debugging purposes, use operand as an arg for BRK!
+            function() {
+                if (self.debug) self.breakpoint("IRQ " + data);
+                pushToStack((PC >>> 8) & 0xff);
+            },
+            function() { pushToStack(PC & 0xff); },
+            function() { pushToStack(getStatusBits()); },
+            function() { AD = bus.read(IRQ_VECTOR); },
+            function() { AD |= bus.read(IRQ_VECTOR + 1) << 8; },
+            function() { PC = AD; fetchNextOpcode(); }
+        ];
+    }
+
+    function NMI() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchDataFromImmediate,
+            function() {
+                if (self.debug) self.breakpoint("NMI " + data);
+                pushToStack((PC >>> 8) & 0xff);
+            },
+            function() { pushToStack(PC & 0xff); },
+            function() { pushToStack(getStatusBits()); },
+            function() { AD = bus.read(NMI_VECTOR); },
+            function() { AD |= bus.read(NMI_VECTOR + 1) << 8; },
+            function() { PC = AD; fetchNextOpcode(); }
+        ];
+    }
+
+    function RTI() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchOpcodeAndDiscard,
+            peekFromStack,
+            function() { setStatusBits(popFromStack()); },
+            function() { AD = popFromStack(); },
+            function() { AD |= popFromStack() << 8; },
+            function() { PC = AD; fetchNextOpcode(); }
+        ];
+    }
+
+    function RTS() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchOpcodeAndDiscard,
+            peekFromStack,
+            function() { AD = popFromStack(); },
+            function() { AD |= popFromStack() << 8; },
+            function() { PC = AD; fetchDataFromImmediate(); },
+            fetchNextOpcode
+        ];
+    }
+
+    function JMP_ABS() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchADL,
+            fetchADH,
+            function() { PC = AD; fetchNextOpcode(); }
+        ];
+    }
+
+    function JMP_IND() {
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchIAL,                           // IAH will be zero
+            fetchIAH,
+            fetchBALFromIA,
+            function() {
+                add1toIAL();
+                fetchBAHFromIA();
+            },
+            function() { PC = BA; fetchNextOpcode(); }
+        ];
+    }
+
+    function Bxx(reg, cond) {
+        var branchTaken;
+        if      (reg === bZ) branchTaken = function() { return Z === cond; };
+        else if (reg === bN) branchTaken = function() { return N === cond; };
+        else if (reg === bC) branchTaken = function() { return C === cond; };
+        else                 branchTaken = function() { return V === cond; };
+        return [
+            fetchOpcodeAndDecodeInstruction,
+            fetchBranchOffset,
+            function() {
+                if (branchTaken()) {
+                    fetchOpcodeAndDiscard();
+                    addBranchOffsetToPCL();
+                } else {
+                    fetchNextOpcode();
+                }
+            },
+            function() {
+                if(branchOffsetCrossAdjust) {
+                    fetchOpcodeAndDiscard();
+                    adjustPCHForBranchOffsetCross();
+                } else {
+                    fetchNextOpcode();
+                }
+            },
+            fetchNextOpcode
+        ];
+    }
+
+
+    // Savestate  -------------------------------------------
+
+    this.saveState = function():MOS6502State {
+        return {
+            PC: PC, A: A, X: X, Y: Y, SP: SP,
+            N: N, V: V, D: D, I: I, Z: Z, C: C,
+            T: T, o: opcode, R: RDY?1:0,
+            d: data, AD: AD, BA: BA, BC: BALCrossed?1:0, IA: IA,
+            bo: branchOffset, boa: branchOffsetCrossAdjust
+        };
+    };
+
+    this.loadState = function(state:MOS6502State) {
+        PC = state.PC; A = state.A; X = state.X; Y = state.Y; SP = state.SP;
+        N = state.N; V = state.V; D = state.D; I = state.I; Z = state.Z; C = state.C;
+        T = state.T; opcode = state.o; RDY = !!state.R;
+        data = state.d; AD = state.AD; BA = state.BA; BALCrossed = !!state.BC; IA = state.IA;
+        branchOffset = state.bo; branchOffsetCrossAdjust = state.boa;
+        instruction = opcode < 0 ? [ fetchOpcodeAndDecodeInstruction ] : instructions[opcode];
+    };
+
+
+    // Accessory methods
+
+    this.toString = function() {
+        return "CPU " +
+            " PC: " + PC.toString(16) + "  op: " + opcode.toString() + "  T: " + T + "  data: " + data + "\n" +
+            " A: " + A.toString(16) + "  X: " + X.toString(16) + "  Y: " + Y.toString(16) + "  SP: " + SP.toString(16) + "     " +
+            "N" + N + "  " + "V" + V + "  " + "D" + D + "  " + "I" + I + "  " + "Z" + Z + "  " + "C" + C + "  ";
+    };
+
+    this.breakpoint = function(mes) {
+        //jt.Util.log(mes);
+        if (this.trace) {
+            var text = "CPU Breakpoint!  " + (mes ? "(" + mes + ")" : "") + "\n\n" + this.toString();
+            //jt.Util.message(text);
+        }
+    };
+
+    var cycletime = [
+      7, 6, 0, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6,
+      2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7,
+      6, 6, 0, 8, 3, 3, 5, 5, 4, 2, 2, 2, 4, 4, 6, 6,
+      2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7,
+      6, 6, 0, 8, 3, 3, 5, 5, 3, 2, 2, 2, 3, 4, 6, 6,
+      2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7,
+      6, 6, 0, 8, 3, 3, 5, 5, 4, 2, 2, 2, 5, 4, 6, 6,
+      2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7,
+      0, 6, 0, 6, 3, 3, 3, 3, 2, 0, 2, 0, 4, 4, 4, 4,
+      2, 6, 0, 0, 4, 4, 4, 4, 2, 5, 2, 0, 0, 5, 0, 0,
+      2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 0, 4, 4, 4, 4,
+      2, 5, 0, 5, 4, 4, 4, 4, 2, 4, 2, 0, 4, 4, 4, 4,
+      2, 6, 0, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 3, 6,
+      2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7,
+      2, 6, 0, 8, 3, 3, 5, 5, 2, 2, 2, 0, 4, 4, 6, 6,
+      2, 5, 0, 8, 4, 4, 6, 6, 2, 4, 0, 7, 4, 4, 7, 7
+    ];
+
+    var extracycles = [
+      0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,
+      0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,
+      0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,
+      0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,
+      0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1,
+      0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,
+      0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1
+    ];
+
+    var insnlengths = [
+      1, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 2, 3, 3, 3, 3,
+      2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3,
+      3, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 2, 3, 3, 3, 3,
+      2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3,
+      1, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 2, 3, 3, 3, 3,
+      2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3,
+      1, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 2, 3, 3, 3, 3,
+      2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3,
+      0, 2, 0, 2, 2, 2, 2, 2, 1, 0, 1, 0, 3, 3, 3, 3,
+      2, 2, 0, 0, 2, 2, 2, 3, 1, 3, 1, 0, 0, 3, 0, 0,
+      2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 0, 3, 3, 3, 3,
+      2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 1, 0, 3, 3, 3, 3,
+      2, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 2, 3, 3, 3, 3,
+      2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3,
+      2, 2, 0, 2, 2, 2, 2, 2, 1, 2, 1, 0, 3, 3, 3, 3,
+      2, 2, 0, 2, 2, 2, 2, 2, 1, 3, 0, 3, 3, 3, 3, 3
+    ];
+
+    var validinsns = [
+      1, 2, 0, 0, 0, 2, 2, 0, 1, 2, 1, 0, 0, 3, 3, 0,
+      2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0,
+      3, 2, 0, 0, 2, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0,
+      2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0,
+      1, 2, 0, 0, 0, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0,
+      2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0,
+      1, 2, 0, 0, 0, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0,
+      2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0,
+      0, 2, 0, 0, 2, 2, 2, 0, 1, 0, 1, 0, 3, 3, 3, 0,
+      2, 2, 0, 0, 2, 2, 2, 0, 1, 3, 1, 0, 0, 3, 0, 0,
+      2, 2, 2, 0, 2, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0,
+      2, 2, 0, 0, 2, 2, 2, 0, 1, 3, 1, 0, 3, 3, 3, 0,
+      2, 2, 0, 0, 2, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0,
+      2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0,
+      2, 2, 0, 0, 2, 2, 2, 0, 1, 2, 1, 0, 3, 3, 3, 0,
+      2, 2, 0, 0, 0, 2, 2, 0, 1, 3, 0, 0, 0, 3, 3, 0
+    ];
+
+    this.getOpcodeMetadata = function(opcode, address) {
+      // TODO: more intelligent maximum cycles
+      var i = instructions[opcode];
+      return {
+        opcode:opcode,
+        mnenomic:opcodes[opcode],
+        minCycles:cycletime[opcode],
+        maxCycles:cycletime[opcode] + extracycles[opcode],
+        insnlength:insnlengths[opcode]
+      };
+    }
+
+    this.setNMI = function() {
+      instruction = NMI();
+    }
+
+    this.setIRQ = function() {
+      instruction = IRQ();
+    }
+
+    this.getSP = function() { return SP; }
+    this.getPC = function() { return PC; }
+    this.getT = function() { return T; }
+};
+
+export interface MOS6502State {
+  PC,SP : number;
+  A,X,Y : number;
+  N,V,D,I,Z,C : number;
+  T,o,R : number;
+  d,AD,BA,BC,IA,bo,boa : number;
+}
+
+export enum MOS6502Interrupts { None=0, NMI=1, IRQ=2 };
+
+export class MOS6502 implements CPU, ClockBased, SavesState<MOS6502State>, Interruptable<MOS6502Interrupts> {
+
+  cpu = new _MOS6502();
+  interruptType : MOS6502Interrupts = MOS6502Interrupts.None;
+  
+  connectMemoryBus(bus:Bus) {
+    this.cpu.connectBus(bus);
+  }
+  advanceClock() {
+    if (this.interruptType && this.cpu.getT() == 0) {
+      switch (this.interruptType) {
+        case MOS6502Interrupts.NMI: this.cpu.setNMI(); break;
+        case MOS6502Interrupts.IRQ: this.cpu.setIRQ(); break;
+      }
+    }
+    this.cpu.clockPulse();
+  }
+  advanceInsn() {
+    do {
+      this.advanceClock();
+    } while (this.cpu.getT() != 0);
+  }
+  reset() {
+    this.cpu.reset();
+    this.interruptType = 0;
+  }
+  interrupt(itype:number) {
+    this.interruptType = itype;
+  }
+  getSP() {
+    return this.cpu.getSP();
+  }
+  getPC() {
+    return this.cpu.getPC();
+  }
+  saveState() {
+    var s = this.cpu.saveState();
+    s.it = this.interruptType;
+    return s;
+  }
+  loadState(s) {
+    this.cpu.loadState(s);
+    this.interruptType = s.it;
+  }
+  // TODO: metadata
+  // TODO: disassembler
+}
diff --git a/src/nemu/machine/apple2.ts b/src/nemu/machine/apple2.ts
new file mode 100644
index 00000000..77de2227
--- /dev/null
+++ b/src/nemu/machine/apple2.ts
@@ -0,0 +1,1103 @@
+"use strict";
+
+import { MOS6502, MOS6502State } from "../cpu/MOS6502";
+import { Bus, RasterFrameBased, SavesState, AcceptsROM, noise, Resettable } from "../nemu";
+import { KeyFlags } from "../../emu"; // TODO
+import { lzgmini } from "../../util";
+
+const cpuFrequency = 1023000;
+const cpuCyclesPerLine = 65; // approx: http://www.cs.columbia.edu/~sedwards/apple2fpga/
+const cpuCyclesPerFrame = 65*262;
+
+const VM_BASE = 0x803; // where to JMP after pr#6
+const LOAD_BASE = VM_BASE; //0x7c9; // where to load ROM
+const PGM_BASE = VM_BASE; //0x800; // where to load ROM
+const HDR_SIZE = PGM_BASE - LOAD_BASE;
+
+interface AppleIIStateBase {
+  ram : Uint8Array;
+  rnd,kbdlatch,soundstate : number;
+  auxRAMselected,writeinhibit : boolean;
+  auxRAMbank,bank2rdoffset,bank2wroffset : number;
+  grdirty : boolean[];
+}
+
+interface AppleIIState extends AppleIIStateBase {
+  c : MOS6502State;
+}
+
+export class AppleII implements Bus, Resettable, RasterFrameBased, AcceptsROM, AppleIIStateBase, SavesState<AppleIIState> {
+
+  ram = new Uint8Array(0x13000); // 64K + 16K LC RAM - 4K hardware + 12K ROM
+  rom : Uint8Array;
+  cpu = new MOS6502();
+  pixels : Uint32Array;
+  grdirty = new Array(0xc000 >> 7);
+  grparams = {dirty:this.grdirty, grswitch:GR_TXMODE, mem:this.ram};
+  ap2disp;
+  pgmbin : Uint8Array;
+  rnd = 1;
+  kbdlatch = 0;
+  soundstate = 0;
+  // language card switches
+  auxRAMselected = false;
+  auxRAMbank = 1;
+  writeinhibit = true;
+  // value to add when reading & writing each of these banks
+  // bank 1 is E000-FFFF, bank 2 is D000-DFFF
+  bank2rdoffset=0;
+  bank2wroffset=0;
+
+  constructor() {
+    // ROM
+    this.rom = new lzgmini().decode(APPLEIIGO_LZG);
+    this.ram.set(this.rom, 0xd000);
+    this.ram[0xbf00] = 0x4c; // fake DOS detect for C
+    this.ram[0xbf6f] = 0x01; // fake DOS detect for C
+    this.cpu.connectMemoryBus(this);
+  }
+  saveState() {
+    // TODO: automagic
+    return {
+      c: this.cpu.saveState(),
+      ram: this.ram.slice(),
+      rnd: this.rnd,
+      kbdlatch: this.kbdlatch,
+      soundstate: this.soundstate,
+      auxRAMselected: this.auxRAMselected,
+      writeinhibit: this.writeinhibit,
+      auxRAMbank: this.auxRAMbank,
+      bank2rdoffset: this.bank2rdoffset,
+      bank2wroffset: this.bank2wroffset,
+      grdirty: this.grdirty.slice(),
+    };
+  }
+  loadState(s) {
+    this.cpu.loadState(s.c);
+    this.ram.set(s.ram);
+  }
+  reset() {
+    this.cpu.reset();
+  }
+  noise() : number {
+    return (this.rnd = noise(this.rnd)) & 0xff;
+  }
+  read(address:number) : number {
+    address &= 0xffff;
+    if (address < 0xc000) {
+      return this.ram[address];
+    } else if (address >= 0xd000) {
+      if (!this.auxRAMselected)
+        return this.rom[address - 0xd000];
+      else if (address >= 0xe000)
+        return this.ram[address];
+      else
+        return this.ram[address + this.bank2rdoffset];
+    } else if (address < 0xc100) {
+      var slot = (address >> 4) & 0x0f;
+      switch (slot)
+      {
+         case 0:
+            return this.kbdlatch;
+         case 1:
+            this.kbdlatch &= 0x7f;
+            break;
+         case 3:
+            this.soundstate = this.soundstate ^ 1;
+            break;
+         case 5:
+            if ((address & 0x0f) < 8) {
+               // graphics
+               if ((address & 1) != 0)
+                  this.grparams.grswitch |= 1 << ((address >> 1) & 0x07);
+               else
+                  this.grparams.grswitch &= ~(1 << ((address >> 1) & 0x07));
+            }
+            break;
+         case 6:
+            // tapein, joystick, buttons
+            switch (address & 7) {
+               // buttons (off)
+               case 1:
+               case 2:
+               case 3:
+                  return this.noise() & 0x7f;
+                // joystick
+               case 4:
+               case 5:
+                  return this.noise() | 0x80;
+               default:
+                  return this.noise();
+            }
+         case 7:
+            // joy reset
+            if (address == 0xc070)
+               return this.noise() | 0x80;
+         case 8:
+            return this.doLanguageCardIO(address);
+         case 9: case 10: case 11: case 12: case 13: case 14: case 15:
+            return this.noise(); // return slots[slot-8].doIO(address, value);
+      }
+    } else {
+      switch (address) {
+        // JMP VM_BASE
+        case 0xc600: {
+          // load program into RAM
+          if (this.pgmbin)
+            this.ram.set(this.pgmbin.slice(HDR_SIZE), PGM_BASE);
+          return 0x4c;
+        }
+        case 0xc601: return VM_BASE&0xff;
+        case 0xc602: return (VM_BASE>>8)&0xff;
+        default: return this.noise();
+      }
+    }
+    return this.noise();
+  }
+  write(address:number, val:number) : void {
+    address &= 0xffff;
+    val &= 0xff;
+    if (address < 0xc000) {
+      this.ram[address] = val;
+      this.grdirty[address>>7] = 1;
+    } else if (address < 0xc100) {
+      this.read(address); // strobe address, discard result
+    } else if (address >= 0xd000 && !this.writeinhibit) {
+      if (address >= 0xe000)
+        this.ram[address] = val;
+      else
+        this.ram[address + this.bank2wroffset] = val;
+    }
+  }
+  loadROM(data:Uint8Array) {
+    this.pgmbin = data.slice();
+  }
+  getVideoParams() {
+    return {width:280, height:192};
+  }
+  connectVideo(pixels:Uint32Array) {
+    this.pixels = pixels;
+    this.ap2disp = pixels && new Apple2Display(this.pixels, this.grparams);
+  }
+  advanceFrame() : number {
+    for (var i=0; i<cpuCyclesPerFrame; i++) {
+      this.cpu.advanceClock();
+    }
+    this.ap2disp && this.ap2disp.updateScreen();
+    return i;
+  }
+  setInput(key:number, code:number, flags:number) : void {
+    if (flags & KeyFlags.KeyPress) {
+      // convert to uppercase for Apple ][
+      if (code >= 0x61 && code <= 0x7a)
+         code -= 32; 
+      if (code >= 32) {
+        if (code >= 65 && code < 65+26) {
+          if (flags & KeyFlags.Ctrl)
+            code -= 64; // ctrl
+        }
+        this.kbdlatch = (code | 0x80) & 0xff;
+      }
+    } else if (flags & KeyFlags.KeyDown) {
+      code = 0;
+      switch (key) {
+        case 13: code=13; break; // return
+        case 37: code=8; break; // left
+        case 39: code=21; break; // right
+        case 38: code=11; break; // up
+        case 40: code=10; break; // down
+      }
+      if (code)
+        this.kbdlatch = (code | 0x80) & 0xff;
+    }
+  }
+  
+  doLanguageCardIO(address:number) {
+     switch (address & 0x0f) {
+         // Select aux RAM bank 2, write protected.
+        case 0x0:
+        case 0x4:
+           this.auxRAMselected = true;
+           this.auxRAMbank = 2;
+           this.writeinhibit = true;
+           break;
+        // Select ROM, write enable aux RAM bank 2.
+        case 0x1:
+        case 0x5:
+           this.auxRAMselected = false;
+           this.auxRAMbank = 2;
+           this.writeinhibit = false;
+           break;
+        // Select ROM, write protect aux RAM (either bank).
+        case 0x2:
+        case 0x6:
+        case 0xA:
+        case 0xE:
+           this.auxRAMselected = false;
+           this.writeinhibit = true;
+           break;
+        // Select aux RAM bank 2, write enabled.
+        case 0x3:
+        case 0x7:
+           this.auxRAMselected = true;
+           this.auxRAMbank = 2;
+           this.writeinhibit = false;
+           break;
+        // Select aux RAM bank 1, write protected.
+        case 0x8:
+        case 0xC:
+           this.auxRAMselected = true;
+           this.auxRAMbank = 1;
+           this.writeinhibit = true;
+           break;
+        // Select ROM, write enable aux RAM bank 1.
+        case 0x9:
+        case 0xD:
+           this.auxRAMselected = false;
+           this.auxRAMbank = 1;
+           this.writeinhibit = false;
+           break;
+       // Select aux RAM bank 1, write enabled.
+        case 0xB:
+        case 0xF:
+           this.auxRAMselected = true;
+           this.auxRAMbank = 1;
+           this.writeinhibit = false;
+           break;
+     }
+     this.setupLanguageCardConstants();
+     return this.noise();
+  }
+
+  setupLanguageCardConstants() {
+    // reset language card constants
+     if (this.auxRAMbank == 2)
+        this.bank2rdoffset = -0x1000;   // map 0xd000-0xdfff -> 0xc000-0xcfff
+     else
+        this.bank2rdoffset = 0x3000; // map 0xd000-0xdfff -> 0x10000-0x10fff
+     if (this.auxRAMbank == 2)
+        this.bank2wroffset = -0x1000;   // map 0xd000-0xdfff -> 0xc000-0xcfff
+     else
+        this.bank2wroffset = 0x3000; // map 0xd000-0xdfff -> 0x10000-0x10fff
+  }
+}
+
+const GR_TXMODE   = 1;
+const GR_MIXMODE  = 2;
+const GR_PAGE1    = 4;
+const GR_HIRES    = 8;
+
+type AppleGRParams = {dirty:boolean[], grswitch:number, mem:Uint8Array};
+
+/*
+const _Apple2Platform = function(mainElement) {
+  const cpuFrequency = 1023000;
+  const cpuCyclesPerLine = 65;
+
+  var cpu, ram, bus;
+  var video, ap2disp, audio, timer;
+  var grdirty = new Array(0xc000 >> 7);
+  var grswitch = GR_TXMODE;
+  var kbdlatch = 0;
+  var soundstate = 0;
+  var pgmbin;
+  // language card switches
+  var auxRAMselected = false;
+  var auxRAMbank = 1;
+  var writeinhibit = true;
+  // value to add when reading & writing each of these banks
+  // bank 1 is E000-FFFF, bank 2 is D000-DFFF
+  var bank2rdoffset=0, bank2wroffset=0;
+  var grparams : AppleGRParams;
+  var scanline : number;
+  
+ class Apple2Platform extends Base6502Platform implements Platform {
+
+  getPresets() {
+    return APPLE2_PRESETS;
+  }
+  start() {
+      }
+    };
+    cpu.connectBus(bus);
+    // create video/audio
+    video = new RasterVideo(mainElement,280,192);
+    audio = new SampleAudio(cpuFrequency);
+    video.create();
+    video.setKeyboardEvents((key,code,flags) => {
+    });
+    var idata = video.getFrameData();
+    grparams = {dirty:grdirty, grswitch:grswitch, mem:ram.mem};
+    ap2disp = new Apple2Display(idata, grparams);
+    timer = new AnimationTimer(60, this.nextFrame.bind(this));
+  }
+  
+  advance(novideo : boolean) {
+    // 262.5 scanlines per frame
+    var clock = 0;
+    var debugCond = this.getDebugCallback();
+    for (var sl=0; sl<262; sl++) {
+      scanline = sl;
+      for (var i=0; i<cpuCyclesPerLine; i++) {
+        if (debugCond && debugCond()) {
+          debugCond = null;
+          sl = 999;
+          break;
+        }
+        clock++;
+        cpu.clockPulse();
+        audio.feedSample(soundstate, 1);
+      }
+    }
+    if (!novideo) {
+      grparams.dirty = grdirty;
+      grparams.grswitch = grswitch;
+      ap2disp.updateScreen();
+      video.updateFrame();
+    }
+  }
+  
+  getRasterScanline() : number {
+    return scanline;
+  }
+
+  loadROM(title, data) {
+    pgmbin = data;
+    this.reset();
+  }
+
+  isRunning() {
+    return timer.isRunning();
+  }
+  pause() {
+    timer.stop();
+    audio.stop();
+  }
+  resume() {
+    timer.start();
+    audio.start();
+  }
+  reset() {
+    cpu.reset();
+    // execute until $c600 boot
+    for (var i=0; i<2000000; i++) {
+      cpu.clockPulse();
+      if (this.getCPUState().PC == 0xc602) {
+        cpu.clockPulse();
+        cpu.clockPulse();
+        break;
+      }
+    }
+  }
+  readAddress(addr : number) {
+    return ((addr & 0xf000) != 0xc000) ? bus.read(addr) : null; // ignore I/O space
+  }
+
+  loadState(state) {
+    this.unfixPC(state.c);
+    cpu.loadState(state.c);
+    this.fixPC(state.c);
+    ram.mem.set(state.b);
+    kbdlatch = state.kbd;
+    grswitch = state.gr;
+    auxRAMselected = state.lc.s;
+    auxRAMbank = state.lc.b;
+    writeinhibit = state.lc.w;
+    setupLanguageCardConstants();
+    ap2disp.invalidate(); // repaint entire screen
+  }
+  saveState() {
+    return {
+      c:this.getCPUState(),
+      b:ram.mem.slice(0),
+      kbd:kbdlatch,
+      gr:grswitch,
+      lc:{s:auxRAMselected,b:auxRAMbank,w:writeinhibit},
+    };
+  }
+  loadControlsState(state) {
+    kbdlatch = state.kbd;
+  }
+  saveControlsState() {
+    return {
+      kbd:kbdlatch
+    };
+  }
+  getCPUState() {
+    return this.fixPC(cpu.saveState());
+  }
+ }
+
+  return new Apple2Platform(); // return inner class from constructor
+};
+*/
+
+var Apple2Display = function(pixels : Uint32Array, apple : AppleGRParams) {
+  var XSIZE = 280;
+  var YSIZE = 192;
+  var PIXELON = 0xffffffff;
+  var PIXELOFF = 0xff000000;
+
+  var oldgrmode = -1;
+  var textbuf = new Array(40*24);
+
+  const flashInterval = 500;
+
+  const loresColor = [
+     (0xff000000), (0xffff00ff), (0xff00007f), (0xff7f007f),
+     (0xff007f00), (0xff7f7f7f), (0xff0000bf), (0xff0000ff),
+     (0xffbf7f00), (0xffffbf00), (0xffbfbfbf), (0xffff7f7f),
+     (0xff00ff00), (0xffffff00), (0xff00bf7f), (0xffffffff),
+  ];
+
+  const text_lut = [
+     0x000, 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380,
+     0x028, 0x0a8, 0x128, 0x1a8, 0x228, 0x2a8, 0x328, 0x3a8,
+     0x050, 0x0d0, 0x150, 0x1d0, 0x250, 0x2d0, 0x350, 0x3d0
+  ];
+
+  const hires_lut = [
+     0x0000, 0x0400, 0x0800, 0x0c00, 0x1000, 0x1400, 0x1800, 0x1c00,
+     0x0080, 0x0480, 0x0880, 0x0c80, 0x1080, 0x1480, 0x1880, 0x1c80,
+     0x0100, 0x0500, 0x0900, 0x0d00, 0x1100, 0x1500, 0x1900, 0x1d00,
+     0x0180, 0x0580, 0x0980, 0x0d80, 0x1180, 0x1580, 0x1980, 0x1d80,
+     0x0200, 0x0600, 0x0a00, 0x0e00, 0x1200, 0x1600, 0x1a00, 0x1e00,
+     0x0280, 0x0680, 0x0a80, 0x0e80, 0x1280, 0x1680, 0x1a80, 0x1e80,
+     0x0300, 0x0700, 0x0b00, 0x0f00, 0x1300, 0x1700, 0x1b00, 0x1f00,
+     0x0380, 0x0780, 0x0b80, 0x0f80, 0x1380, 0x1780, 0x1b80, 0x1f80,
+     0x0028, 0x0428, 0x0828, 0x0c28, 0x1028, 0x1428, 0x1828, 0x1c28,
+     0x00a8, 0x04a8, 0x08a8, 0x0ca8, 0x10a8, 0x14a8, 0x18a8, 0x1ca8,
+     0x0128, 0x0528, 0x0928, 0x0d28, 0x1128, 0x1528, 0x1928, 0x1d28,
+     0x01a8, 0x05a8, 0x09a8, 0x0da8, 0x11a8, 0x15a8, 0x19a8, 0x1da8,
+     0x0228, 0x0628, 0x0a28, 0x0e28, 0x1228, 0x1628, 0x1a28, 0x1e28,
+     0x02a8, 0x06a8, 0x0aa8, 0x0ea8, 0x12a8, 0x16a8, 0x1aa8, 0x1ea8,
+     0x0328, 0x0728, 0x0b28, 0x0f28, 0x1328, 0x1728, 0x1b28, 0x1f28,
+     0x03a8, 0x07a8, 0x0ba8, 0x0fa8, 0x13a8, 0x17a8, 0x1ba8, 0x1fa8,
+     0x0050, 0x0450, 0x0850, 0x0c50, 0x1050, 0x1450, 0x1850, 0x1c50,
+     0x00d0, 0x04d0, 0x08d0, 0x0cd0, 0x10d0, 0x14d0, 0x18d0, 0x1cd0,
+     0x0150, 0x0550, 0x0950, 0x0d50, 0x1150, 0x1550, 0x1950, 0x1d50,
+     0x01d0, 0x05d0, 0x09d0, 0x0dd0, 0x11d0, 0x15d0, 0x19d0, 0x1dd0,
+     0x0250, 0x0650, 0x0a50, 0x0e50, 0x1250, 0x1650, 0x1a50, 0x1e50,
+     0x02d0, 0x06d0, 0x0ad0, 0x0ed0, 0x12d0, 0x16d0, 0x1ad0, 0x1ed0,
+     0x0350, 0x0750, 0x0b50, 0x0f50, 0x1350, 0x1750, 0x1b50, 0x1f50,
+     0x03d0, 0x07d0, 0x0bd0, 0x0fd0, 0x13d0, 0x17d0, 0x1bd0, 0x1fd0
+  ];
+
+  var colors_lut;
+
+  /**
+    * This function makes the color lookup table for hires mode.
+    * We make a table of 1024 * 2 * 7 entries.
+    * Why? Because we assume each color byte has 10 bits
+    * (8 real bits + 1 on each side) and we need different colors
+    * for odd and even addresses (2) and each byte displays 7 pixels.
+    */
+  {
+     colors_lut = new Array(256*4*2*7);
+     var i,j;
+     var c1,c2,c3 = 15;
+     var base = 0;
+
+     // go thru odd and even
+     for (j=0; j<2; j++)
+     {
+        // go thru 1024 values
+        for (var b1=0; b1<1024; b1++)
+        {
+           // see if the hi bit is set
+           if ((b1 & 0x80) == 0)
+           {
+              c1 = 1; c2 = 12;    // red & green
+           } else
+           {
+              c1 = 7; c2 = 9;     // blue & orange
+           }
+           // make a value consisting of:
+           // the 8th bit, then bits 0-7, then the 9th bit
+           var b = ((b1 & 0x100) >> 8) | ((b1 & 0x7f) << 1) |
+                   ((b1 & 0x200) >> 1);
+           // go through each pixel
+           for (i=0; i<7; i++)
+           {
+              var c;
+              // is this pixel lit?
+              if (((2<<i)&b) != 0)
+              {
+                 // are there pixels lit on both sides of this one?
+                 if (((7<<i)&b) == (7<<i))
+                    // yes, make it white
+                    c = 15;
+                 else
+                    // no, choose color based on odd/even byte
+                    // and odd/even pixel column
+                    c = ((((j ^ i) & 1) == 0) ? c1 : c2);
+              } else
+              {
+                 // are there pixels lit in the previous & next
+                 // column but none in this?
+                 if (((5<<i)&b) == (5<<i))
+                    // color this pixel
+                    c = ((((j ^ i) & 1) != 0) ? c1 : c2);
+                 else
+                    c = 0;
+              }
+              colors_lut[base] = loresColor[c];
+              base++;
+           }
+        }
+     }
+  }
+
+  function drawLoresChar(x, y, b)
+  {
+     var i,base,adr,c;
+     base = (y<<3)*XSIZE + x*7; //(x<<2) + (x<<1) + x
+     c = loresColor[b & 0x0f];
+     for (i=0; i<4; i++)
+     {
+        pixels[base] =
+        pixels[base+1] =
+        pixels[base+2] =
+        pixels[base+3] =
+        pixels[base+4] =
+        pixels[base+5] =
+        pixels[base+6] = c;
+        base += XSIZE;
+     }
+     c = loresColor[b >> 4];
+     for (i=0; i<4; i++)
+     {
+        pixels[base] =
+        pixels[base+1] =
+        pixels[base+2] =
+        pixels[base+3] =
+        pixels[base+4] =
+        pixels[base+5] =
+        pixels[base+6] = c;
+        base += XSIZE;
+     }
+  }
+
+  function drawTextChar(x, y, b, invert)
+  {
+     var base = (y<<3)*XSIZE + x*7; // (x<<2) + (x<<1) + x
+     var on,off;
+     if (invert)
+     {
+        on = PIXELOFF;
+        off = PIXELON;
+     } else
+     {
+        on = PIXELON;
+        off = PIXELOFF;
+     }
+
+     for (var yy=0; yy<8; yy++)
+     {
+        var chr = apple2_charset[(b<<3)+yy];
+        pixels[base] = ((chr & 64) > 0)?on:off;
+        pixels[base+1] = ((chr & 32) > 0)?on:off;
+        pixels[base+2] = ((chr & 16) > 0)?on:off;
+        pixels[base+3] = ((chr & 8) > 0)?on:off;
+        pixels[base+4] = ((chr & 4) > 0)?on:off;
+        pixels[base+5] = ((chr & 2) > 0)?on:off;
+        pixels[base+6] = ((chr & 1) > 0)?on:off;
+        base += XSIZE;
+     }
+  }
+
+  function drawHiresLines(y, maxy)
+  {
+     var yb = y*XSIZE;
+     for (; y < maxy; y++)
+     {
+        var base = hires_lut[y] + (((apple.grswitch & GR_PAGE1) != 0) ? 0x4000 : 0x2000);
+        if (!apple.dirty[base >> 7])
+        {
+           yb += XSIZE;
+           continue;
+        }
+        var c1, c2;
+        var b = 0;
+        var b1 = apple.mem[base] & 0xff;
+        for (var x1=0; x1<20; x1++)
+        {
+           var b2 = apple.mem[base+1] & 0xff;
+           var b3 = apple.mem[base+2] & 0xff;
+           var d1 = (((b&0x40)<<2) | b1 | b2<<9) & 0x3ff;
+           for (var i=0; i<7; i++)
+              pixels[yb+i] = colors_lut[d1*7+i];
+           var d2 = (((b1&0x40)<<2) | b2 | b3<<9) & 0x3ff;
+           for (var i=0; i<7; i++)
+              pixels[yb+7+i] = colors_lut[d2*7+7168+i];
+           yb += 14;
+           base += 2;
+           b = b2;
+           b1 = b3;
+        }
+     }
+  }
+
+  function drawLoresLine(y)
+  {
+     // get the base address of this line
+     var base = text_lut[y] +
+                (((apple.grswitch & GR_PAGE1) != 0) ? 0x800 : 0x400);
+  //		if (!dirty[base >> 7])
+  //		    return;
+     for (var x=0; x<40; x++)
+     {
+        var b = apple.mem[base+x] & 0xff;
+        // if the char. changed, draw it
+        if (b != textbuf[y*40+x])
+        {
+           drawLoresChar(x, y, b);
+           textbuf[y*40+x] = b;
+        }
+     }
+  }
+
+  function drawTextLine(y, flash)
+  {
+     // get the base address of this line
+     var base = text_lut[y] +
+                (((apple.grswitch & GR_PAGE1) != 0) ? 0x800 : 0x400);
+  //		if (!dirty[base >> 7])
+  //		    return;
+     for (var x=0; x<40; x++)
+     {
+        var b = apple.mem[base+x] & 0xff;
+        var invert;
+        // invert flash characters 1/2 of the time
+        if (b >= 0x80)
+        {
+           invert = false;
+        } else if (b >= 0x40)
+        {
+           invert = flash;
+           if (flash)
+              b -= 0x40;
+           else
+              b += 0x40;
+        } else
+           invert = true;
+        // if the char. changed, draw it
+        if (b != textbuf[y*40+x])
+        {
+           drawTextChar(x, y, b & 0x7f, invert);
+           textbuf[y*40+x] = b;
+        }
+     }
+  }
+
+  this.updateScreen = function(totalrepaint)
+  {
+     var y;
+     var flash = (new Date().getTime() % (flashInterval<<1)) > flashInterval;
+
+     // if graphics mode changed, repaint whole screen
+     if (apple.grswitch != oldgrmode)
+     {
+        oldgrmode = apple.grswitch;
+        totalrepaint = true;
+     }
+     if (totalrepaint)
+     {
+        // clear textbuf if in text mode
+        if ((apple.grswitch & GR_TXMODE) != 0 || (apple.grswitch & GR_MIXMODE) != 0)
+        {
+           for (y=0; y<24; y++)
+              for (var x=0; x<40; x++)
+                 textbuf[y*40+x] = -1;
+        }
+        for (var i=0; i<apple.dirty.length; i++)
+           apple.dirty[i] = true;
+     }
+
+     // first, draw top part of window
+     if ((apple.grswitch & GR_TXMODE) != 0)
+     {
+        for (y=0; y<20; y++)
+           drawTextLine(y, flash);
+     } else
+     {
+        if ((apple.grswitch & GR_HIRES) != 0)
+           drawHiresLines(0, 160);
+        else
+           for (y=0; y<20; y++)
+              drawLoresLine(y);
+     }
+
+     // now do mixed part of window
+     if ((apple.grswitch & GR_TXMODE) != 0 || (apple.grswitch & GR_MIXMODE) != 0)
+     {
+        for (y=20; y<24; y++)
+           drawTextLine(y, flash);
+     } else
+     {
+        if ((apple.grswitch & GR_HIRES) != 0)
+           drawHiresLines(160, 192);
+        else
+           for (y=20; y<24; y++)
+              drawLoresLine(y);
+     }
+     for (var i=0; i<apple.dirty.length; i++)
+        apple.dirty[i] = false;
+  }
+  
+  this.invalidate = function() {
+    oldgrmode = -1;
+  }
+}
+
+/*exported apple2_charset */
+
+const apple2_charset = [
+    0x00,0x1c,0x22,0x2a,0x2e,0x2c,0x20,0x1e,
+    0x00,0x08,0x14,0x22,0x22,0x3e,0x22,0x22,
+    0x00,0x3c,0x22,0x22,0x3c,0x22,0x22,0x3c,
+    0x00,0x1c,0x22,0x20,0x20,0x20,0x22,0x1c,
+    0x00,0x3c,0x22,0x22,0x22,0x22,0x22,0x3c,
+    0x00,0x3e,0x20,0x20,0x3c,0x20,0x20,0x3e,
+    0x00,0x3e,0x20,0x20,0x3c,0x20,0x20,0x20,
+    0x00,0x1e,0x20,0x20,0x20,0x26,0x22,0x1e,
+    0x00,0x22,0x22,0x22,0x3e,0x22,0x22,0x22,
+    0x00,0x1c,0x08,0x08,0x08,0x08,0x08,0x1c,
+    0x00,0x02,0x02,0x02,0x02,0x02,0x22,0x1c,
+    0x00,0x22,0x24,0x28,0x30,0x28,0x24,0x22,
+    0x00,0x20,0x20,0x20,0x20,0x20,0x20,0x3e,
+    0x00,0x22,0x36,0x2a,0x2a,0x22,0x22,0x22,
+    0x00,0x22,0x22,0x32,0x2a,0x26,0x22,0x22,
+    0x00,0x1c,0x22,0x22,0x22,0x22,0x22,0x1c,
+    0x00,0x3c,0x22,0x22,0x3c,0x20,0x20,0x20,
+    0x00,0x1c,0x22,0x22,0x22,0x2a,0x24,0x1a,
+    0x00,0x3c,0x22,0x22,0x3c,0x28,0x24,0x22,
+    0x00,0x1c,0x22,0x20,0x1c,0x02,0x22,0x1c,
+    0x00,0x3e,0x08,0x08,0x08,0x08,0x08,0x08,
+    0x00,0x22,0x22,0x22,0x22,0x22,0x22,0x1c,
+    0x00,0x22,0x22,0x22,0x22,0x22,0x14,0x08,
+    0x00,0x22,0x22,0x22,0x2a,0x2a,0x36,0x22,
+    0x00,0x22,0x22,0x14,0x08,0x14,0x22,0x22,
+    0x00,0x22,0x22,0x14,0x08,0x08,0x08,0x08,
+    0x00,0x3e,0x02,0x04,0x08,0x10,0x20,0x3e,
+    0x00,0x3e,0x30,0x30,0x30,0x30,0x30,0x3e,
+    0x00,0x00,0x20,0x10,0x08,0x04,0x02,0x00,
+    0x00,0x3e,0x06,0x06,0x06,0x06,0x06,0x3e,
+    0x00,0x00,0x00,0x08,0x14,0x22,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x08,0x08,0x08,0x08,0x08,0x00,0x08,
+    0x00,0x14,0x14,0x14,0x00,0x00,0x00,0x00,
+    0x00,0x14,0x14,0x3e,0x14,0x3e,0x14,0x14,
+    0x00,0x08,0x1e,0x28,0x1c,0x0a,0x3c,0x08,
+    0x00,0x30,0x32,0x04,0x08,0x10,0x26,0x06,
+    0x00,0x10,0x28,0x28,0x10,0x2a,0x24,0x1a,
+    0x00,0x08,0x08,0x08,0x00,0x00,0x00,0x00,
+    0x00,0x08,0x10,0x20,0x20,0x20,0x10,0x08,
+    0x00,0x08,0x04,0x02,0x02,0x02,0x04,0x08,
+    0x00,0x08,0x2a,0x1c,0x08,0x1c,0x2a,0x08,
+    0x00,0x00,0x08,0x08,0x3e,0x08,0x08,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x08,0x08,0x10,
+    0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,
+    0x00,0x00,0x02,0x04,0x08,0x10,0x20,0x00,
+    0x00,0x1c,0x22,0x26,0x2a,0x32,0x22,0x1c,
+    0x00,0x08,0x18,0x08,0x08,0x08,0x08,0x1c,
+    0x00,0x1c,0x22,0x02,0x0c,0x10,0x20,0x3e,
+    0x00,0x3e,0x02,0x04,0x0c,0x02,0x22,0x1c,
+    0x00,0x04,0x0c,0x14,0x24,0x3e,0x04,0x04,
+    0x00,0x3e,0x20,0x3c,0x02,0x02,0x22,0x1c,
+    0x00,0x0e,0x10,0x20,0x3c,0x22,0x22,0x1c,
+    0x00,0x3e,0x02,0x04,0x08,0x10,0x10,0x10,
+    0x00,0x1c,0x22,0x22,0x1c,0x22,0x22,0x1c,
+    0x00,0x1c,0x22,0x22,0x1e,0x02,0x04,0x38,
+    0x00,0x00,0x00,0x08,0x00,0x08,0x00,0x00,
+    0x00,0x00,0x00,0x08,0x00,0x08,0x08,0x10,
+    0x00,0x04,0x08,0x10,0x20,0x10,0x08,0x04,
+    0x00,0x00,0x00,0x3e,0x00,0x3e,0x00,0x00,
+    0x00,0x10,0x08,0x04,0x02,0x04,0x08,0x10,
+    0x00,0x1c,0x22,0x04,0x08,0x08,0x00,0x08,
+    0x80,0x9c,0xa2,0xaa,0xae,0xac,0xa0,0x9e,
+    0x80,0x88,0x94,0xa2,0xa2,0xbe,0xa2,0xa2,
+    0x80,0xbc,0xa2,0xa2,0xbc,0xa2,0xa2,0xbc,
+    0x80,0x9c,0xa2,0xa0,0xa0,0xa0,0xa2,0x9c,
+    0x80,0xbc,0xa2,0xa2,0xa2,0xa2,0xa2,0xbc,
+    0x80,0xbe,0xa0,0xa0,0xbc,0xa0,0xa0,0xbe,
+    0x80,0xbe,0xa0,0xa0,0xbc,0xa0,0xa0,0xa0,
+    0x80,0x9e,0xa0,0xa0,0xa0,0xa6,0xa2,0x9e,
+    0x80,0xa2,0xa2,0xa2,0xbe,0xa2,0xa2,0xa2,
+    0x80,0x9c,0x88,0x88,0x88,0x88,0x88,0x9c,
+    0x80,0x82,0x82,0x82,0x82,0x82,0xa2,0x9c,
+    0x80,0xa2,0xa4,0xa8,0xb0,0xa8,0xa4,0xa2,
+    0x80,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xbe,
+    0x80,0xa2,0xb6,0xaa,0xaa,0xa2,0xa2,0xa2,
+    0x80,0xa2,0xa2,0xb2,0xaa,0xa6,0xa2,0xa2,
+    0x80,0x9c,0xa2,0xa2,0xa2,0xa2,0xa2,0x9c,
+    0x80,0xbc,0xa2,0xa2,0xbc,0xa0,0xa0,0xa0,
+    0x80,0x9c,0xa2,0xa2,0xa2,0xaa,0xa4,0x9a,
+    0x80,0xbc,0xa2,0xa2,0xbc,0xa8,0xa4,0xa2,
+    0x80,0x9c,0xa2,0xa0,0x9c,0x82,0xa2,0x9c,
+    0x80,0xbe,0x88,0x88,0x88,0x88,0x88,0x88,
+    0x80,0xa2,0xa2,0xa2,0xa2,0xa2,0xa2,0x9c,
+    0x80,0xa2,0xa2,0xa2,0xa2,0xa2,0x94,0x88,
+    0x80,0xa2,0xa2,0xa2,0xaa,0xaa,0xb6,0xa2,
+    0x80,0xa2,0xa2,0x94,0x88,0x94,0xa2,0xa2,
+    0x80,0xa2,0xa2,0x94,0x88,0x88,0x88,0x88,
+    0x80,0xbe,0x82,0x84,0x88,0x90,0xa0,0xbe,
+    0x80,0xbe,0xb0,0xb0,0xb0,0xb0,0xb0,0xbe,
+    0x80,0x80,0xa0,0x90,0x88,0x84,0x82,0x80,
+    0x80,0xbe,0x86,0x86,0x86,0x86,0x86,0xbe,
+    0x80,0x80,0x80,0x88,0x94,0xa2,0x80,0x80,
+    0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xbe,
+    0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+    0x80,0x88,0x88,0x88,0x88,0x88,0x80,0x88,
+    0x80,0x94,0x94,0x94,0x80,0x80,0x80,0x80,
+    0x80,0x94,0x94,0xbe,0x94,0xbe,0x94,0x94,
+    0x80,0x88,0x9e,0xa8,0x9c,0x8a,0xbc,0x88,
+    0x80,0xb0,0xb2,0x84,0x88,0x90,0xa6,0x86,
+    0x80,0x90,0xa8,0xa8,0x90,0xaa,0xa4,0x9a,
+    0x80,0x88,0x88,0x88,0x80,0x80,0x80,0x80,
+    0x80,0x88,0x90,0xa0,0xa0,0xa0,0x90,0x88,
+    0x80,0x88,0x84,0x82,0x82,0x82,0x84,0x88,
+    0x80,0x88,0xaa,0x9c,0x88,0x9c,0xaa,0x88,
+    0x80,0x80,0x88,0x88,0xbe,0x88,0x88,0x80,
+    0x80,0x80,0x80,0x80,0x80,0x88,0x88,0x90,
+    0x80,0x80,0x80,0x80,0xbe,0x80,0x80,0x80,
+    0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x88,
+    0x80,0x80,0x82,0x84,0x88,0x90,0xa0,0x80,
+    0x80,0x9c,0xa2,0xa6,0xaa,0xb2,0xa2,0x9c,
+    0x80,0x88,0x98,0x88,0x88,0x88,0x88,0x9c,
+    0x80,0x9c,0xa2,0x82,0x8c,0x90,0xa0,0xbe,
+    0x80,0xbe,0x82,0x84,0x8c,0x82,0xa2,0x9c,
+    0x80,0x84,0x8c,0x94,0xa4,0xbe,0x84,0x84,
+    0x80,0xbe,0xa0,0xbc,0x82,0x82,0xa2,0x9c,
+    0x80,0x8e,0x90,0xa0,0xbc,0xa2,0xa2,0x9c,
+    0x80,0xbe,0x82,0x84,0x88,0x90,0x90,0x90,
+    0x80,0x9c,0xa2,0xa2,0x9c,0xa2,0xa2,0x9c,
+    0x80,0x9c,0xa2,0xa2,0x9e,0x82,0x84,0xb8,
+    0x80,0x80,0x80,0x88,0x80,0x88,0x80,0x80,
+    0x80,0x80,0x80,0x88,0x80,0x88,0x88,0x90,
+    0x80,0x84,0x88,0x90,0xa0,0x90,0x88,0x84,
+    0x80,0x80,0x80,0xbe,0x80,0xbe,0x80,0x80,
+    0x80,0x90,0x88,0x84,0x82,0x84,0x88,0x90,
+    0x80,0x9c,0xa2,0x84,0x88,0x88,0x80,0x88,
+    0x00,0x1c,0x22,0x2a,0x2e,0x2c,0x20,0x1e,
+    0x00,0x08,0x14,0x22,0x22,0x3e,0x22,0x22,
+    0x00,0x3c,0x22,0x22,0x3c,0x22,0x22,0x3c,
+    0x00,0x1c,0x22,0x20,0x20,0x20,0x22,0x1c,
+    0x00,0x3c,0x22,0x22,0x22,0x22,0x22,0x3c,
+    0x00,0x3e,0x20,0x20,0x3c,0x20,0x20,0x3e,
+    0x00,0x3e,0x20,0x20,0x3c,0x20,0x20,0x20,
+    0x00,0x1e,0x20,0x20,0x20,0x26,0x22,0x1e,
+    0x00,0x22,0x22,0x22,0x3e,0x22,0x22,0x22,
+    0x00,0x1c,0x08,0x08,0x08,0x08,0x08,0x1c,
+    0x00,0x02,0x02,0x02,0x02,0x02,0x22,0x1c,
+    0x00,0x22,0x24,0x28,0x30,0x28,0x24,0x22,
+    0x00,0x20,0x20,0x20,0x20,0x20,0x20,0x3e,
+    0x00,0x22,0x36,0x2a,0x2a,0x22,0x22,0x22,
+    0x00,0x22,0x22,0x32,0x2a,0x26,0x22,0x22,
+    0x00,0x1c,0x22,0x22,0x22,0x22,0x22,0x1c,
+    0x00,0x3c,0x22,0x22,0x3c,0x20,0x20,0x20,
+    0x00,0x1c,0x22,0x22,0x22,0x2a,0x24,0x1a,
+    0x00,0x3c,0x22,0x22,0x3c,0x28,0x24,0x22,
+    0x00,0x1c,0x22,0x20,0x1c,0x02,0x22,0x1c,
+    0x00,0x3e,0x08,0x08,0x08,0x08,0x08,0x08,
+    0x00,0x22,0x22,0x22,0x22,0x22,0x22,0x1c,
+    0x00,0x22,0x22,0x22,0x22,0x22,0x14,0x08,
+    0x00,0x22,0x22,0x22,0x2a,0x2a,0x36,0x22,
+    0x00,0x22,0x22,0x14,0x08,0x14,0x22,0x22,
+    0x00,0x22,0x22,0x14,0x08,0x08,0x08,0x08,
+    0x00,0x3e,0x02,0x04,0x08,0x10,0x20,0x3e,
+    0x00,0x3e,0x30,0x30,0x30,0x30,0x30,0x3e,
+    0x00,0x00,0x20,0x10,0x08,0x04,0x02,0x00,
+    0x00,0x3e,0x06,0x06,0x06,0x06,0x06,0x3e,
+    0x00,0x00,0x00,0x08,0x14,0x22,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x08,0x08,0x08,0x08,0x08,0x00,0x08,
+    0x00,0x14,0x14,0x14,0x00,0x00,0x00,0x00,
+    0x00,0x14,0x14,0x3e,0x14,0x3e,0x14,0x14,
+    0x00,0x08,0x1e,0x28,0x1c,0x0a,0x3c,0x08,
+    0x00,0x30,0x32,0x04,0x08,0x10,0x26,0x06,
+    0x00,0x10,0x28,0x28,0x10,0x2a,0x24,0x1a,
+    0x00,0x08,0x08,0x08,0x00,0x00,0x00,0x00,
+    0x00,0x08,0x10,0x20,0x20,0x20,0x10,0x08,
+    0x00,0x08,0x04,0x02,0x02,0x02,0x04,0x08,
+    0x00,0x08,0x2a,0x1c,0x08,0x1c,0x2a,0x08,
+    0x00,0x00,0x08,0x08,0x3e,0x08,0x08,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x08,0x08,0x10,
+    0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,
+    0x00,0x00,0x02,0x04,0x08,0x10,0x20,0x00,
+    0x00,0x1c,0x22,0x26,0x2a,0x32,0x22,0x1c,
+    0x00,0x08,0x18,0x08,0x08,0x08,0x08,0x1c,
+    0x00,0x1c,0x22,0x02,0x0c,0x10,0x20,0x3e,
+    0x00,0x3e,0x02,0x04,0x0c,0x02,0x22,0x1c,
+    0x00,0x04,0x0c,0x14,0x24,0x3e,0x04,0x04,
+    0x00,0x3e,0x20,0x3c,0x02,0x02,0x22,0x1c,
+    0x00,0x0e,0x10,0x20,0x3c,0x22,0x22,0x1c,
+    0x00,0x3e,0x02,0x04,0x08,0x10,0x10,0x10,
+    0x00,0x1c,0x22,0x22,0x1c,0x22,0x22,0x1c,
+    0x00,0x1c,0x22,0x22,0x1e,0x02,0x04,0x38,
+    0x00,0x00,0x00,0x08,0x00,0x08,0x00,0x00,
+    0x00,0x00,0x00,0x08,0x00,0x08,0x08,0x10,
+    0x00,0x04,0x08,0x10,0x20,0x10,0x08,0x04,
+    0x00,0x00,0x00,0x3e,0x00,0x3e,0x00,0x00,
+    0x00,0x10,0x08,0x04,0x02,0x04,0x08,0x10,
+    0x00,0x1c,0x22,0x04,0x08,0x08,0x00,0x08,
+    0x80,0x9c,0xa2,0xaa,0xae,0xac,0xa0,0x9e,
+    0x80,0x88,0x94,0xa2,0xa2,0xbe,0xa2,0xa2,
+    0x80,0xbc,0xa2,0xa2,0xbc,0xa2,0xa2,0xbc,
+    0x80,0x9c,0xa2,0xa0,0xa0,0xa0,0xa2,0x9c,
+    0x80,0xbc,0xa2,0xa2,0xa2,0xa2,0xa2,0xbc,
+    0x80,0xbe,0xa0,0xa0,0xbc,0xa0,0xa0,0xbe,
+    0x80,0xbe,0xa0,0xa0,0xbc,0xa0,0xa0,0xa0,
+    0x80,0x9e,0xa0,0xa0,0xa0,0xa6,0xa2,0x9e,
+    0x80,0xa2,0xa2,0xa2,0xbe,0xa2,0xa2,0xa2,
+    0x80,0x9c,0x88,0x88,0x88,0x88,0x88,0x9c,
+    0x80,0x82,0x82,0x82,0x82,0x82,0xa2,0x9c,
+    0x80,0xa2,0xa4,0xa8,0xb0,0xa8,0xa4,0xa2,
+    0x80,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xbe,
+    0x80,0xa2,0xb6,0xaa,0xaa,0xa2,0xa2,0xa2,
+    0x80,0xa2,0xa2,0xb2,0xaa,0xa6,0xa2,0xa2,
+    0x80,0x9c,0xa2,0xa2,0xa2,0xa2,0xa2,0x9c,
+    0x80,0xbc,0xa2,0xa2,0xbc,0xa0,0xa0,0xa0,
+    0x80,0x9c,0xa2,0xa2,0xa2,0xaa,0xa4,0x9a,
+    0x80,0xbc,0xa2,0xa2,0xbc,0xa8,0xa4,0xa2,
+    0x80,0x9c,0xa2,0xa0,0x9c,0x82,0xa2,0x9c,
+    0x80,0xbe,0x88,0x88,0x88,0x88,0x88,0x88,
+    0x80,0xa2,0xa2,0xa2,0xa2,0xa2,0xa2,0x9c,
+    0x80,0xa2,0xa2,0xa2,0xa2,0xa2,0x94,0x88,
+    0x80,0xa2,0xa2,0xa2,0xaa,0xaa,0xb6,0xa2,
+    0x80,0xa2,0xa2,0x94,0x88,0x94,0xa2,0xa2,
+    0x80,0xa2,0xa2,0x94,0x88,0x88,0x88,0x88,
+    0x80,0xbe,0x82,0x84,0x88,0x90,0xa0,0xbe,
+    0x80,0xbe,0xb0,0xb0,0xb0,0xb0,0xb0,0xbe,
+    0x80,0x80,0xa0,0x90,0x88,0x84,0x82,0x80,
+    0x80,0xbe,0x86,0x86,0x86,0x86,0x86,0xbe,
+    0x80,0x80,0x80,0x88,0x94,0xa2,0x80,0x80,
+    0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xbe,
+    0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+    0x80,0x88,0x88,0x88,0x88,0x88,0x80,0x88,
+    0x80,0x94,0x94,0x94,0x80,0x80,0x80,0x80,
+    0x80,0x94,0x94,0xbe,0x94,0xbe,0x94,0x94,
+    0x80,0x88,0x9e,0xa8,0x9c,0x8a,0xbc,0x88,
+    0x80,0xb0,0xb2,0x84,0x88,0x90,0xa6,0x86,
+    0x80,0x90,0xa8,0xa8,0x90,0xaa,0xa4,0x9a,
+    0x80,0x88,0x88,0x88,0x80,0x80,0x80,0x80,
+    0x80,0x88,0x90,0xa0,0xa0,0xa0,0x90,0x88,
+    0x80,0x88,0x84,0x82,0x82,0x82,0x84,0x88,
+    0x80,0x88,0xaa,0x9c,0x88,0x9c,0xaa,0x88,
+    0x80,0x80,0x88,0x88,0xbe,0x88,0x88,0x80,
+    0x80,0x80,0x80,0x80,0x80,0x88,0x88,0x90,
+    0x80,0x80,0x80,0x80,0xbe,0x80,0x80,0x80,
+    0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x88,
+    0x80,0x80,0x82,0x84,0x88,0x90,0xa0,0x80,
+    0x80,0x9c,0xa2,0xa6,0xaa,0xb2,0xa2,0x9c,
+    0x80,0x88,0x98,0x88,0x88,0x88,0x88,0x9c,
+    0x80,0x9c,0xa2,0x82,0x8c,0x90,0xa0,0xbe,
+    0x80,0xbe,0x82,0x84,0x8c,0x82,0xa2,0x9c,
+    0x80,0x84,0x8c,0x94,0xa4,0xbe,0x84,0x84,
+    0x80,0xbe,0xa0,0xbc,0x82,0x82,0xa2,0x9c,
+    0x80,0x8e,0x90,0xa0,0xbc,0xa2,0xa2,0x9c,
+    0x80,0xbe,0x82,0x84,0x88,0x90,0x90,0x90,
+    0x80,0x9c,0xa2,0xa2,0x9c,0xa2,0xa2,0x9c,
+    0x80,0x9c,0xa2,0xa2,0x9e,0x82,0x84,0xb8,
+    0x80,0x80,0x80,0x88,0x80,0x88,0x80,0x80,
+    0x80,0x80,0x80,0x88,0x80,0x88,0x88,0x90,
+    0x80,0x84,0x88,0x90,0xa0,0x90,0x88,0x84,
+    0x80,0x80,0x80,0xbe,0x80,0xbe,0x80,0x80,
+    0x80,0x90,0x88,0x84,0x82,0x84,0x88,0x90,
+    0x80,0x9c,0xa2,0x84,0x88,0x88,0x80,0x88
+];
+
+// public domain ROM
+const APPLEIIGO_LZG = [
+  76,90,71,0,0,48,0,0,0,10,174,5,108,198,141,1,25,52,55,59,65,80,80,76,69,73,73,71,79,32,82,79,
+  77,49,46,49,255,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,3,133,109,132,110,56,165,150,229,155,133,94,
+  168,165,151,229,156,170,232,152,240,35,165,150,56,229,94,133,150,176,3,198,151,56,165,148,55,3,148,176,8,198,149,144,
+  4,177,150,145,148,136,208,249,59,194,198,151,198,149,202,208,242,96,52,30,128,59,27,255,255,32,0,224,52,30,67,59,
+  30,59,28,52,31,174,59,31,59,30,59,28,59,4,52,63,105,59,31,59,30,59,28,59,2,52,63,103,59,15,52,31,
+  137,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,26,160,32,59,28,32,
+  32,160,0,59,5,52,6,40,1,16,16,12,5,19,15,6,20,32,14,15,20,32,1,22,1,9,12,1,2,12,5,52,
+  16,40,198,207,210,160,205,207,210,197,160,201,206,55,3,205,193,212,201,207,206,160,208,204,197,193,211,197,160,195,204,201,
+  195,203,160,55,8,160,52,8,40,212,200,197,160,193,208,55,25,201,201,199,207,160,204,207,59,129,194,197,204,207,215,55,
+  28,59,10,52,6,40,59,29,59,14,76,3,224,32,88,252,162,39,189,0,223,157,128,4,202,16,247,55,3,48,223,157,
+  0,5,55,195,55,78,52,5,3,96,55,3,6,55,195,144,55,25,7,55,3,76,64,224,59,65,0,32,190,224,76,74,
+  224,104,24,105,1,133,244,104,105,0,133,245,165,226,72,165,225,72,165,227,133,225,165,228,133,226,160,0,169,225,133,250,
+  76,243,0,104,133,230,104,133,231,160,2,177,230,133,245,136,59,129,244,136,52,12,33,52,28,31,55,159,226,133,250,120,
+  141,3,192,55,35,160,16,185,127,225,153,238,0,136,208,247,132,227,132,225,169,191,133,55,24,162,16,96,234,59,28,59,
+  4,115,228,128,226,145,226,182,226,90,227,100,227,118,227,127,227,74,227,138,227,153,227,169,227,185,227,201,227,235,227,162,
+  226,24,228,63,228,41,228,142,228,102,229,125,59,161,164,228,239,0,83,228,95,228,105,228,96,232,109,232,66,232,81,232,
+  151,231,173,231,211,231,243,231,195,231,227,231,23,232,3,232,30,232,122,232,139,232,235,232,60,233,110,233,133,233,240,0,
+  248,228,15,229,124,229,148,229,234,229,12,230,228,230,247,230,132,230,155,230,183,230,203,230,15,231,47,231,84,231,115,231,
+  232,200,240,8,185,255,255,133,249,108,0,225,230,245,208,244,52,28,171,59,30,59,3,52,28,248,52,9,248,193,52,28,
+  248,122,232,183,232,14,233,60,233,106,233,129,233,240,0,41,229,70,229,173,229,203,229,49,230,89,52,19,248,181,192,24,
+  117,193,149,193,181,208,117,209,149,209,232,76,240,0,181,193,56,245,192,55,9,209,245,208,52,5,9,192,10,54,208,52,
+  13,29,132,229,160,16,181,193,73,255,133,230,181,209,59,161,231,169,0,149,193,70,231,102,230,176,12,149,209,181,192,52,
+  6,36,22,192,54,208,136,208,231,55,43,164,229,55,45,169,0,52,2,82,192,169,0,245,208,149,208,96,55,59,17,169,
+  0,133,230,133,231,181,208,41,128,133,224,16,5,32,235,226,230,224,181,209,16,9,232,55,2,202,230,224,208,4,21,193,
+  240,37,22,193,54,209,136,144,249,38,230,38,231,165,230,213,192,165,231,245,208,144,9,133,55,4,245,192,133,230,56,54,
+  55,86,208,226,232,164,229,96,52,11,87,76,240,0,32,249,226,70,224,176,233,55,194,165,230,149,55,51,149,208,165,224,
+  48,215,55,10,246,192,208,2,246,55,93,181,55,1,214,208,214,192,55,3,169,255,85,55,119,255,85,55,247,181,193,53,
+  52,3,255,53,52,6,255,193,21,55,136,21,52,7,8,55,39,55,8,55,39,52,37,11,181,192,201,8,144,10,180,193,
+  148,209,160,0,148,193,233,8,168,240,7,52,3,181,208,249,52,4,248,52,5,26,16,180,209,148,193,192,128,160,0,144,
+  1,136,148,209,56,55,96,12,181,209,201,128,106,118,193,136,208,248,52,38,37,181,192,21,208,240,2,169,255,73,255,149,
+  192,52,5,136,21,209,55,33,52,5,15,149,193,52,38,149,21,208,21,55,82,6,52,8,12,202,181,193,149,192,181,209,
+  55,238,192,72,181,208,72,55,142,104,149,208,104,149,52,2,225,202,169,0,52,5,76,202,200,208,2,230,245,177,244,52,
+  34,46,52,13,9,52,6,1,52,8,14,152,24,101,244,133,55,163,168,101,245,133,245,149,208,177,244,168,52,13,21,52,
+  5,19,55,17,73,255,24,101,227,133,227,55,38,255,101,228,133,228,55,101,145,227,136,192,255,208,247,200,55,239,181,192,
+  133,230,181,208,133,231,132,229,160,0,177,230,149,192,148,208,52,5,239,52,12,15,200,59,129,52,14,18,141,2,192,52,
+  8,44,52,130,128,52,19,21,52,5,50,55,216,52,5,198,202,24,101,225,52,2,185,101,226,52,3,208,52,5,14,132,
+  229,168,202,177,55,144,52,5,99,52,13,16,200,59,129,52,15,17,141,2,192,52,6,44,141,3,192,52,21,22,55,178,
+  52,13,23,133,230,52,6,1,52,5,221,202,52,7,245,52,25,26,52,40,0,52,18,29,52,5,237,52,3,66,52,26,
+  103,52,8,32,52,3,72,52,6,35,181,193,52,98,192,133,231,181,192,52,2,104,145,230,232,52,69,123,52,5,15,55,
+  77,181,192,145,230,200,181,208,52,7,20,52,8,228,55,18,225,52,18,12,55,102,52,19,17,52,22,36,52,21,174,52,
+  7,141,52,57,27,52,8,150,52,27,29,145,230,52,28,60,55,220,181,192,213,193,208,28,181,208,213,209,208,22,169,255,
+  232,52,102,124,55,78,240,55,142,234,169,0,52,7,14,193,213,192,52,162,39,80,2,73,128,16,210,48,230,55,94,181,
+  208,245,209,55,72,48,194,16,214,52,10,8,16,178,48,198,52,10,40,48,162,16,182,232,181,207,21,191,208,20,52,3,
+  134,59,131,76,240,0,55,204,236,165,245,133,231,165,244,55,141,24,113,244,133,230,165,231,55,132,55,3,245,165,52,226,
+  145,136,55,163,191,213,192,208,193,181,207,213,208,240,207,208,185,55,199,198,55,135,172,208,190,55,135,181,207,245,208,48,
+  179,16,157,232,181,192,213,191,181,208,245,207,48,166,16,144,165,244,24,117,192,133,244,165,245,117,208,133,245,52,130,26,
+  52,48,16,165,245,72,165,244,72,152,72,32,57,233,104,168,104,133,244,104,133,245,25,3,0,28,52,26,36,141,2,192,
+  88,55,40,120,141,3,192,52,7,44,226,55,172,52,102,157,232,52,24,79,52,15,27,52,24,70,108,230,0,200,177,244,
+  72,73,255,56,52,130,97,133,225,52,132,97,133,226,55,13,10,168,240,13,181,208,136,145,225,181,192,232,59,161,208,243,
+  160,2,55,41,52,2,67,104,24,101,225,133,227,52,98,249,133,228,104,133,225,104,133,226,96,55,79,165,55,13,165,52,
+  8,11,25,30,1,212,59,31,59,31,59,31,59,30,0,201,206,176,238,201,201,144,234,201,204,240,230,208,232,25,12,1,
+  185,72,74,41,3,9,4,133,41,104,41,24,144,2,105,127,133,40,10,10,5,40,133,40,52,94,61,0,0,165,37,32,
+  193,251,101,32,52,29,75,59,21,165,34,72,32,36,252,165,40,133,42,165,41,133,43,164,33,136,104,105,1,197,35,176,
+  13,55,78,177,40,145,42,136,16,249,48,225,160,0,32,158,252,176,134,164,36,169,160,145,40,200,196,33,144,249,52,30,
+  199,59,27,164,36,177,40,72,41,63,9,64,145,40,104,108,56,52,19,27,32,12,253,32,165,251,59,161,201,155,240,243,
+  52,28,141,59,6,32,142,253,165,51,32,237,253,162,1,138,240,243,202,32,53,253,201,149,208,2,177,40,201,224,144,2,
+  41,223,157,0,2,201,141,208,178,32,156,252,169,141,208,91,164,61,166,60,55,39,32,64,249,160,0,169,173,76,237,253,
+  52,28,87,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,31,59,28,59,7,169,
+  0,133,28,165,230,133,27,160,0,132,26,165,28,145,26,32,126,244,200,208,246,230,27,165,27,41,31,208,238,96,133,226,
+  134,224,132,225,72,41,192,133,38,74,74,5,38,133,38,104,133,39,10,10,10,38,39,59,66,102,38,165,39,41,31,5,
+  230,133,39,138,192,0,240,5,160,35,105,4,200,233,7,176,251,132,229,170,189,185,244,133,48,152,74,165,228,133,28,176,
+  25,28,0,35,59,4,10,201,192,16,6,165,28,73,127,133,28,52,254,218,59,31,59,31,59,31,59,31,59,31,59,31,
+  59,28,59,10,74,8,32,71,248,40,169,15,144,2,105,224,133,46,177,38,69,48,37,46,81,38,145,38,96,32,0,248,
+  196,44,176,17,200,32,14,248,144,246,105,1,72,55,8,104,197,45,144,245,96,160,47,208,2,160,39,132,45,160,39,169,
+  0,133,48,32,40,248,136,16,246,96,25,5,4,126,39,25,6,4,126,38,10,10,52,130,52,96,165,48,24,105,3,41,
+  15,133,48,10,59,1,5,48,133,48,52,103,223,144,4,74,59,1,41,15,52,107,240,168,74,144,9,106,176,16,201,162,
+  240,12,41,135,74,170,189,98,249,32,121,248,208,4,160,128,169,0,170,189,166,249,133,46,41,3,133,47,152,41,143,170,
+  152,160,3,224,138,240,11,74,144,8,74,74,9,32,136,208,250,200,136,208,242,52,159,59,59,31,59,31,59,20,216,32,
+  132,254,32,47,251,32,147,254,32,137,254,173,88,192,173,90,192,173,93,192,173,95,192,173,255,207,44,16,192,216,32,58,
+  255,32,96,251,169,0,133,0,169,198,133,1,108,52,30,111,59,29,25,3,19,108,221,219,199,207,52,10,13,173,112,192,
+  160,0,234,234,189,100,192,16,4,200,208,248,136,96,169,0,133,72,173,86,192,173,84,192,173,81,192,169,0,240,11,173,
+  80,192,173,83,192,32,54,248,169,20,133,34,55,22,32,169,40,133,33,169,24,133,35,169,23,133,37,76,34,252,32,88,
+  252,160,9,185,8,251,153,14,4,136,208,247,96,173,243,3,73,165,141,244,3,96,201,141,208,24,172,0,192,16,19,192,
+  147,208,15,44,16,192,55,68,251,192,131,240,3,55,4,76,253,251,52,12,148,25,29,7,248,40,133,40,96,201,135,208,
+  18,169,64,32,168,252,160,192,169,12,59,193,173,48,192,136,208,245,96,164,36,145,40,230,36,165,36,197,33,176,102,96,
+  201,160,176,239,168,16,236,201,141,240,90,201,138,59,97,136,208,201,198,36,16,232,165,33,133,36,198,36,165,34,197,37,
+  176,11,198,37,25,28,7,248,0,72,32,36,252,32,158,252,160,0,104,105,0,197,35,144,240,176,202,165,34,133,37,160,
+  0,132,36,240,228,169,0,133,36,230,55,62,55,16,182,198,37,25,29,7,248,25,6,7,248,56,72,233,1,208,252,104,
+  59,129,246,96,230,66,208,2,230,67,165,60,197,62,165,61,229,63,230,60,55,6,61,52,125,244,59,18,25,13,7,248,
+  230,78,208,2,230,79,44,0,192,16,245,145,40,173,0,192,44,16,192,96,25,10,7,248,254,96,165,50,72,169,255,133,
+  50,189,0,2,32,237,253,104,55,129,201,136,240,29,201,152,240,10,224,248,144,3,32,58,255,232,208,19,169,220,55,21,
+  25,10,7,248,254,25,30,7,248,59,27,0,72,52,162,88,32,229,253,104,41,15,9,176,201,186,144,2,105,6,108,54,
+  0,201,160,144,2,37,50,132,53,72,32,120,251,104,164,53,52,49,47,64,52,10,5,52,11,24,177,60,145,66,32,180,
+  252,144,247,52,190,97,59,1,160,63,208,2,160,255,132,50,52,98,82,62,162,56,160,27,208,8,55,130,54,160,240,165,
+  62,41,15,240,6,9,192,160,0,240,2,169,253,148,0,149,1,96,234,234,76,0,224,52,30,115,59,29,59,13,169,135,
+  76,237,253,165,72,72,165,69,166,70,164,71,52,110,22,52,62,27,59,30,59,14,245,3,251,3,98,250,98,250
+];
+
diff --git a/src/nemu/nemu.ts b/src/nemu/nemu.ts
new file mode 100644
index 00000000..e4a843e3
--- /dev/null
+++ b/src/nemu/nemu.ts
@@ -0,0 +1,165 @@
+
+export interface SavesState<T> {
+    saveState() : T;
+    loadState(state:T) : void;
+}
+
+export interface Bus {
+    read(a:number) : number;
+    write(a:number, v:number) : void;
+    // TODO: readConst?(a:number) : number;
+}
+
+export interface ClockBased {
+    advanceClock() : void;
+}
+
+export interface InstructionBased {
+    advanceInsn() : number;
+}
+
+export interface FrameBased {
+    advanceFrame() : number;
+}
+
+export interface VideoFrameBased extends FrameBased {
+  getVideoParams() : VideoParams;
+  connectVideo(pixels:Uint32Array) : void;
+}
+
+export interface RasterFrameBased extends VideoFrameBased {
+}
+
+export interface VideoParams {
+    width : number;
+    height : number;
+    overscan? : boolean;
+    rotate? : number;
+}
+
+// TODO: frame buffer optimization (apple2, etc)
+
+export interface SampledAudioParams {
+    sampleRate : number;
+    stereo : boolean;
+}
+
+export interface SampledAudio {
+    setAudioParams(params:SampledAudioParams) : void;
+    sendAudioFrame(samples:Uint16Array) : void;
+}
+
+export interface AcceptsROM {
+    loadROM(data:Uint8Array, title?:string) : void;
+}
+
+export interface Resettable {
+    reset() : void;
+}
+
+export interface MemoryBusConnected {
+    connectMemoryBus(bus:Bus) : void;
+}
+
+export interface CPU extends MemoryBusConnected, Resettable {
+    getPC() : number;
+    getSP() : number;
+}
+
+export interface Interruptable<T> {
+    interrupt(type:T) : void;
+}
+
+// TODO
+export interface AcceptsInput {
+    setInput(key:number, code:number, flags:number) : void;
+    //loadControlState();
+    //saveControlState();
+}
+
+// TODO?
+export function noise(x : number) : number {
+  x ^= x << 13;
+  x ^= x >> 17;
+  x ^= x << 5;
+  return x;
+}
+
+/// HOOKS
+
+export interface Hook<T> {
+  //target : T;
+  unhook();
+}
+
+export class BusHook implements Hook<Bus> {
+  //target : Bus;
+  constructor(bus : Bus, profiler : ProfilerInterface) {
+    //this.target = bus;
+    var oldread = bus.read.bind(bus);
+    var oldwrite = bus.write.bind(bus);
+    bus.read = (a:number):number => {
+      profiler.logRead(a);
+      var val = oldread(a);
+      return val;
+    }
+    bus.write = (a:number,v:number) => {
+      profiler.logWrite(a);
+      oldwrite(a,v);
+    }
+    this.unhook = () => {
+      bus.read = oldread;
+      bus.write = oldwrite;
+    }
+  }
+  unhook : () => void;
+}
+
+export class CPUClockHook implements Hook<CPU&ClockBased> {
+  //target : CPU&ClockBased;
+  constructor(cpu : CPU&ClockBased, profiler : ProfilerInterface) {
+    //this.target = cpu;
+    var oldclock = cpu.advanceClock.bind(cpu);
+    cpu.advanceClock = () => {
+      profiler.logExecute(cpu.getPC());
+      return oldclock();
+    }
+    this.unhook = () => {
+      cpu.advanceClock = oldclock;
+    }
+  }
+  unhook : () => void;
+}
+
+export class CPUInsnHook implements Hook<CPU&InstructionBased> {
+  //target : CPU&InstructionBased;
+  constructor(cpu : CPU&InstructionBased, profiler : ProfilerInterface) {
+    //this.target = cpu;
+    var oldinsn = cpu.advanceInsn.bind(cpu);
+    cpu.advanceInsn = () => {
+      profiler.logExecute(cpu.getPC());
+      return oldinsn();
+    }
+    this.unhook = () => {
+      cpu.advanceInsn = oldinsn;
+    }
+  }
+  unhook : () => void;
+}
+
+/// PROFILER
+
+export interface ProfilerInterface {
+  logExecute(address:number);
+  logRead(address:number);
+  logWrite(address:number);
+  logIORead(address:number);
+  logIOWrite(address:number);
+  logInterrupt(type:number);
+}
+
+/// DEBUGGING
+
+class EmuBreakpoint extends Error {
+}
+
diff --git a/src/platform/apple2.ts b/src/platform/apple2.ts
index 0ad8c189..d75951dd 100644
--- a/src/platform/apple2.ts
+++ b/src/platform/apple2.ts
@@ -1065,5 +1065,64 @@ class Apple2MAMEPlatform extends BaseMAMEPlatform implements Platform {
   }
 }
 
+///
+
+// TODO: move to own place, debugging
+import { CPU, Bus, ClockBased, SavesState, Interruptable } from "../nemu/nemu";
+import { MOS6502 } from "../nemu/cpu/MOS6502";
+import { AppleII } from "../nemu/machine/apple2";
+
+class NewApple2Platform extends Base6502Platform implements Platform {
+
+  mainElement : HTMLElement;
+  machine : AppleII;
+  timer : AnimationTimer;
+  video : RasterVideo;
+
+  constructor(mainElement : HTMLElement) {
+    super();
+    this.mainElement = mainElement;
+  }
+  getOpcodeMetadata = getOpcodeMetadata_6502;
+  getDefaultExtension () { return ".c"; };
+  getToolForFilename = getToolForFilename_6502;
+  getPresets () { return APPLE2_PRESETS; }
+  getCPUState() { return this.machine.cpu.saveState(); }
+  saveState() { return this.machine.saveState(); }
+  loadState(s) { this.machine.loadState(s); }
+  readAddress(a) { return this.machine.read(a); }
+
+  start() {
+    this.machine = new AppleII();
+    this.timer = new AnimationTimer(60, this.nextFrame.bind(this));
+    var vp = this.machine.getVideoParams();
+    this.video = new RasterVideo(this.mainElement, vp.width, vp.height);
+    //this.audio = new SampleAudio(cpuFrequency);
+    this.video.create();
+    this.machine.connectVideo(this.video.getFrameData());
+  }
+  reset() {
+    this.machine.reset();
+  }
+  loadROM(title, data) {
+    this.machine.loadROM(data);
+    this.reset();
+  }
+  advance(novideo:boolean) {
+    this.machine.advanceFrame();
+    if (!novideo) this.video.updateFrame();
+  }
+  isRunning() {
+    return this.timer.isRunning();
+  }
+  resume() {
+    this.timer.start();
+  }
+  pause() {
+    this.timer.stop();
+  }
+}
+
 PLATFORMS['apple2'] = _Apple2Platform;
-PLATFORMS['apple2-e'] = Apple2MAMEPlatform;
+PLATFORMS['apple2.mame'] = Apple2MAMEPlatform;
+PLATFORMS['apple2.new'] = NewApple2Platform;
diff --git a/test/cli/6502/6502_functional_test.bin b/test/cli/6502/6502_functional_test.bin
new file mode 100644
index 0000000000000000000000000000000000000000..c9a35e1d6bd2e7d85844da2abf7034d5ed820e6e
GIT binary patch
literal 65536
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
E3ya{&@Bjb+

literal 0
HcmV?d00001

diff --git a/test/cli/6502/test6502sim.js b/test/cli/6502/test6502sim.js
new file mode 100644
index 00000000..35d32638
--- /dev/null
+++ b/test/cli/6502/test6502sim.js
@@ -0,0 +1,68 @@
+
+var assert = require('assert');
+var fs = require('fs');
+
+var emu = require("gen/nemu/nemu.js");
+var MOS6502 = require("gen/nemu/cpu/MOS6502.js");
+var testbin = fs.readFileSync('test/cli/6502/6502_functional_test.bin', null);
+
+describe('MOS6502', function() {
+  it('Should pass functional tests', function() {
+    assert.equal(65536, testbin.length);
+    var mem = new Uint8Array(testbin);
+    var bus = {
+      read:  (a)   => { return mem[a]; },
+      write: (a,v) => { mem[a] = v; }
+    };
+    var cpu = new MOS6502.MOS6502();
+    cpu.connectMemoryBus(bus);
+    cpu.reset();
+    var s0 = cpu.saveState();
+    s0.PC = 0x400;
+    cpu.loadState(s0);
+    for (var i=0; i<100000000; i++) {
+      cpu.advanceClock();
+      var pc = cpu.getPC();
+      if (pc == 0x3469) break; // success!
+    }
+    console.log(i+' cycles, PC = $'+pc.toString(16));
+    assert.equal(pc, 0x3469);
+    // NMI trap
+    cpu.interrupt(1);
+    for (var i=0; i<20; i++) {
+      cpu.advanceClock();
+      var pc = cpu.getPC();
+      if (pc == 0x379e) break;
+    }
+    assert.equal(pc, 0x379e);
+    // hooks
+    mem.set(testbin);
+    cpu.loadState(s0);
+    var pcs = [];
+    var profiler = {
+      logExecute: function(a) { pcs.push(a); },
+      logRead:    function(a) { pcs.push(a); },
+      logWrite:   function(a) { pcs.push(a); },
+    };
+    // test hooks
+    var chook = new emu.CPUClockHook(cpu, profiler);
+    for (var i=0; i<10000; i++) {
+      cpu.advanceClock();
+    }
+    chook.unhook();
+    for (var i=0; i<100000; i++) {
+      cpu.advanceClock();
+    }
+    console.log(pcs.slice(pcs.length-10));
+    assert.equal(10000, pcs.length);
+    // bus hook
+    var bhook = new emu.BusHook(bus, profiler);
+    for (var i=0; i<10000; i++) {
+      cpu.advanceClock();
+    }
+    bhook.unhook();
+    console.log(pcs.slice(pcs.length-10));
+    assert.equal(20000, pcs.length);
+  });
+});
+