diff --git a/host/scripts/nes/studybox.lua b/host/scripts/nes/studybox.lua
new file mode 100644
index 0000000..6c14666
--- /dev/null
+++ b/host/scripts/nes/studybox.lua
@@ -0,0 +1,720 @@
+math.randomseed(os.time())
+
+-- create the module's table
+local studybox = {}
+
+-- import required modules
+local nes = require "scripts.app.nes"
+local dict = require "scripts.app.dict"
+local dump = require "scripts.app.dump"
+local flash = require "scripts.app.flash"
+local buffers = require "scripts.app.buffers"
+
+-- file constants
+local mapname = "SBX"
+
+-- local functions
+
+local function create_header( file, prgKB, chrKB )
+
+	--write_header( file, prgKB, chrKB, mapper, mirroring )
+	nes.write_header( file, prgKB, 0, op_buffer[mapname], 0)
+end
+
+
+--local function wr_flash_byte(addr, value, debug)
+
+--base is the actual NES CPU address, not the rom offset (ie $FFF0, not $7FF0)
+--local function wr_bank_table(base, entries)
+--Action53 not susceptible to bus conflicts, no banktable needed
+
+local function sb_write_string(start_addr, value, log)
+    value = string.format("'%s' starting at $%04X", value, start_addr)
+    print(string.format("Writing %s starting at address $%04X\n", value, start_addr))
+    for i = 1, #value do
+        local c = value:sub(i,i)
+        dict.nes("NES_CPU_WR", start_addr + (i - 1), string.byte(c))
+    end
+end
+
+local function sb_write_and_verify(start_addr, stop_addr, value, log)
+    log:write(string.format("Writing $%X from address $%X to $%X\n", value, start_addr, stop_addr))
+    addr = start_addr
+    while (addr < stop_addr) do
+        dict.nes("NES_CPU_WR", addr, value)
+        addr = addr + 1
+    end
+
+    log:write("Verifying data\n")
+    addr = start_addr
+    while(addr < stop_addr) do
+        rv = dict.nes("NES_CPU_RD", addr)
+        if rv ~= value then
+            log:write(string.format("$%X not $%X\n", addr, value))
+        end
+        addr = addr + 1
+    end
+end
+
+-- Write and verify random values in RAM
+local function sb_random_ram(start_addr, stop_addr, log)
+    log:write(string.format("\nStarting random ram test from address $%04X to address $%04X\n", start_addr, stop_addr))
+    values = {}
+    for i = 0, (stop_addr - start_addr) do
+        val = math.random(0, 255)
+        values[i] = val
+        dict.nes("NES_CPU_WR", start_addr + i, val)
+    end
+
+    for i = 0, (stop_addr - start_addr) do
+        rv = dict.nes("NES_CPU_RD", start_addr + i)
+        if rv ~= values[i] then
+            log:write(string.format("$%04X: expected $%02X received $%02X\n", start_addr + i, values[i], rv))
+        end
+    end
+end
+
+local function sb_write_ram(start_addr, stop_addr, value)
+    print(string.format("Writing $%02X from $%04X to $%04X", value, start_addr, stop_addr))
+    while (start_addr < stop_addr) do
+        dict.nes("NES_CPU_WR", start_addr, value)
+        start_addr = start_addr + 1
+    end
+end
+
+local function sb_verify_value_ram(start_addr, stop_addr, value, log)
+    print(string.format("Verifying $%02X from $%04X to $%04X", value, start_addr, stop_addr))
+    while (start_addr < stop_addr) do
+        rv = dict.nes("NES_CPU_RD", start_addr)
+        if rv ~= value then
+            log:write(string.format("$%04X: expected $%02X received $%02X\n", start_addr, value, rv))
+        end
+        start_addr = start_addr + 1
+    end
+end
+
+local function sb_ram_dump(start_addr, stop_addr, filename)
+    file = io.open(filename, "wb")
+    while (start_addr < stop_addr) do
+        rv = dict.nes("NES_CPU_RD", start_addr)
+        file:write(string.char(rv))
+        start_addr = start_addr + 1
+    end
+
+    file:flush()
+    file:close()
+end
+
+-- Write data to ram and read it back
+local function sb_verify_ram()
+    logfile = io.open("studybox.log", "w")
+    print("Starting sb_verify_ram()")
+
+    --print("Write/Verify $00")
+    --sb_write_and_verify(0x4020, 0x8000, 0x00, logfile)
+    --print("Write/Verify $88")
+    --sb_write_and_verify(0x4020, 0x8000, 0x88, logfile)
+    --print("Write/Verify $FF")
+    --sb_write_and_verify(0x4020, 0x8000, 0xFF, logfile)
+
+    --print("Write/Verify random")
+    --sb_random_ram(0x4020, 0x8000, logfile)
+
+    -- Select first bank
+    --sprint("\n$4200 value of $00")
+    --dict.nes("NES_CPU_WR", 0x4200, 0x00)
+    --val = math.random(0, 255)
+    --sb_write_ram(0x5000, 0x5FFF, val)
+    --sb_verify_value_ram(0x4400, 0x8000, val, logfile)
+
+    --sprint("\n$4200 value of $01")
+    --sdict.nes("NES_CPU_WR", 0x4200, 0x01)
+    --sval = math.random(0, 255)
+    --ssb_write_ram(0x5000, 0x5FFF, val)
+    --ssb_verify_value_ram(0x4400, 0x8000, val, logfile)
+
+    --sprint("\n$4200 value of $00 verify")
+    --sdict.nes("NES_CPU_WR", 0x4200, 0x00)
+    --ssb_verify_value_ram(0x4400, 0x5FFF, val, logfile)
+
+    --print("\n$4200 value of $00")
+    --dict.nes("NES_CPU_WR", 0x4200, 0x00)
+    --val = math.random(0, 255)
+    --sb_write_ram(0x6000, 0x8000, val)
+    --sb_verify_value_ram(0x6000, 0x8000, val, logfile)
+
+    --logfile:write("\n==== Second verify with $4200 value $40 ====\n")
+
+    --print("\n$4200 value of $40")
+    --dict.nes("NES_CPU_WR", 0x4200, 0x40)
+    --sb_verify_value_ram(0x6000, 0x8000, val, logfile)
+
+    print("Clearing ram")
+    sb_write_ram(0x4400, 0x8000, 0x00)
+
+    --41 b01000001
+    --82 b10000010
+    --82 b11000011
+    dict.nes("NES_CPU_WR", 0x4200, 0x41)
+    sb_write_ram(0x4400, 0x8000, 0x00)
+    dict.nes("NES_CPU_WR", 0x4200, 0x82)
+    sb_write_ram(0x4400, 0x8000, 0x00)
+    dict.nes("NES_CPU_WR", 0x4200, 0xC3)
+    sb_write_ram(0x4400, 0x8000, 0x00)
+
+
+    print("Writing strings")
+    dict.nes("NES_CPU_WR", 0x4200, 0x00)
+    sb_write_string(0x5400, "|< page $00 >|")
+    sb_write_string(0x6000, "|< page $00 >|")
+
+    dict.nes("NES_CPU_WR", 0x4200, 0x41)
+    sb_write_string(0x5000, "|< page $01 >|")
+    sb_write_string(0x6000, "|< page $01 >|")
+
+    dict.nes("NES_CPU_WR", 0x4200, 0x82)
+    sb_write_string(0x5000, "|< page $02 >|")
+    sb_write_string(0x6000, "|< page $02 >|")
+
+    dict.nes("NES_CPU_WR", 0x4200, 0xC3)
+    sb_write_string(0x5000, "|< page $03 >|")
+    sb_write_string(0x6000, "|< page $03 >|")
+
+    --sb_write_string(0x5000, "|< page $00 at $5000 >|")
+
+    print("dumping 4200_00.dmp")
+    dict.nes("NES_CPU_WR", 0x4200, 0x00)
+    sb_ram_dump(0x4400, 0x8000, "4200_00.dmp")
+
+    print("dumping 4200_01.dmp")
+    dict.nes("NES_CPU_WR", 0x4200, 0x01)
+    sb_ram_dump(0x4400, 0x8000, "4200_01.dmp")
+
+    print("dumping 4200_01.dmp")
+    dict.nes("NES_CPU_WR", 0x4200, 0x01)
+    sb_ram_dump(0x4400, 0x8000, "4200_01.dmp")
+
+    --print("\n$4200 value of $01")
+    --dict.nes("NES_CPU_WR", 0x4200, 0x01)
+    --sb_ram_dump(0x4400, 0x8000, "4200_01.dmp")
+
+    --print("\n$4200 value of $02")
+    --dict.nes("NES_CPU_WR", 0x4200, 0x02)
+    --sb_ram_dump(0x4400, 0x8000, "4200_02.dmp")
+
+    --print("\n$4200 value of $03")
+    --dict.nes("NES_CPU_WR", 0x4200, 0x03)
+    --sb_ram_dump(0x4400, 0x8000, "4200_03.dmp")
+
+    --print("\n$4200 value of $40")
+    --dict.nes("NES_CPU_WR", 0x4200, 0x40)
+    --sb_ram_dump(0x4400, 0x8000, "4200_40.dmp")
+
+    --print("\n$4200 value of $80")
+    --dict.nes("NES_CPU_WR", 0x4200, 0x80)
+    --sb_ram_dump(0x4400, 0x8000, "4200_80.dmp")
+
+    --print("\n$4200 value of $C0")
+    --dict.nes("NES_CPU_WR", 0x4200, 0x80)
+    --sb_ram_dump(0x4400, 0x8000, "4200_C0.dmp")
+
+    logfile:flush()
+    logfile:close()
+end
+
+--initialize mapper for dump/flash routines
+local function init_mapper( debug )
+	
+	--//Setup as CNROM, then scroll through outer banks.
+	--cpu_wr(0x5000, 0x80);   //reg select mode
+	--dict.nes("NES_CPU_WR", 0x5000, 0x80)
+
+	--//   xxSSPPMM   SS-size: 0-32KB, PP-prg mode: 0,1 32KB, MM-mirror
+	--cpu_wr(0x8000, 0b00000000);     //reg value 256KB inner, 32KB banks
+	--dict.nes("NES_CPU_WR", 0x8000, 0x00)
+	--cpu_wr(0x5000, 0x81);   //outer reg select mode
+	--dict.nes("NES_CPU_WR", 0x5000, 0x81)
+	--cpu_wr(0x8000, 0x00);   //first 32KB bank
+	--dict.nes("NES_CPU_WR", 0x8000, 0x00)
+	--
+	--cpu_wr(0x5000, 0x01);   //inner prg reg select
+	--dict.nes("NES_CPU_WR", 0x5000, 0x01)
+	--cpu_wr(0x8000, 0x00);   //controls nothing in this size
+	--dict.nes("NES_CPU_WR", 0x8000, 0x00)
+	--cpu_wr(0x5000, 0x00);   //chr reg select
+	--dict.nes("NES_CPU_WR", 0x5000, 0x00)
+	--cpu_wr(0x8000, 0x00);   //first chr bank
+	--dict.nes("NES_CPU_WR", 0x8000, 0x00)
+	--selecting CNROM means that mapper writes to $8000-FFFF will only change the CHR-RAM bank which
+	--doesn't affect anything we're concerned about
+
+end
+
+local function sb_dump_rom()
+
+    file = io.open("prg.dat", "wb")
+    for i = 0x00,0x0F,1 do
+        print(string.format("$4201: %02X", i))
+        dict.nes("NES_CPU_WR", 0x4201, i)
+        start_addr = 0x8000
+        stop_addr = 0xC000
+        while (start_addr < stop_addr) do
+            rv = dict.nes("NES_CPU_RD", start_addr)
+            file:write(string.char(rv))
+            start_addr = start_addr + 1
+        end
+        --sb_ram_dump(0x8000, 0xC000, string.format("raw/prg_8000_%02X.dat", i))
+    end
+    file:flush()
+    file:close()
+
+    --dict.nes("NES_CPU_WR", 0x4201, 0x00)
+    --sb_ram_dump(0x8000, 0xC000, "prg_8000_00.dat")
+    --sb_ram_dump(0xC000, 0x10000, "prg_C000_00.dat")
+
+    --dict.nes("NES_CPU_WR", 0x4201, 0x01)
+    --sb_ram_dump(0x8000, 0xC000, "prg_8000_01.dat")
+    --sb_ram_dump(0xC000, 0x10000, "prg_C000_01.dat")
+
+    --dict.nes("NES_CPU_WR", 0x4201, 0x02)
+    --sb_ram_dump(0x8000, 0xC000, "prg_8000_02.dat")
+    --sb_ram_dump(0xC000, 0x10000, "prg_C000_02.dat")
+
+    --dict.nes("NES_CPU_WR", 0x4201, 0x03)
+    --sb_ram_dump(0x8000, 0xC000, "prg_8000_03.dat")
+    --sb_ram_dump(0xC000, 0x10000, "prg_C000_03.dat")
+end
+
+local function sb_write_save()
+    print("Clearing ram")
+    dict.nes("NES_CPU_WR", 0x4200, 0x00)
+    sb_write_ram(0x600, 0x8000, 0x00)
+    sb_write_string(0x5400, "|< page $00 >|")
+    sb_write_string(0x6000, "|< page $00 >|")
+end
+
+local function sb_dump_save()
+    print("Dumping ram")
+    dict.nes("NES_CPU_WR", 0x4200, 0x00)
+    sb_ram_dump(0x4400, 0x8000, "raw/ram.dat")
+end
+
+local function sb_read_registers()
+    data = dict.nes("NES_CPU_RD", 0x4202)
+    print(string.format("$4202: $%02X", data))
+end
+
+--read PRG-ROM flash ID
+local function prgrom_manf_id( debug )
+
+	init_mapper()
+
+	if debug then print("reading PRG-ROM manf ID") end
+	--A0-A14 are all directly addressable in CNROM mode
+	--and mapper writes don't affect PRG banking
+	dict.nes("NES_CPU_WR", 0xD555, 0xAA)
+	dict.nes("NES_CPU_WR", 0xAAAA, 0x55)
+	dict.nes("NES_CPU_WR", 0xD555, 0x90)
+	rv = dict.nes("NES_CPU_RD", 0x8000)
+	if debug then print("attempted read PRG-ROM manf ID:", string.format("%X", rv)) end
+	rv = dict.nes("NES_CPU_RD", 0x8001)
+	if debug then print("attempted read PRG-ROM prod ID:", string.format("%X", rv)) end
+
+	--exit software
+	dict.nes("NES_CPU_WR", 0x8000, 0xF0)
+
+end
+
+local function mirror_test( debug )
+    init_mapper()
+
+end
+
+local function bank0(bank)
+    dict.nes("NES_CPU_WR", 0x4201, bank)
+
+    print("selecting bank: ", bank)
+	--rv = dict.nes("NES_CPU_RD", 0x8000)
+	--if debug then print("attempted read PRG-ROM $8000:", string.format("%X", rv)) end
+	--rv = dict.nes("NES_CPU_RD", 0x8001)
+	--if debug then print("attempted read PRG-ROM $8001:", string.format("%X", rv)) end
+end
+
+local function sb_write_ppu_string(start_addr, value)
+    value = string.format("'%s' starting at $%04X", value, start_addr)
+    print(string.format("Writing %s starting at address $%04X\n", value, start_addr))
+    for i = 1, #value do
+        local c = value:sub(i,i)
+        dict.nes("NES_PPU_WR", start_addr + (i - 1), string.byte(c))
+    end
+end
+
+local function sb_ppu_test()
+    dict.nes("NES_CPU_WR", 0x4200, 0x00)
+    dict.nes("NES_CPU_WR", 0x4201, 0x00)
+    dict.nes("NES_CPU_WR", 0x4203, 0x00)
+    print("Clearing ppu ram")
+    for i=0x0000,0x2FFF,1 do
+		dict.nes("NES_PPU_WR", i, 0x00)
+    end
+
+    sb_write_ppu_string(0x0000, "|< chr page $00 >|")
+
+    print("Writing nametable 1")
+    for i=0x2000,0x23FF,1 do
+		dict.nes("NES_PPU_WR", i, 0x01)
+    end
+
+    print("Writing nametable 2")
+    for i=0x2400,0x27FF,1 do
+		dict.nes("NES_PPU_WR", i, 0x02)
+    end
+
+    print("Writing nametable 3")
+    for i=0x2800,0x2BFF,1 do
+		dict.nes("NES_PPU_WR", i, 0x03)
+    end
+
+    print("Writing nametable 4")
+    for i=0x2C00,0x2FFF,1 do
+		dict.nes("NES_PPU_WR", i, 0x04)
+    end
+
+    print("dumping ppu ram")
+    dict.nes("NES_CPU_WR", 0x4200, 0xFF)
+    dict.nes("NES_CPU_WR", 0x4201, 0xFF)
+    dict.nes("NES_CPU_WR", 0x4203, 0xFF)
+    file = io.open("raw/ppu.dat", "wb")
+    for i=0x0000,0x2FFF,1 do
+        val = dict.nes("NES_PPU_RD", i)
+        file:write(string.char(val))
+    end
+    file:flush()
+    file:close()
+end
+
+local function sb_ppu_high_ram_test()
+
+    print("Testing PPU RAM $3000-$3FFF")
+    file = io.open("raw/ppu_high_init.dmp", "wb")
+    for i=0x3000,0x3FFF,1 do
+        val = dict.nes("NES_PPU_RD", i)
+        file:write(string.char(val))
+    end
+    file:flush()
+    file:close()
+
+    print("writing $B1")
+    for i=0x3000,0x3FFF,1 do
+        dict.nes("NES_PPU_WR", i, 0xB1)
+    end
+
+    print("dump 2")
+    file = io.open("raw/ppu_high_post.dmp", "wb")
+    for i=0x3000,0x3FFF,1 do
+        val = dict.nes("NES_PPU_RD", i)
+        file:write(string.char(val))
+    end
+    file:flush()
+    file:close()
+
+    print("dump ppu main")
+    file = io.open("raw/ppu_main.dmp", "wb")
+    for i=0x0000,0x2FFF,1 do
+        val = dict.nes("NES_PPU_RD", i)
+        file:write(string.char(val))
+    end
+    file:flush()
+    file:close()
+
+end
+
+-- Test CPU vs PPU ram
+local function sb_ram_full_test()
+    --print("Clearing ram")
+    --sb_write_ram(0x4400, 0x8000, 0x00)
+
+    --dict.nes("NES_CPU_WR", 0x4200, 0x41)
+    --sb_write_ram(0x4400, 0x8000, 0x00)
+    --dict.nes("NES_CPU_WR", 0x4200, 0x82)
+    --sb_write_ram(0x4400, 0x8000, 0x00)
+    --dict.nes("NES_CPU_WR", 0x4200, 0xC3)
+    --sb_write_ram(0x4400, 0x8000, 0x00)
+
+    --dict.nes("NES_CPU_WR", 0x4200, 0x00)
+    --dict.nes("NES_CPU_WR", 0x4201, 0x00)
+    --dict.nes("NES_CPU_WR", 0x4203, 0x00)
+    --print("Clearing ppu ram")
+    --for i=0x0000,0x2FFF,1 do
+	--	dict.nes("NES_PPU_WR", i, 0x00)
+    --end
+
+    print("Writing values")
+    -- Only using 0x6000-0x7FFF here because it's
+    -- the same memory as the first block
+    dict.nes("NES_CPU_WR", 0x4200, 0x00)
+    sb_write_ram(0x6000, 0x7FFF, 01)
+
+    dict.nes("NES_CPU_WR", 0x4200, 0x40)
+    sb_write_ram(0x6000, 0x7FFF, 02)
+
+    dict.nes("NES_CPU_WR", 0x4200, 0x80)
+    sb_write_ram(0x6000, 0x7FFF, 03)
+
+    dict.nes("NES_CPU_WR", 0x4200, 0xC0)
+    sb_write_ram(0x6000, 0x7FFF, 04)
+
+    --print("Clearing ppu ram")
+    --for i=0x0000,0x2FFF,1 do
+	--	dict.nes("NES_PPU_WR", i, 0x00)
+    --end
+
+--    print("Writing values")
+
+    print("Writing nametable 1")
+    for i=0x2000,0x23FF,1 do
+		dict.nes("NES_PPU_WR", i, 0xA1)
+    end
+
+    print("Writing nametable 2")
+    for i=0x2400,0x27FF,1 do
+		dict.nes("NES_PPU_WR", i, 0xA2)
+    end
+
+    print("Writing nametable 3")
+    for i=0x2800,0x2BFF,1 do
+		dict.nes("NES_PPU_WR", i, 0xA3)
+    end
+
+    print("Writing nametable 4")
+    for i=0x2C00,0x2FFF,1 do
+		dict.nes("NES_PPU_WR", i, 0xA4)
+    end
+
+    print("writing CHR at 0x0000")
+    for i=0x0000,0x0FFF,1 do
+        dict.nes("NES_PPU_WR", i, 0xA5)
+    end
+    print("writing CHR at 0x1000")
+    for i=0x1000,0x1FFF,1 do
+        dict.nes("NES_PPU_WR", i, 0xA6)
+    end
+
+    print("dumping ppu ram")
+    --dict.nes("NES_CPU_WR", 0x4200, 0xFF)
+    --dict.nes("NES_CPU_WR", 0x4201, 0xFF)
+    --dict.nes("NES_CPU_WR", 0x4203, 0xFF)
+    file = io.open("raw/cpu-ppu.dmp", "wb")
+    for i=0x0000,0x2FFF,1 do
+        val = dict.nes("NES_PPU_RD", i)
+        file:write(string.char(val))
+    end
+    file:flush()
+    file:close()
+
+    print("dumping 4200_00.dmp")
+    dict.nes("NES_CPU_WR", 0x4200, 0x00)
+    sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_00.dmp")
+
+    print("dumping 4200_40.dmp")
+    dict.nes("NES_CPU_WR", 0x4200, 0x40)
+    sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_40.dmp")
+
+    print("dumping 4200_80.dmp")
+    dict.nes("NES_CPU_WR", 0x4200, 0x80)
+    sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_80.dmp")
+
+    print("dumping 4200_C0.dmp")
+    dict.nes("NES_CPU_WR", 0x4200, 0xC0)
+    sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_C0.dmp")
+end
+
+local function check_ppu_mirror(a, b)
+    vala = dict.nes("NES_PPU_RD", 0x2800)
+    valb = dict.nes("NES_PPU_RD", 0x2C00)
+    if vala ~= a then
+        print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
+    end
+    if valb ~= b then
+        print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
+    end
+end
+
+local function sb_mirror_test()
+	dict.nes("NES_PPU_WR", 0x2800, 0xA1)
+	dict.nes("NES_PPU_WR", 0x2C00, 0xA2)
+
+    print("checking $4200")
+    for i=0xC4,0xFF,4 do
+        --print(string.format("  %02X", i))
+        dict.nes("NES_CPU_WR", 0x4200, i)
+        vala = dict.nes("NES_PPU_RD", 0x2800)
+        valb = dict.nes("NES_PPU_RD", 0x2C00)
+        if vala ~= 0xA1 then
+            print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
+        end
+        if valb ~= 0xA2 then
+            print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
+        end
+    end
+
+    print("checking $4201")
+    for i=0x00,0xF0,0x10 do
+        --print(string.format("  %02X", i))
+        dict.nes("NES_CPU_WR", 0x4201, i)
+        vala = dict.nes("NES_PPU_RD", 0x2800)
+        valb = dict.nes("NES_PPU_RD", 0x2C00)
+        if vala ~= 0xA1 then
+            print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
+        end
+        if valb ~= 0xA2 then
+            print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
+        end
+    end
+
+    print("checking $4202")
+    dict.nes("NES_CPU_WR", 0x4202, 0x40)
+    check_ppu_mirror(0xA1, 0xA2)
+    dict.nes("NES_CPU_WR", 0x4202, 0x08)
+    check_ppu_mirror(0xA1, 0xA2)
+
+    print("checking $4203")
+    for i=0x00,0xFF,0x01 do
+        --print(string.format("  %02X", i))
+        dict.nes("NES_CPU_WR", 0x4203, i)
+        vala = dict.nes("NES_PPU_RD", 0x2800)
+        valb = dict.nes("NES_PPU_RD", 0x2C00)
+        if vala ~= 0xA1 then
+            print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
+        end
+        if valb ~= 0xA2 then
+            print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
+        end
+    end
+
+end
+
+--Cart should be in reset state upon calling this function 
+--this function processes all user requests for this specific board/mapper
+local function process(process_opts, console_opts)
+	local test = process_opts["test"]
+	local read = process_opts["read"]
+	local erase = process_opts["erase"]
+	local program = process_opts["program"]
+	local verify = process_opts["verify"]
+	local dumpfile = process_opts["dump_filename"]
+	local flashfile = process_opts["flash_filename"]
+	local verifyfile = process_opts["verify_filename"]
+
+	local rv = nil
+	local file 
+	local prg_size = console_opts["prg_rom_size_kb"]
+	local chr_size = console_opts["chr_rom_size_kb"]
+	local wram_size = console_opts["wram_size_kb"]
+
+--initialize device i/o for NES
+	dict.io("IO_RESET")
+	dict.io("NES_INIT")
+
+    mirror_test(true)
+
+--test cart by reading manf/prod ID
+	if test then
+		prgrom_manf_id(true)
+	end
+
+    --sb_verify_ram()
+    --sb_read_registers()
+    --sb_dump_rom()
+    --sb_write_save()
+    --sb_dump_save()
+    --sb_ppu_test()
+    --sb_ram_full_test()
+    --sb_ppu_high_ram_test()
+    sb_mirror_test()
+	dict.io("IO_RESET")
+    do return end
+
+    -- Poke some registers
+    init_mapper(debug)
+    dict.nes("NES_CPU_WR", 0x4202, 0x20)
+    --for i=0, 8, 1 do
+    --    dict.nes("NES_CPU_WR", 0x4202, 0x10)
+
+    --    rv = dict.nes("NES_CPU_RD", 0x4201)
+    --    print(i, "initial read:", string.format("$%02X", rv))
+    --    while (rv & 0x40 == 0) do
+    --        rv = dict.nes("NES_CPU_RD", 0x4201)
+    --        io.write(".")
+    --    end
+    --    print("")
+    --end
+
+--dump the cart to dumpfile
+    read = false
+	if read then
+        print("Attempting to read StudyBox stuff")
+		--initialize the mapper for dumping
+		init_mapper(debug)
+
+        rv = dict.nes("NES_CPU_RD", 0x4200)
+        print("$4200:", string.format("$%X", rv))
+        rv = dict.nes("NES_CPU_RD", 0x4201)
+        print("$4201:", string.format("$%X", rv))
+        rv = dict.nes("NES_CPU_RD", 0x4202)
+        print("$4202:", string.format("$%X", rv))
+        rv = dict.nes("NES_CPU_RD", 0x4203)
+        print("$4203:", string.format("$%X", rv))
+
+		file = assert(io.open(dumpfile, "wb"))
+
+		--create header: pass open & empty file & rom sizes
+		--create_header(file, prg_size, chr_size)
+
+        for bank=0, 16, 1 do
+            dict.nes("NES_CPU_WR", 0x4201, bank)
+
+            print("dumping bank: ", bank)
+            rv = dict.nes("NES_CPU_RD", 0x4201)
+            print("$4201:", string.format("$%X", rv))
+            --dump cart into file
+            dump.dumptofile( file, prg_size, "186", "PRGROM", true )
+        end
+
+		--close file
+		assert(file:close())
+	end
+
+
+--verify flashfile is on the cart
+    verify = false
+	if verify then
+		--for now let's just dump the file and verify manually
+
+		--initialize the mapper for dumping
+		init_mapper(debug)
+
+		file = assert(io.open(verifyfile, "wb"))
+
+		--dump cart into file
+		dump.dumptofile( file, 512, "A53", "PRGROM", true )
+
+		--close file
+		assert(file:close())
+	end
+
+	dict.io("IO_RESET")
+end
+
+
+-- global variables so other modules can use them
+
+
+-- call functions desired to run when script is called/imported
+
+
+-- functions other modules are able to call
+studybox.process = process
+
+-- return the module's table
+return studybox