diff --git a/devices/pc8080/machine/invaders/README.md b/devices/pc8080/machine/invaders/README.md
index d32fa2544..d7792bc66 100644
--- a/devices/pc8080/machine/invaders/README.md
+++ b/devices/pc8080/machine/invaders/README.md
@@ -5,7 +5,6 @@ permalink: /devices/pc8080/machine/invaders/
 machines:
   - type: pc8080
     id: invaders
-    debugger: true
 ---
 
 Space Invaders (1978)
diff --git a/devices/pc8080/machine/invaders/debugger/README.md b/devices/pc8080/machine/invaders/debugger/README.md
new file mode 100644
index 000000000..7ea9b9947
--- /dev/null
+++ b/devices/pc8080/machine/invaders/debugger/README.md
@@ -0,0 +1,27 @@
+---
+layout: page
+title: Space Invaders (1978) with Debugger
+permalink: /devices/pc8080/machine/invaders/debugger/
+machines:
+  - type: pc8080
+    id: invaders
+    debugger: true
+---
+
+Space Invaders (1978) with Debugger
+-----------------------------------
+
+The [PC8080](/modules/pc8080/) machine below is configured to run [Space Invaders](/devices/pc8080/machine/invaders/)
+with a Control Panel and Debugger.  It is currently playable only in desktop browsers and uses the following hard-coded
+key mappings:
+
+- 1: One Player
+- 2: Two Player
+- 3: Insert Coin
+- A: Move Left
+- D: Move Right
+- L: Fire Missile
+
+Click the "Run" button when you're ready to start the simulation. 
+
+{% include machine.html id="invaders" %}
diff --git a/devices/pc8080/machine/invaders/debugger/machine.xml b/devices/pc8080/machine/invaders/debugger/machine.xml
new file mode 100644
index 000000000..170279973
--- /dev/null
+++ b/devices/pc8080/machine/invaders/debugger/machine.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet type="text/xsl" href="/versions/pc8080/1.23.3/machine.xsl"?>
+<machine id="invaders" class="pc8080" border="1" pos="center" background="#FAEBD7">
+	<name pos="center">Space Invaders</name>
+	<computer id="computer" busWidth="16"/>
+	<cpu id="cpu8080" model="8080" cycles="2000000" autoStart="true"/>
+	<rom id="romH" addr="0x0000" size="0x0800" file="/devices/pc8080/rom/invaders/INVADERS-H.json"/>
+	<rom id="romG" addr="0x0800" size="0x0800" file="/devices/pc8080/rom/invaders/INVADERS-G.json"/>
+	<rom id="romF" addr="0x1000" size="0x0800" file="/devices/pc8080/rom/invaders/INVADERS-F.json"/>
+	<rom id="romE" addr="0x1800" size="0x0800" file="/devices/pc8080/rom/invaders/INVADERS-E.json"/>
+	<ram id="ram"  addr="0x2000" size="0x0400"/>
+	<video id="video" screenWidth="896" screenHeight="1024" bufferRotate="-90" smoothing="false" bufferAddr="0x2400" bufferCols="256" bufferRows="224" bufferBits="1" bufferLeft="0" interruptRate="120" width="40%" pos="left" padding="8px">
+		<menu>
+			<title>224x256 Screen (Rotated)</title>
+			<control type="container" pos="right">
+				<control type="button" binding="fullScreen" padleft="8px;line-height:1em">Full Screen</control>
+			</control>
+		</menu>
+	</video>
+	<chipset id="chipset" model="SI1978"/>
+	<keyboard id="keyboard"/>
+	<panel ref="/devices/pc8080/panel/left.xml"/>
+	<debugger id="debugger" commands="s 8086"/>
+</machine>
diff --git a/devices/pc8080/machine/invaders/machine.xml b/devices/pc8080/machine/invaders/machine.xml
index 170279973..99a0839bb 100644
--- a/devices/pc8080/machine/invaders/machine.xml
+++ b/devices/pc8080/machine/invaders/machine.xml
@@ -9,7 +9,7 @@
 	<rom id="romF" addr="0x1000" size="0x0800" file="/devices/pc8080/rom/invaders/INVADERS-F.json"/>
 	<rom id="romE" addr="0x1800" size="0x0800" file="/devices/pc8080/rom/invaders/INVADERS-E.json"/>
 	<ram id="ram"  addr="0x2000" size="0x0400"/>
-	<video id="video" screenWidth="896" screenHeight="1024" bufferRotate="-90" smoothing="false" bufferAddr="0x2400" bufferCols="256" bufferRows="224" bufferBits="1" bufferLeft="0" interruptRate="120" width="40%" pos="left" padding="8px">
+	<video id="video" screenWidth="896" screenHeight="1024" bufferRotate="-90" smoothing="false" bufferAddr="0x2400" bufferCols="256" bufferRows="224" bufferBits="1" bufferLeft="0" interruptRate="120" padding="8px">
 		<menu>
 			<title>224x256 Screen (Rotated)</title>
 			<control type="container" pos="right">
@@ -19,6 +19,4 @@
 	</video>
 	<chipset id="chipset" model="SI1978"/>
 	<keyboard id="keyboard"/>
-	<panel ref="/devices/pc8080/panel/left.xml"/>
-	<debugger id="debugger" commands="s 8086"/>
 </machine>
diff --git a/devices/pc8080/machine/vt100/machine.xml b/devices/pc8080/machine/vt100/machine.xml
index 5f347c243..3be3be0ba 100644
--- a/devices/pc8080/machine/vt100/machine.xml
+++ b/devices/pc8080/machine/vt100/machine.xml
@@ -26,5 +26,5 @@
 	<chipset id="chipset" model="VT100"/>
 	<keyboard id="keyboard"/>
 	<panel ref="/devices/pc8080/panel/wide.xml"/>
-	<debugger id="debugger" messages="port|mem" commands="s 8086"/>
+	<debugger id="debugger" messages="chipset|mem" commands="s 8086"/>
 </machine>
diff --git a/devices/pc8080/rom/vt100/README.md b/devices/pc8080/rom/vt100/README.md
index 5b0bb6793..0784ffe50 100644
--- a/devices/pc8080/rom/vt100/README.md
+++ b/devices/pc8080/rom/vt100/README.md
@@ -64,6 +64,8 @@ and passed on to the PC8080 Debugger.  Here are the rebuild steps:
 	grep -E "[0-9]+ [0-9A-D]+.*;;" VT100.lst | sed -E "s/ *[0-9]+ ([0-9A-F]+).*;(;.*)/     \1   .   \2/" > VT100.map
 	filedump --file=VT100.bin --format=bytes --output=VT100.json --comments --overwrite
 
+You can omit `--comments` to reduce the size of the [VT100.json](VT100.json) file.
+
 Some [VT100.asm](VT100.asm) clean-up remains, because there are still chunks of data that were incorrectly disassembled as code.
 From a reassembly standpoint, it doesn't matter too much, because such instructions get reassembled into the same original binary
 patterns, but from a readability standpoint, it's a nuisance.
diff --git a/devices/pc8080/rom/vt100/VT100.asm b/devices/pc8080/rom/vt100/VT100.asm
index 55a5c0863..32d070e3d 100644
--- a/devices/pc8080/rom/vt100/VT100.asm
+++ b/devices/pc8080/rom/vt100/VT100.asm
@@ -3703,8 +3703,8 @@ X18d7:	in	42h
 	jnz	X18d7
 	mvi	a,2fh		;; Write 0x2fh (standby) to nvr latch
 	out	62h
-	lxi	h,X21d3		;; HL=X21d3
-	mvi	b,0eh		;; B= 14 -- we're reading 14 bits
+	lxi	h,X21d3		;; HL = X21d3
+	mvi	b,0eh		;; B = 14 -- we're reading 14 bits
 X18e6:	in	42h
 	ana	c
 	jz	X18e6
@@ -3726,7 +3726,7 @@ X1900:	in	42h
 	jnz	X18f6		;; read next bit
 	mvi	a,2fh		;; send standby
 	out	62h
-	lxi	d,X21d3		;; DE=0x21d3
+	lxi	d,X21d3		;; DE = 0x21d3
 	mvi	b,0eh		;; B = 14
 	lxi	h,X0000		;; HL = 0
 X1916:	dad	h		;;
diff --git a/devices/pc8080/rom/vt100/VT100.json b/devices/pc8080/rom/vt100/VT100.json
index 2d628595a..a3cd89b9e 100644
--- a/devices/pc8080/rom/vt100/VT100.json
+++ b/devices/pc8080/rom/vt100/VT100.json
@@ -511,4 +511,1194 @@
   0x79,0xF6,0x04,0x4F,0xB7,0x79,0xC9,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 0x00001FD0 y..O.y..........
   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 0x00001FE0 ................
   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00] // 0x00001FF0 ................
-,"symbols":{".64":{"o":64,"a":"","c":"0x0f to NVR latch"},".66":{"o":66,"a":"","c":"invert A (0xf0)"},".67":{"o":67,"a":"","c":"0xf0 to brightness"},".69":{"o":69,"a":"","c":"zero A"},".70":{"o":70,"a":"","c":"zero D, L, H"},".73":{"o":73,"a":"","c":"next 2K ROM"},".74":{"o":74,"a":"","c":"store the current ROM # in B"},".75":{"o":75,"a":"","c":"show current ROM on LEDs"},".77":{"o":77,"a":"","c":"Checksum over 8 256B blocks"},".79":{"o":79,"a":"","c":"Rotate A left"},".80":{"o":80,"a":"","c":"A <- A ^ memory"},".81":{"o":81,"a":"","c":"next memory address"},".82":{"o":82,"a":"","c":"... repeat until end of block"},".85":{"o":85,"a":"","c":"next block"},".86":{"o":86,"a":"","c":"decrement block count"},".87":{"o":87,"a":"","c":"... repeat until end of chip"},".90":{"o":90,"a":"","c":"Check the value of the accumulator"},".91":{"o":91,"a":"","c":"If it's not zero, hang forever"},".94":{"o":94,"a":"","c":"Put the ROM # back in the accumulator"},".95":{"o":95,"a":"","c":"If it's not 4..."},".97":{"o":97,"a":"","c":"repeat for the next ROM"},".101":{"o":101,"a":"","c":"write 5 to LEDs (turns on L2 and L4)"},".103":{"o":103,"a":"","c":"Test pattern: 0xaa"},".105":{"o":105,"a":"","c":"0x2c is the top of RAM on the basic board"},".107":{"o":107,"a":""},".109":{"o":109,"a":"","c":"flags buffer &= 0x02 : is AVO installed?"},".111":{"o":111,"a":"","c":"if bit 2 is not set, AVO is installed"},".114":{"o":114,"a":"","c":"0x40 is the top of RAM on the AVO"},".116":{"o":116,"a":"","c":"load HL with top of RAM"},".117":{"o":117,"a":"","c":"dec HL"},".118":{"o":118,"a":"","c":"M <- 0"},".120":{"o":120,"a":"","c":"dec HL"},".121":{"o":121,"a":"","c":"a <- h"},".122":{"o":122,"a":"","c":"compare to 1f (top of ROM)"},".124":{"o":124,"a":"","c":"continue to zero if not at ROM"},".128":{"o":128,"a":"","c":"read a byte of memory"},".130":{"o":130,"a":"","c":"if it's zero, skip ahead"},".136":{"o":136,"a":"","c":"err"},".141":{"o":141,"a":"","c":"err"},".144":{"o":144,"a":"","c":"run test pattern through ram"},".147":{"o":147,"a":"","c":"jump to 00a8 if ok"},".153":{"o":153,"a":"","c":"err"},".158":{"o":158,"a":"","c":"ok"},".165":{"o":165,"a":"","c":"Hang if non-AVO memory"},".179":{"o":179,"a":"","c":"Repeat mem test with pattern 0x55"},".186":{"o":186,"a":"","c":"zero scratch and screen mem"},".189":{"o":189,"a":"","c":"Set a number of scratch values to fixed values"},".192":{"o":192,"a":"","c":".... more memory initialization"},".254":{"o":254,"a":"","c":"Read from keyboard port"},".258":{"o":258,"a":"","c":"copy b <- a"},".259":{"o":259,"a":"","c":"subtract 0x7c from a"},".261":{"o":261,"a":"","c":"jump to 011a if a is a normal key"},".264":{"o":264,"a":"","c":"otherwise h <- a"},".265":{"o":265,"a":"","c":"h++"},".266":{"o":266,"a":"","c":"a <- 0x10"},".274":{"o":274,"a":"","c":"load keys flag addresss"},".277":{"o":277,"a":"","c":"or in control bit"},".278":{"o":278,"a":"","c":"store again"},".279":{"o":279,"a":"","c":"jump to end to interrupt"},".282":{"o":282,"a":"","c":"load keys flag address"},".287":{"o":287,"a":"","c":"load key counter"},".288":{"o":288,"a":"","c":"if overflow.. (>3 keys)"},".290":{"o":290,"a":"","c":"discard keypress and end interrupt"},".293":{"o":293,"a":"","c":"otherwise increment key counter"},".294":{"o":294,"a":"","c":"load key address buffer?"},".297":{"o":297,"a":"","c":"add key counter to address buffer"},".300":{"o":300,"a":"","c":"save key to address buffer"},".676":{"o":676,"a":"","c":"HL <- 0x204e (top of stack)"},".679":{"o":679,"a":"","c":"DE <- 0x0fb2"},".682":{"o":682,"a":"","c":"B  <- 0"},".684":{"o":684,"a":"","c":"memset(0x204e,0,0xfb2)"},".687":{"o":687,"a":"","c":"invert A"},".688":{"o":688,"a":"","c":"store A in 0x2104"},".691":{"o":691,"a":"","c":"HL <- 0x2004"},".694":{"o":694,"a":"","c":"*(0x2052) = 0x2004"},".697":{"o":697,"a":"","c":"HL <- 0x22d0"},".700":{"o":700,"a":"","c":"*(20f6) = 0x22d0"},".704":{"o":704,"a":"","c":"0x2140 = 0xe605"},".707":{"o":707,"a":"","c":"HL = 0x2000"},".710":{"o":710,"a":"","c":"DE = 0x02d9"},".713":{"o":713,"a":"","c":"B = 18"},".715":{"o":715,"a":"","c":"copy 18 bytes from 0x02d9 to 0x2000"},".718":{"o":718,"a":"","c":"HL = 0x3000"},".721":{"o":721,"a":"","c":"DE = 0x1000"},".724":{"o":724,"a":"","c":"B = 0xFF"},".726":{"o":726,"a":"","c":"Set all of attribute RAM to 0xFF and return"},".747":{"o":747,"a":"","c":"HL = 0x0212"},".750":{"o":750,"a":"","c":"Store 0x1202 at 0x212d"},".753":{"o":753,"a":"","c":"A = 0x35"},".755":{"o":755,"a":"","c":"0x212c = 0x35"},".758":{"o":758,"a":"","c":"A = 1"},".760":{"o":760,"a":"","c":"0x205b = 1"},".763":{"o":763,"a":"","c":"0x2176 = 1"},".766":{"o":766,"a":"","c":"HL = 0x07ff"},".769":{"o":769,"a":"","c":"store 0xff07 at 0x2149"},".772":{"o":772,"a":"","c":"A = 2"},".774":{"o":774,"a":"","c":"0x2073 = 2"},".777":{"o":777,"a":"","c":"A = 0xf7"},".779":{"o":779,"a":"","c":"0x20fa = 0xf7"},".782":{"o":782,"a":"","c":"read flags buffer"},".784":{"o":784,"a":"","c":"And it with 0x04 (check graphics flag)"},".786":{"o":786,"a":"","c":"A=1"},".788":{"o":788,"a":"","c":"if no graphics skip"},".791":{"o":791,"a":"","c":"else store 1 in 0x2079"},".794":{"o":794,"a":"","c":"A = 0xff"},".796":{"o":796,"a":"","c":"0x210e = 0xff"},".799":{"o":799,"a":"","c":"0x21ba = 0xff"},".802":{"o":802,"a":"","c":"H = 0x80"},".804":{"o":804,"a":"","c":"L = 0x80"},".805":{"o":805,"a":"","c":"Store 0x8080 at 0x20c0"},".907":{"o":907,"a":"","c":"Load memory at DE into accumulator"},".908":{"o":908,"a":"","c":"Store it at HL"},".909":{"o":909,"a":"","c":"HL++"},".910":{"o":910,"a":"","c":"DE++"},".911":{"o":911,"a":"","c":"B--"},".912":{"o":912,"a":"","c":"until B is zero"},".975":{"o":975,"a":"","c":"Read from PUSART data"},".990":{"o":990,"a":"","c":"Read from PUSART ctrl"},".2260":{"o":2260,"a":"","c":"subtract 5 from A and return if negative"},".2263":{"o":2263,"a":"","c":"load jump table at 8e5"},".2266":{"o":2266,"a":"","c":"double a"},".2270":{"o":2270,"a":"","c":"hl = X08e5 + 2A"},".2271":{"o":2271,"a":"","c":"load DE from (HL) little-endian"},".2275":{"o":2275,"a":"","c":"zero A"},".2276":{"o":2276,"a":"","c":"jump to address"},".2279":{"o":2279,"a":"","c":"immediate return"},".2285":{"o":2285,"a":"","c":"MYSTERY ADDRESS: this isn't even in AVO!!!"},".2581":{"o":2581,"a":"","c":"HL = 0x05e6"},".2584":{"o":2584,"a":"","c":"0x2140 = 0xe605"},".4227":{"o":4227,"a":"","c":"M <- B"},".4228":{"o":4228,"a":"","c":"HL++"},".4229":{"o":4229,"a":"","c":"DE--"},".4230":{"o":4230,"a":""},".4231":{"o":4231,"a":"","c":"A = D | E"},".4232":{"o":4232,"a":"","c":"repeat if A != 0"},".5267":{"o":5267,"a":"","c":"Read flags buffer"},".5269":{"o":5269,"a":"","c":"check if transmit buffer is empty"},".5271":{"o":5271,"a":"","c":"if zero, return"},".5272":{"o":5272,"a":"","c":"HL = 0x2144"},".5275":{"o":5275,"a":"","c":"Load from 2144"},".5276":{"o":5276,"a":"","c":"Check if zero"},".5277":{"o":5277,"a":""},".5280":{"o":5280,"a":"","c":"If not, A = 10 (else A is zero)"},".5282":{"o":5282,"a":""},".5285":{"o":5285,"a":"","c":"or bits from 0x21a5"},".5286":{"o":5286,"a":""},".5289":{"o":5289,"a":"","c":"or bits from 0x2145"},".5290":{"o":5290,"a":""},".5291":{"o":5291,"a":"","c":"... and 0x2146"},".5292":{"o":5292,"a":""},".5293":{"o":5293,"a":"","c":"... and 0x2147"},".5294":{"o":5294,"a":"","c":"zero 0x2147"},".5296":{"o":5296,"a":""},".5297":{"o":5297,"a":"","c":"... and 0x2148"},".5298":{"o":5298,"a":"","c":"zero 0x2148"},".5300":{"o":5300,"a":"","c":"Write to keyboard buffer"},".5302":{"o":5302,"a":""},".5305":{"o":5305,"a":"","c":"Increment what's at 0x2074"},".5306":{"o":5306,"a":"","c":"load what's at 0x2077"},".5309":{"o":5309,"a":"","c":"return if it's not zero"},".5310":{"o":5310,"a":""},".5311":{"o":5311,"a":"","c":"A =  0x2065"},".5314":{"o":5314,"a":""},".5317":{"o":5317,"a":"","c":"return if [0x2065] | [0x2051] != 0"},".5979":{"o":5979,"a":"","c":"Initialize start of screen RAM and wipe attribute RAM to 0xff"},".5982":{"o":5982,"a":"","c":"B = 0x0a"},".5984":{"o":5984,"a":"","c":"D = 1"},".5986":{"o":5986,"a":"","c":"push B, D"},".5987":{"o":5987,"a":""},".5988":{"o":5988,"a":"","c":"Display wait message"},".5991":{"o":5991,"a":"","c":"pop D"},".5992":{"o":5992,"a":"","c":"disable interrupts(???)"},".5993":{"o":5993,"a":"","c":"HL = 0x217b"},".5996":{"o":5996,"a":"","c":"E = 0x33"},".5998":{"o":5998,"a":"","c":"C = 1"},".6000":{"o":6000,"a":"","c":"A = 0"},".6001":{"o":6001,"a":"","c":"0x21ae = A"},".6004":{"o":6004,"a":"","c":"A = C"},".6005":{"o":6005,"a":"","c":"0x21ad = A"},".6008":{"o":6008,"a":"","c":"push D,H"},".6009":{"o":6009,"a":""},".6010":{"o":6010,"a":"","c":"A=D"},".6011":{"o":6011,"a":"","c":"or A"},".6012":{"o":6012,"a":"","c":"load A from HL"},".6013":{"o":6013,"a":"","c":"store it in 0x21af"},".6016":{"o":6016,"a":"","c":"if A is 0 call X18ae"},".6019":{"o":6019,"a":"","c":"call X18a3"},".6022":{"o":6022,"a":"","c":"pop H,D"},".6078":{"o":6078,"a":"","c":"DE = 0x17ec"},".6081":{"o":6081,"a":"","c":"B = 7"},".6083":{"o":6083,"a":"","c":"HL = 0x21cc"},".6086":{"o":6086,"a":"","c":"Initialize 0x21cc to Wait message"},".6089":{"o":6089,"a":"","c":"HL = 0xcc71"},".6092":{"o":6092,"a":"","c":"retarget screen ram to display wait message"},".6108":{"o":6108,"a":"","c":"DE = 0x17f3"},".6111":{"o":6111,"a":"","c":"B = 11"},".6113":{"o":6113,"a":"","c":"store"},".6349":{"o":6349,"a":"","c":"Write READ command to NVR latch"},".6365":{"o":6365,"a":"","c":"Write 0x2fh (standby) to nvr latch"},".6369":{"o":6369,"a":"","c":"HL=X21d3"},".6372":{"o":6372,"a":"","c":"B= 14 -- we're reading 14 bits"},".6383":{"o":6383,"a":"","c":"wait for NVR clock L"},".6386":{"o":6386,"a":"","c":"shft bit out of nvr"},".6393":{"o":6393,"a":"","c":"wait for NVR clock H"},".6396":{"o":6396,"a":"","c":"read bit and store it in memory"},".6403":{"o":6403,"a":"","c":"wait for NVR clock L"},".6407":{"o":6407,"a":"","c":"read next bit"},".6410":{"o":6410,"a":"","c":"send standby"},".6414":{"o":6414,"a":"","c":"DE=0x21d3"},".6417":{"o":6417,"a":"","c":"B = 14"},".6419":{"o":6419,"a":"","c":"HL = 0"},".6422":{"o":6422,"a":""},".6423":{"o":6423,"a":"","c":"load next char"},".6424":{"o":6424,"a":"","c":"and with NVR data bit"},".6426":{"o":6426,"a":"","c":"rotate NVR bit to high bit"},".6436":{"o":6436,"a":"","c":"Store the finished data in 21af and 21ae"},".6440":{"o":6440,"a":"","c":"Load accumulator from 0x21ae -- (0x42)"},".6443":{"o":6443,"a":"","c":"B = 0xff"},".6445":{"o":6445,"a":"","c":"increment B"},".6446":{"o":6446,"a":"","c":"subtract 0x0a from accumulator"},".6448":{"o":6448,"a":"","c":"repeat while accumulator is positive"},".6451":{"o":6451,"a":"","c":"add 0x0a to accumulator"},".6453":{"o":6453,"a":"","c":"HL = 0x21d3"},".6456":{"o":6456,"a":"","c":"E = 0x23"},".6458":{"o":6458,"a":"","c":"D = 0x14"},".6460":{"o":6460,"a":""},".6461":{"o":6461,"a":"","c":"HL++"},".6462":{"o":6462,"a":"","c":"D--"},".6463":{"o":6463,"a":"","c":"repeat until D is zero"},".6466":{"o":6466,"a":"","c":"Store 0x2f in 21e7"},".6468":{"o":6468,"a":"","c":"HL = 0x21d3"},".6471":{"o":6471,"a":"","c":"copy A to E"},".6472":{"o":6472,"a":"","c":"clear D"},".6474":{"o":6474,"a":"","c":"add DE to HL -- calculate address of bit A"},".6475":{"o":6475,"a":"","c":"Store 0x22 in M"},".6477":{"o":6477,"a":"","c":"HL = 0x21d3"},".6480":{"o":6480,"a":"","c":"A = 0x0a"},".6482":{"o":6482,"a":"","c":"A = 0x0a + B"},".6496":{"o":6496,"a":""},".6500":{"o":6500,"a":"","c":"Flags Buffer & C"},".6505":{"o":6505,"a":"","c":"Return if B is negative"}}}
\ No newline at end of file
+,"symbols":{
+  ".64": {
+    "o": 64,
+    "a": "",
+    "c": "0x0f to NVR latch"
+  },
+  ".66": {
+    "o": 66,
+    "a": "",
+    "c": "invert A (0xf0)"
+  },
+  ".67": {
+    "o": 67,
+    "a": "",
+    "c": "0xf0 to brightness"
+  },
+  ".69": {
+    "o": 69,
+    "a": "",
+    "c": "zero A"
+  },
+  ".70": {
+    "o": 70,
+    "a": "",
+    "c": "zero D, L, H"
+  },
+  ".73": {
+    "o": 73,
+    "a": "",
+    "c": "next 2K ROM"
+  },
+  ".74": {
+    "o": 74,
+    "a": "",
+    "c": "store the current ROM # in B"
+  },
+  ".75": {
+    "o": 75,
+    "a": "",
+    "c": "show current ROM on LEDs"
+  },
+  ".77": {
+    "o": 77,
+    "a": "",
+    "c": "Checksum over 8 256B blocks"
+  },
+  ".79": {
+    "o": 79,
+    "a": "",
+    "c": "Rotate A left"
+  },
+  ".80": {
+    "o": 80,
+    "a": "",
+    "c": "A <- A ^ memory"
+  },
+  ".81": {
+    "o": 81,
+    "a": "",
+    "c": "next memory address"
+  },
+  ".82": {
+    "o": 82,
+    "a": "",
+    "c": "... repeat until end of block"
+  },
+  ".85": {
+    "o": 85,
+    "a": "",
+    "c": "next block"
+  },
+  ".86": {
+    "o": 86,
+    "a": "",
+    "c": "decrement block count"
+  },
+  ".87": {
+    "o": 87,
+    "a": "",
+    "c": "... repeat until end of chip"
+  },
+  ".90": {
+    "o": 90,
+    "a": "",
+    "c": "Check the value of the accumulator"
+  },
+  ".91": {
+    "o": 91,
+    "a": "",
+    "c": "If it's not zero, hang forever"
+  },
+  ".94": {
+    "o": 94,
+    "a": "",
+    "c": "Put the ROM # back in the accumulator"
+  },
+  ".95": {
+    "o": 95,
+    "a": "",
+    "c": "If it's not 4..."
+  },
+  ".97": {
+    "o": 97,
+    "a": "",
+    "c": "repeat for the next ROM"
+  },
+  ".101": {
+    "o": 101,
+    "a": "",
+    "c": "write 5 to LEDs (turns on L2 and L4)"
+  },
+  ".103": {
+    "o": 103,
+    "a": "",
+    "c": "Test pattern: 0xaa"
+  },
+  ".105": {
+    "o": 105,
+    "a": "",
+    "c": "0x2c is the top of RAM on the basic board"
+  },
+  ".107": {
+    "o": 107,
+    "a": ""
+  },
+  ".109": {
+    "o": 109,
+    "a": "",
+    "c": "flags buffer &= 0x02 : is AVO installed?"
+  },
+  ".111": {
+    "o": 111,
+    "a": "",
+    "c": "if bit 2 is not set, AVO is installed"
+  },
+  ".114": {
+    "o": 114,
+    "a": "",
+    "c": "0x40 is the top of RAM on the AVO"
+  },
+  ".116": {
+    "o": 116,
+    "a": "",
+    "c": "load HL with top of RAM"
+  },
+  ".117": {
+    "o": 117,
+    "a": "",
+    "c": "dec HL"
+  },
+  ".118": {
+    "o": 118,
+    "a": "",
+    "c": "M <- 0"
+  },
+  ".120": {
+    "o": 120,
+    "a": "",
+    "c": "dec HL"
+  },
+  ".121": {
+    "o": 121,
+    "a": "",
+    "c": "a <- h"
+  },
+  ".122": {
+    "o": 122,
+    "a": "",
+    "c": "compare to 1f (top of ROM)"
+  },
+  ".124": {
+    "o": 124,
+    "a": "",
+    "c": "continue to zero if not at ROM"
+  },
+  ".128": {
+    "o": 128,
+    "a": "",
+    "c": "read a byte of memory"
+  },
+  ".130": {
+    "o": 130,
+    "a": "",
+    "c": "if it's zero, skip ahead"
+  },
+  ".136": {
+    "o": 136,
+    "a": "",
+    "c": "err"
+  },
+  ".141": {
+    "o": 141,
+    "a": "",
+    "c": "err"
+  },
+  ".144": {
+    "o": 144,
+    "a": "",
+    "c": "run test pattern through ram"
+  },
+  ".147": {
+    "o": 147,
+    "a": "",
+    "c": "jump to 00a8 if ok"
+  },
+  ".153": {
+    "o": 153,
+    "a": "",
+    "c": "err"
+  },
+  ".158": {
+    "o": 158,
+    "a": "",
+    "c": "ok"
+  },
+  ".165": {
+    "o": 165,
+    "a": "",
+    "c": "Hang if non-AVO memory"
+  },
+  ".179": {
+    "o": 179,
+    "a": "",
+    "c": "Repeat mem test with pattern 0x55"
+  },
+  ".186": {
+    "o": 186,
+    "a": "",
+    "c": "zero scratch and screen mem"
+  },
+  ".189": {
+    "o": 189,
+    "a": "",
+    "c": "Set a number of scratch values to fixed values"
+  },
+  ".192": {
+    "o": 192,
+    "a": "",
+    "c": ".... more memory initialization"
+  },
+  ".254": {
+    "o": 254,
+    "a": "",
+    "c": "Read from keyboard port"
+  },
+  ".258": {
+    "o": 258,
+    "a": "",
+    "c": "copy b <- a"
+  },
+  ".259": {
+    "o": 259,
+    "a": "",
+    "c": "subtract 0x7c from a"
+  },
+  ".261": {
+    "o": 261,
+    "a": "",
+    "c": "jump to 011a if a is a normal key"
+  },
+  ".264": {
+    "o": 264,
+    "a": "",
+    "c": "otherwise h <- a"
+  },
+  ".265": {
+    "o": 265,
+    "a": "",
+    "c": "h++"
+  },
+  ".266": {
+    "o": 266,
+    "a": "",
+    "c": "a <- 0x10"
+  },
+  ".274": {
+    "o": 274,
+    "a": "",
+    "c": "load keys flag addresss"
+  },
+  ".277": {
+    "o": 277,
+    "a": "",
+    "c": "or in control bit"
+  },
+  ".278": {
+    "o": 278,
+    "a": "",
+    "c": "store again"
+  },
+  ".279": {
+    "o": 279,
+    "a": "",
+    "c": "jump to end to interrupt"
+  },
+  ".282": {
+    "o": 282,
+    "a": "",
+    "c": "load keys flag address"
+  },
+  ".287": {
+    "o": 287,
+    "a": "",
+    "c": "load key counter"
+  },
+  ".288": {
+    "o": 288,
+    "a": "",
+    "c": "if overflow.. (>3 keys)"
+  },
+  ".290": {
+    "o": 290,
+    "a": "",
+    "c": "discard keypress and end interrupt"
+  },
+  ".293": {
+    "o": 293,
+    "a": "",
+    "c": "otherwise increment key counter"
+  },
+  ".294": {
+    "o": 294,
+    "a": "",
+    "c": "load key address buffer?"
+  },
+  ".297": {
+    "o": 297,
+    "a": "",
+    "c": "add key counter to address buffer"
+  },
+  ".300": {
+    "o": 300,
+    "a": "",
+    "c": "save key to address buffer"
+  },
+  ".676": {
+    "o": 676,
+    "a": "",
+    "c": "HL <- 0x204e (top of stack)"
+  },
+  ".679": {
+    "o": 679,
+    "a": "",
+    "c": "DE <- 0x0fb2"
+  },
+  ".682": {
+    "o": 682,
+    "a": "",
+    "c": "B  <- 0"
+  },
+  ".684": {
+    "o": 684,
+    "a": "",
+    "c": "memset(0x204e,0,0xfb2)"
+  },
+  ".687": {
+    "o": 687,
+    "a": "",
+    "c": "invert A"
+  },
+  ".688": {
+    "o": 688,
+    "a": "",
+    "c": "store A in 0x2104"
+  },
+  ".691": {
+    "o": 691,
+    "a": "",
+    "c": "HL <- 0x2004"
+  },
+  ".694": {
+    "o": 694,
+    "a": "",
+    "c": "*(0x2052) = 0x2004"
+  },
+  ".697": {
+    "o": 697,
+    "a": "",
+    "c": "HL <- 0x22d0"
+  },
+  ".700": {
+    "o": 700,
+    "a": "",
+    "c": "*(20f6) = 0x22d0"
+  },
+  ".704": {
+    "o": 704,
+    "a": "",
+    "c": "0x2140 = 0xe605"
+  },
+  ".707": {
+    "o": 707,
+    "a": "",
+    "c": "HL = 0x2000"
+  },
+  ".710": {
+    "o": 710,
+    "a": "",
+    "c": "DE = 0x02d9"
+  },
+  ".713": {
+    "o": 713,
+    "a": "",
+    "c": "B = 18"
+  },
+  ".715": {
+    "o": 715,
+    "a": "",
+    "c": "copy 18 bytes from 0x02d9 to 0x2000"
+  },
+  ".718": {
+    "o": 718,
+    "a": "",
+    "c": "HL = 0x3000"
+  },
+  ".721": {
+    "o": 721,
+    "a": "",
+    "c": "DE = 0x1000"
+  },
+  ".724": {
+    "o": 724,
+    "a": "",
+    "c": "B = 0xFF"
+  },
+  ".726": {
+    "o": 726,
+    "a": "",
+    "c": "Set all of attribute RAM to 0xFF and return"
+  },
+  ".747": {
+    "o": 747,
+    "a": "",
+    "c": "HL = 0x0212"
+  },
+  ".750": {
+    "o": 750,
+    "a": "",
+    "c": "Store 0x1202 at 0x212d"
+  },
+  ".753": {
+    "o": 753,
+    "a": "",
+    "c": "A = 0x35"
+  },
+  ".755": {
+    "o": 755,
+    "a": "",
+    "c": "0x212c = 0x35"
+  },
+  ".758": {
+    "o": 758,
+    "a": "",
+    "c": "A = 1"
+  },
+  ".760": {
+    "o": 760,
+    "a": "",
+    "c": "0x205b = 1"
+  },
+  ".763": {
+    "o": 763,
+    "a": "",
+    "c": "0x2176 = 1"
+  },
+  ".766": {
+    "o": 766,
+    "a": "",
+    "c": "HL = 0x07ff"
+  },
+  ".769": {
+    "o": 769,
+    "a": "",
+    "c": "store 0xff07 at 0x2149"
+  },
+  ".772": {
+    "o": 772,
+    "a": "",
+    "c": "A = 2"
+  },
+  ".774": {
+    "o": 774,
+    "a": "",
+    "c": "0x2073 = 2"
+  },
+  ".777": {
+    "o": 777,
+    "a": "",
+    "c": "A = 0xf7"
+  },
+  ".779": {
+    "o": 779,
+    "a": "",
+    "c": "0x20fa = 0xf7"
+  },
+  ".782": {
+    "o": 782,
+    "a": "",
+    "c": "read flags buffer"
+  },
+  ".784": {
+    "o": 784,
+    "a": "",
+    "c": "And it with 0x04 (check graphics flag)"
+  },
+  ".786": {
+    "o": 786,
+    "a": "",
+    "c": "A=1"
+  },
+  ".788": {
+    "o": 788,
+    "a": "",
+    "c": "if no graphics skip"
+  },
+  ".791": {
+    "o": 791,
+    "a": "",
+    "c": "else store 1 in 0x2079"
+  },
+  ".794": {
+    "o": 794,
+    "a": "",
+    "c": "A = 0xff"
+  },
+  ".796": {
+    "o": 796,
+    "a": "",
+    "c": "0x210e = 0xff"
+  },
+  ".799": {
+    "o": 799,
+    "a": "",
+    "c": "0x21ba = 0xff"
+  },
+  ".802": {
+    "o": 802,
+    "a": "",
+    "c": "H = 0x80"
+  },
+  ".804": {
+    "o": 804,
+    "a": "",
+    "c": "L = 0x80"
+  },
+  ".805": {
+    "o": 805,
+    "a": "",
+    "c": "Store 0x8080 at 0x20c0"
+  },
+  ".907": {
+    "o": 907,
+    "a": "",
+    "c": "Load memory at DE into accumulator"
+  },
+  ".908": {
+    "o": 908,
+    "a": "",
+    "c": "Store it at HL"
+  },
+  ".909": {
+    "o": 909,
+    "a": "",
+    "c": "HL++"
+  },
+  ".910": {
+    "o": 910,
+    "a": "",
+    "c": "DE++"
+  },
+  ".911": {
+    "o": 911,
+    "a": "",
+    "c": "B--"
+  },
+  ".912": {
+    "o": 912,
+    "a": "",
+    "c": "until B is zero"
+  },
+  ".975": {
+    "o": 975,
+    "a": "",
+    "c": "Read from PUSART data"
+  },
+  ".990": {
+    "o": 990,
+    "a": "",
+    "c": "Read from PUSART ctrl"
+  },
+  ".2260": {
+    "o": 2260,
+    "a": "",
+    "c": "subtract 5 from A and return if negative"
+  },
+  ".2263": {
+    "o": 2263,
+    "a": "",
+    "c": "load jump table at 8e5"
+  },
+  ".2266": {
+    "o": 2266,
+    "a": "",
+    "c": "double a"
+  },
+  ".2270": {
+    "o": 2270,
+    "a": "",
+    "c": "hl = X08e5 + 2A"
+  },
+  ".2271": {
+    "o": 2271,
+    "a": "",
+    "c": "load DE from (HL) little-endian"
+  },
+  ".2275": {
+    "o": 2275,
+    "a": "",
+    "c": "zero A"
+  },
+  ".2276": {
+    "o": 2276,
+    "a": "",
+    "c": "jump to address"
+  },
+  ".2279": {
+    "o": 2279,
+    "a": "",
+    "c": "immediate return"
+  },
+  ".2285": {
+    "o": 2285,
+    "a": "",
+    "c": "MYSTERY ADDRESS: this isn't even in AVO!!!"
+  },
+  ".2581": {
+    "o": 2581,
+    "a": "",
+    "c": "HL = 0x05e6"
+  },
+  ".2584": {
+    "o": 2584,
+    "a": "",
+    "c": "0x2140 = 0xe605"
+  },
+  ".4227": {
+    "o": 4227,
+    "a": "",
+    "c": "M <- B"
+  },
+  ".4228": {
+    "o": 4228,
+    "a": "",
+    "c": "HL++"
+  },
+  ".4229": {
+    "o": 4229,
+    "a": "",
+    "c": "DE--"
+  },
+  ".4230": {
+    "o": 4230,
+    "a": ""
+  },
+  ".4231": {
+    "o": 4231,
+    "a": "",
+    "c": "A = D | E"
+  },
+  ".4232": {
+    "o": 4232,
+    "a": "",
+    "c": "repeat if A != 0"
+  },
+  ".5267": {
+    "o": 5267,
+    "a": "",
+    "c": "Read flags buffer"
+  },
+  ".5269": {
+    "o": 5269,
+    "a": "",
+    "c": "check if transmit buffer is empty"
+  },
+  ".5271": {
+    "o": 5271,
+    "a": "",
+    "c": "if zero, return"
+  },
+  ".5272": {
+    "o": 5272,
+    "a": "",
+    "c": "HL = 0x2144"
+  },
+  ".5275": {
+    "o": 5275,
+    "a": "",
+    "c": "Load from 2144"
+  },
+  ".5276": {
+    "o": 5276,
+    "a": "",
+    "c": "Check if zero"
+  },
+  ".5277": {
+    "o": 5277,
+    "a": ""
+  },
+  ".5280": {
+    "o": 5280,
+    "a": "",
+    "c": "If not, A = 10 (else A is zero)"
+  },
+  ".5282": {
+    "o": 5282,
+    "a": ""
+  },
+  ".5285": {
+    "o": 5285,
+    "a": "",
+    "c": "or bits from 0x21a5"
+  },
+  ".5286": {
+    "o": 5286,
+    "a": ""
+  },
+  ".5289": {
+    "o": 5289,
+    "a": "",
+    "c": "or bits from 0x2145"
+  },
+  ".5290": {
+    "o": 5290,
+    "a": ""
+  },
+  ".5291": {
+    "o": 5291,
+    "a": "",
+    "c": "... and 0x2146"
+  },
+  ".5292": {
+    "o": 5292,
+    "a": ""
+  },
+  ".5293": {
+    "o": 5293,
+    "a": "",
+    "c": "... and 0x2147"
+  },
+  ".5294": {
+    "o": 5294,
+    "a": "",
+    "c": "zero 0x2147"
+  },
+  ".5296": {
+    "o": 5296,
+    "a": ""
+  },
+  ".5297": {
+    "o": 5297,
+    "a": "",
+    "c": "... and 0x2148"
+  },
+  ".5298": {
+    "o": 5298,
+    "a": "",
+    "c": "zero 0x2148"
+  },
+  ".5300": {
+    "o": 5300,
+    "a": "",
+    "c": "Write to keyboard buffer"
+  },
+  ".5302": {
+    "o": 5302,
+    "a": ""
+  },
+  ".5305": {
+    "o": 5305,
+    "a": "",
+    "c": "Increment what's at 0x2074"
+  },
+  ".5306": {
+    "o": 5306,
+    "a": "",
+    "c": "load what's at 0x2077"
+  },
+  ".5309": {
+    "o": 5309,
+    "a": "",
+    "c": "return if it's not zero"
+  },
+  ".5310": {
+    "o": 5310,
+    "a": ""
+  },
+  ".5311": {
+    "o": 5311,
+    "a": "",
+    "c": "A =  0x2065"
+  },
+  ".5314": {
+    "o": 5314,
+    "a": ""
+  },
+  ".5317": {
+    "o": 5317,
+    "a": "",
+    "c": "return if [0x2065] | [0x2051] != 0"
+  },
+  ".5979": {
+    "o": 5979,
+    "a": "",
+    "c": "Initialize start of screen RAM and wipe attribute RAM to 0xff"
+  },
+  ".5982": {
+    "o": 5982,
+    "a": "",
+    "c": "B = 0x0a"
+  },
+  ".5984": {
+    "o": 5984,
+    "a": "",
+    "c": "D = 1"
+  },
+  ".5986": {
+    "o": 5986,
+    "a": "",
+    "c": "push B, D"
+  },
+  ".5987": {
+    "o": 5987,
+    "a": ""
+  },
+  ".5988": {
+    "o": 5988,
+    "a": "",
+    "c": "Display wait message"
+  },
+  ".5991": {
+    "o": 5991,
+    "a": "",
+    "c": "pop D"
+  },
+  ".5992": {
+    "o": 5992,
+    "a": "",
+    "c": "disable interrupts(???)"
+  },
+  ".5993": {
+    "o": 5993,
+    "a": "",
+    "c": "HL = 0x217b"
+  },
+  ".5996": {
+    "o": 5996,
+    "a": "",
+    "c": "E = 0x33"
+  },
+  ".5998": {
+    "o": 5998,
+    "a": "",
+    "c": "C = 1"
+  },
+  ".6000": {
+    "o": 6000,
+    "a": "",
+    "c": "A = 0"
+  },
+  ".6001": {
+    "o": 6001,
+    "a": "",
+    "c": "0x21ae = A"
+  },
+  ".6004": {
+    "o": 6004,
+    "a": "",
+    "c": "A = C"
+  },
+  ".6005": {
+    "o": 6005,
+    "a": "",
+    "c": "0x21ad = A"
+  },
+  ".6008": {
+    "o": 6008,
+    "a": "",
+    "c": "push D,H"
+  },
+  ".6009": {
+    "o": 6009,
+    "a": ""
+  },
+  ".6010": {
+    "o": 6010,
+    "a": "",
+    "c": "A=D"
+  },
+  ".6011": {
+    "o": 6011,
+    "a": "",
+    "c": "or A"
+  },
+  ".6012": {
+    "o": 6012,
+    "a": "",
+    "c": "load A from HL"
+  },
+  ".6013": {
+    "o": 6013,
+    "a": "",
+    "c": "store it in 0x21af"
+  },
+  ".6016": {
+    "o": 6016,
+    "a": "",
+    "c": "if A is 0 call X18ae"
+  },
+  ".6019": {
+    "o": 6019,
+    "a": "",
+    "c": "call X18a3"
+  },
+  ".6022": {
+    "o": 6022,
+    "a": "",
+    "c": "pop H,D"
+  },
+  ".6078": {
+    "o": 6078,
+    "a": "",
+    "c": "DE = 0x17ec"
+  },
+  ".6081": {
+    "o": 6081,
+    "a": "",
+    "c": "B = 7"
+  },
+  ".6083": {
+    "o": 6083,
+    "a": "",
+    "c": "HL = 0x21cc"
+  },
+  ".6086": {
+    "o": 6086,
+    "a": "",
+    "c": "Initialize 0x21cc to Wait message"
+  },
+  ".6089": {
+    "o": 6089,
+    "a": "",
+    "c": "HL = 0xcc71"
+  },
+  ".6092": {
+    "o": 6092,
+    "a": "",
+    "c": "retarget screen ram to display wait message"
+  },
+  ".6108": {
+    "o": 6108,
+    "a": "",
+    "c": "DE = 0x17f3"
+  },
+  ".6111": {
+    "o": 6111,
+    "a": "",
+    "c": "B = 11"
+  },
+  ".6113": {
+    "o": 6113,
+    "a": "",
+    "c": "store"
+  },
+  ".6349": {
+    "o": 6349,
+    "a": "",
+    "c": "Write READ command to NVR latch"
+  },
+  ".6365": {
+    "o": 6365,
+    "a": "",
+    "c": "Write 0x2fh (standby) to nvr latch"
+  },
+  ".6369": {
+    "o": 6369,
+    "a": "",
+    "c": "HL=X21d3"
+  },
+  ".6372": {
+    "o": 6372,
+    "a": "",
+    "c": "B= 14 -- we're reading 14 bits"
+  },
+  ".6383": {
+    "o": 6383,
+    "a": "",
+    "c": "wait for NVR clock L"
+  },
+  ".6386": {
+    "o": 6386,
+    "a": "",
+    "c": "shft bit out of nvr"
+  },
+  ".6393": {
+    "o": 6393,
+    "a": "",
+    "c": "wait for NVR clock H"
+  },
+  ".6396": {
+    "o": 6396,
+    "a": "",
+    "c": "read bit and store it in memory"
+  },
+  ".6403": {
+    "o": 6403,
+    "a": "",
+    "c": "wait for NVR clock L"
+  },
+  ".6407": {
+    "o": 6407,
+    "a": "",
+    "c": "read next bit"
+  },
+  ".6410": {
+    "o": 6410,
+    "a": "",
+    "c": "send standby"
+  },
+  ".6414": {
+    "o": 6414,
+    "a": "",
+    "c": "DE=0x21d3"
+  },
+  ".6417": {
+    "o": 6417,
+    "a": "",
+    "c": "B = 14"
+  },
+  ".6419": {
+    "o": 6419,
+    "a": "",
+    "c": "HL = 0"
+  },
+  ".6422": {
+    "o": 6422,
+    "a": ""
+  },
+  ".6423": {
+    "o": 6423,
+    "a": "",
+    "c": "load next char"
+  },
+  ".6424": {
+    "o": 6424,
+    "a": "",
+    "c": "and with NVR data bit"
+  },
+  ".6426": {
+    "o": 6426,
+    "a": "",
+    "c": "rotate NVR bit to high bit"
+  },
+  ".6436": {
+    "o": 6436,
+    "a": "",
+    "c": "Store the finished data in 21af and 21ae"
+  },
+  ".6440": {
+    "o": 6440,
+    "a": "",
+    "c": "Load accumulator from 0x21ae -- (0x42)"
+  },
+  ".6443": {
+    "o": 6443,
+    "a": "",
+    "c": "B = 0xff"
+  },
+  ".6445": {
+    "o": 6445,
+    "a": "",
+    "c": "increment B"
+  },
+  ".6446": {
+    "o": 6446,
+    "a": "",
+    "c": "subtract 0x0a from accumulator"
+  },
+  ".6448": {
+    "o": 6448,
+    "a": "",
+    "c": "repeat while accumulator is positive"
+  },
+  ".6451": {
+    "o": 6451,
+    "a": "",
+    "c": "add 0x0a to accumulator"
+  },
+  ".6453": {
+    "o": 6453,
+    "a": "",
+    "c": "HL = 0x21d3"
+  },
+  ".6456": {
+    "o": 6456,
+    "a": "",
+    "c": "E = 0x23"
+  },
+  ".6458": {
+    "o": 6458,
+    "a": "",
+    "c": "D = 0x14"
+  },
+  ".6460": {
+    "o": 6460,
+    "a": ""
+  },
+  ".6461": {
+    "o": 6461,
+    "a": "",
+    "c": "HL++"
+  },
+  ".6462": {
+    "o": 6462,
+    "a": "",
+    "c": "D--"
+  },
+  ".6463": {
+    "o": 6463,
+    "a": "",
+    "c": "repeat until D is zero"
+  },
+  ".6466": {
+    "o": 6466,
+    "a": "",
+    "c": "Store 0x2f in 21e7"
+  },
+  ".6468": {
+    "o": 6468,
+    "a": "",
+    "c": "HL = 0x21d3"
+  },
+  ".6471": {
+    "o": 6471,
+    "a": "",
+    "c": "copy A to E"
+  },
+  ".6472": {
+    "o": 6472,
+    "a": "",
+    "c": "clear D"
+  },
+  ".6474": {
+    "o": 6474,
+    "a": "",
+    "c": "add DE to HL -- calculate address of bit A"
+  },
+  ".6475": {
+    "o": 6475,
+    "a": "",
+    "c": "Store 0x22 in M"
+  },
+  ".6477": {
+    "o": 6477,
+    "a": "",
+    "c": "HL = 0x21d3"
+  },
+  ".6480": {
+    "o": 6480,
+    "a": "",
+    "c": "A = 0x0a"
+  },
+  ".6482": {
+    "o": 6482,
+    "a": "",
+    "c": "A = 0x0a + B"
+  },
+  ".6496": {
+    "o": 6496,
+    "a": ""
+  },
+  ".6500": {
+    "o": 6500,
+    "a": "",
+    "c": "Flags Buffer & C"
+  },
+  ".6505": {
+    "o": 6505,
+    "a": "",
+    "c": "Return if B is negative"
+  }
+}}
\ No newline at end of file
diff --git a/modules/filedump/lib/filedump.js b/modules/filedump/lib/filedump.js
index daf45eb9a..65393d50f 100644
--- a/modules/filedump/lib/filedump.js
+++ b/modules/filedump/lib/filedump.js
@@ -631,7 +631,7 @@ FileDump.prototype.loadMap = function(sMapFile, done)
                         done(new Error("unrecognized line (" + s + ") in MAP file: " + sMapName), null);
                         return;
                     }
-                    sMapData = JSON.stringify(aSymbols);
+                    sMapData = obj.fJSONComments? JSON.stringify(aSymbols, null, 2) : JSON.stringify(aSymbols);
                     if (sMapData) {
                         obj.json = '{' + obj.json + ',"symbols":' + sMapData + '}';
                     }
diff --git a/modules/pc8080/lib/chipset.js b/modules/pc8080/lib/chipset.js
index 804875450..00b8bc6a9 100644
--- a/modules/pc8080/lib/chipset.js
+++ b/modules/pc8080/lib/chipset.js
@@ -205,7 +205,8 @@ ChipSet.VT100 = {
             ERASE:          0x5,
             READ:           0x6,
             STANDBY:        0x7
-        }
+        },
+        WORDMASK:   0x3fff              // NVR words are 14-bit
     },
     DC012: {                            // generates scan counts for the Video Processor
         PORT:       0xA2,               // write-only
@@ -678,11 +679,11 @@ ChipSet.prototype.getNVRAddr = function()
 };
 
 /**
- * advanceNVR()
+ * doNVRCommand()
  */
-ChipSet.prototype.advanceNVR = function()
+ChipSet.prototype.doNVRCommand = function()
 {
-    var addr;
+    var addr, data;
     var bit = this.bNVRLatch & 0x1;
     var bCmd = (this.bNVRLatch >> 1) & 0x7;
 
@@ -696,7 +697,8 @@ ChipSet.prototype.advanceNVR = function()
 
     case ChipSet.VT100.NVR.CMD.ERASE:
         addr = this.getNVRAddr();
-        this.aNVRWords[addr] = 0x3fff;
+        this.aNVRWords[addr] = ChipSet.VT100.NVR.WORDMASK;
+        this.printMessage("doNVRCommand(): erase data at addr " + str.toHexWord(addr));
         break;
 
     case ChipSet.VT100.NVR.CMD.ACCEPT_DATA:
@@ -705,17 +707,32 @@ ChipSet.prototype.advanceNVR = function()
 
     case ChipSet.VT100.NVR.CMD.WRITE:
         addr = this.getNVRAddr();
-        this.aNVRWords[addr] = this.wNVRData & 0x3fff;
+        data = this.wNVRData & ChipSet.VT100.NVR.WORDMASK;
+        this.aNVRWords[addr] = data;
+        this.printMessage("doNVRCommand(): write data " + str.toHexWord(data) + " to addr " + str.toHexWord(addr));
         break;
 
     case ChipSet.VT100.NVR.CMD.READ:
         addr = this.getNVRAddr();
-        this.wNVRData = this.aNVRWords[addr];
+        data = this.aNVRWords[addr];
+        /*
+         * Since we don't explicitly initialize aNVRWords[], we pretend any uninitialized words contains WORDMASK.
+         */
+        if (data == null) data = ChipSet.VT100.NVR.WORDMASK;
+        this.wNVRData = data;
+        this.printMessage("doNVRCommand():  read data " + str.toHexWord(data) + " from addr " + str.toHexWord(addr));
         break;
 
     case ChipSet.VT100.NVR.CMD.SHIFT_OUT:
-        this.bNVROut = this.wNVRData & 0x2000;
         this.wNVRData <<= 1;
+        /*
+         * Since WORDMASK is 0x3fff, this will mask the shifted data with 0x4000, which is the bit we want to isolate.
+         */
+        this.bNVROut = this.wNVRData & (ChipSet.VT100.NVR.WORDMASK + 1);
+        break;
+
+    default:
+        this.printMessage("doNVRCommand(): unrecognized command " + str.toHexByte(bCmd));
         break;
     }
 };
@@ -738,7 +755,7 @@ ChipSet.prototype.inVT100FlagsBuffer = function(port, addrFrom)
     if (this.getVT100LBA(7)) {
         b |= ChipSet.VT100.FLAGS_BUFFER.NVR_CLK;
         if (b != this.bFlagsBuffer) {
-            this.advanceNVR();
+            this.doNVRCommand();
         }
     }
     b &= ~ChipSet.VT100.FLAGS_BUFFER.NVR_DATA;
diff --git a/modules/pc8080/lib/debugger.js b/modules/pc8080/lib/debugger.js
index 18d6e86e6..40816d6ba 100644
--- a/modules/pc8080/lib/debugger.js
+++ b/modules/pc8080/lib/debugger.js
@@ -230,30 +230,31 @@ if (DEBUGGER) {
      */
 
     Debugger.COMMANDS = {
-        '?':     "help/print",
-        'a [#]': "assemble",            // TODO: Implement this command someday
-        'b [#]': "breakpoint",          // multiple variations (use b? to list them)
-        'c':     "clear output",
-        'd [#]': "dump memory",         // additional syntax: d [#] [l#], where l# is a number of bytes to dump
-        'e [#]': "edit memory",
-        'f':     "frequencies",
-        'g [#]': "go [to #]",
-        'h':     "halt",
-        'i [#]': "input port #",
-        'if':    "eval expression",
-        'k':     "stack trace",
-        "ln":    "list nearest symbol(s)",
-        'm':     "messages",
-        'o [#]': "output port #",
-        'p':     "step over",           // other variations: pr (step and dump registers)
-        'print': "print expression",
-        'r':     "dump/set registers",
-        'reset': "reset machine",
-        's':     "set options",
-        't [#]': "trace",               // other variations: tr (trace and dump registers)
-        'u [#]': "unassemble",
-        'v':     "print version",
-        'var':   "assign variable"
+        '?':        "help/print",
+        'a [#]':    "assemble",             // TODO: Implement this command someday
+        'b [#]':    "breakpoint",           // multiple variations (use b? to list them)
+        'c':        "clear output",
+        'd [#]':    "dump memory",          // additional syntax: d [#] [l#], where l# is a number of bytes to dump
+        'e [#]':    "edit memory",
+        'f':        "frequencies",
+        'g [#]':    "go [to #]",
+        'h':        "halt",
+        'i [#]':    "input port #",
+        'if':       "eval expression",
+        'int [#]':  "request interrupt",
+        'k':        "stack trace",
+        "ln":       "list nearest symbol(s)",
+        'm':        "messages",
+        'o [#]':    "output port #",
+        'p':        "step over",            // other variations: pr (step and dump registers)
+        'print':    "print expression",
+        'r':        "dump/set registers",
+        'reset':    "reset machine",
+        's':        "set options",
+        't [#]':    "trace",                // other variations: tr (trace and dump registers)
+        'u [#]':    "unassemble",
+        'v':        "print version",
+        'var':      "assign variable"
     };
 
     Debugger.STYLE_8080 = 8080;
@@ -3288,7 +3289,7 @@ if (DEBUGGER) {
     {
         var s = "commands:";
         for (var sCommand in Debugger.COMMANDS) {
-            s += '\n' + str.pad(sCommand, 7) + Debugger.COMMANDS[sCommand];
+            s += '\n' + str.pad(sCommand, 9) + Debugger.COMMANDS[sCommand];
         }
         if (!this.checksEnabled()) s += "\nnote: frequency/history disabled if no exec breakpoints";
         this.println(s);
@@ -3799,6 +3800,26 @@ if (DEBUGGER) {
         }
     };
 
+    /**
+     * doInt(sLevel)
+     *
+     * @this {Debugger}
+     * @param {string} sLevel
+     * @return {boolean} true if success, false if error
+     */
+    Debugger.prototype.doInt = function(sLevel)
+    {
+        if (!this.cpu.getIF()) {
+            this.println("interrupts disabled (use rif=1 to enable)");
+            return false;
+        }
+        var nLevel = this.parseExpression(sLevel);
+        if (nLevel == null) return false;
+        this.println("requesting interrupt level " + nLevel);
+        this.cpu.requestINTR(nLevel);
+        return true;
+    };
+
     /**
      * doVar(sCmd)
      *
@@ -4686,6 +4707,12 @@ if (DEBUGGER) {
                         }
                         break;
                     }
+                    if (asArgs[0] == "int") {
+                        if (!this.doInt(asArgs[1])) {
+                            result = false;
+                        }
+                        break;
+                    }
                     this.doInput(asArgs[1]);
                     break;
                 case 'k':