- Fixed some bugs in the emulator.

- Started work on implementing the Super VIA emulation.
- Added support for disabling disassembly per
  instruction, when in debug mode.
- Did some more work on rewriting the SuB Suite to
  work with the new calling convention.
- Rewrote the symbol handling code in the emulator's
  assembler, to make it both simpler, and to add
  support for arbitrarily deep symbol scopes.
- Added support for arbitrarily deep local symbol
  scopes.

  For example, to declare a symbol of depth 2, you add
  two '@' characters to the start of the symbol name.

  In other words, the number of '@' characters before
  the symbol name is what determines the scope of that
  symbol.

  And to use a symbol thats outside the current
  scope, you would use the same syntax as using a
  struct member, so you would do `global.local`.

11 files changed, 1309 insertions, 957 deletions

diff --git a/programs/sub-suite/declare.s b/programs/sub-suite/declare.s
index 550228d..36a4f15 100644
--- a/programs/sub-suite/declare.s
+++ b/programs/sub-suite/declare.s
@@ -2,7 +2,7 @@
 ; Structs, and unions.
 
 ; Line struct.
-.struct ln
+.struct line
 	next	.qword	; Pointer to next line.
 	tok	.qword	; The tokens for this line.
 
@@ -852,7 +852,7 @@ cmd_srt:
 	.word list
 	.word asm
 	.word help
-	.word inst
+	.word instruction
 	.word run
 	.word set_val
 
diff --git a/programs/sub-suite/free-new.s b/programs/sub-suite/free-new.s
new file mode 100644
index 0000000..dad19d0
--- /dev/null
+++ b/programs/sub-suite/free-new.s
@@ -0,0 +1,143 @@
+.include "declare.s"
+
+.org 0
+
+; free: Free allocated memory.
+; Input: D = Pointer to allocated memory.
+; Output: none.
+; Caller preserved registers: D.
+; Callie preserved registers: A, B, X, Y, E.
+
+free:
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	phy.q			; Preserve Y.
+	phe.q			; Preserve E.
+	and #0			; Reset A.
+	tab			; Reset B.
+	tax			; Reset X.
+	tay			; Reset Y.
+	mov a, d		; Get the passed pointer.
+	bne @getrealblk		; The pointer isn't NULL, so get the real block.
+	bra @end		; The pointer is NULL, so we're done.
+@getrealblk:
+	sub #8			; Get the start of the used block.
+	mov.q a, (a)		; Get the start of the real block.
+	mov.q b, (a+ublk.size)	; Get the size of the real block.
+	lea e, (a+b)		; Add the size of the real block with the start of the real block.
+	cmp.q e, heapptr	; Is this block on top of the heap?
+	bne @heapadd		; No, so add it to the free block list.
+@dectop:
+	mov.q heapptr, (a)	; Set the top of the heap to the start of the previous real block.
+@chklastblk:
+	mov.q b, heapl		; Get the last free list entry.
+	beq @end		; The free list is empty, so we're done.
+	ldy #fblk.size		; Get the size of the block.
+	mov.q a, (b+fblk.size)	; Get the size of the block.
+	lea e, (a+b)		; Add the size of the block, with the address of the block entry.
+	cmp.q e, heapptr	; Is the last block on top of the heap?
+	bne @end		; No, so we're done.
+@delblk:
+	mov.q heapptr, b	; Yes, so remove the last block.
+@correctblk:
+	mov.q a, (b+fblk.prev)	; Get the previous block.
+	sta.q heapl		; Set the last block to the previous block.
+	bne @delnxtblk		; The previous block isn't NULL, so delete the next block.
+	sta.q heapf		; The previous block is NULL, so empty the free list.
+	bra @end		; We are done.
+@delnxtblk:
+	lea e, (a+fblk.next)	; Delete the next block.
+	stz.q (e)		;
+@end:
+	ple.q			; Restore E.
+	ply.q			; Restore Y.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of free.
+
+
+@heapadd:
+	mov.q y, heapf		; Get the first block.
+	bne @srchflst		; The Free list isn't empty, so start searching the free list.
+@empty:
+	mov.q (a+fblk.next), y	; Clear the next block.
+	mov.q (a+fblk.prev), y	; Clear the previous block.
+	sta.q heapf		; Set the first block entry to the current block.
+	sta.q heapl		; Set the last block entry to the current block.
+	bra @end		; We are done.
+@srchflst:
+@loop:
+	cmp y, a		; Is the right pointer at, or below the current block?
+	beq @nextright		; Yes, so get the next right pointer.
+	bcs @chkrmerge		; No, so do the right block merge.
+@nextright:
+	tyx			; Set the left pointer, to the right pointer.
+	mov.q y, (y+fblk.next)	; Set the current right pointer to the next right pointer.
+	bne @loop		; The next right pointer isn't NULL, so keep looping.
+@st_lmerge2:
+	mov.q (a+fblk.next), y	; Clear the next block.
+	sta.q heapl		; Set the last free block entry to it.
+	bra @chklmerge2		; Do the left block merge.
+@chkrmerge:
+	lea e, (a+b)		; Add the size of the current block, to the current block.
+	cmp e, y		; Is the current block the same as the right block?
+	bne @normerge		; No, so don't merge the right block.
+@rmerge:
+	mov e, b		; Get the size of the current block.
+	add.q e, (y+fblk.size)	; Add the size of the current block, with the size of the right pointer.
+	mov.q (a+fblk.size), e	; Set the size of the current block, to the new size.
+@rmerge2:
+	lea fblk.next		; Get the next right pointer.
+	mov.q (a+e), (y+e)	; Set the next block, to the next right pointer.
+	mov.q b, (y+e)		; Save the next block.
+	beq @setheapl		; The next block is NULL, so set the last block.
+@setprev:
+	mov.q (b+fblk.prev), a	; Set the previous block to the current block.
+	bra @chklmerge		; Do the left block merge.
+@setheapl:
+	sta.q heapl		; Set the last block to the current block.
+	bra @chklmerge		; Do the left block merge.
+@normerge:
+	mov.q (a+fblk.next), y	; Set the next block to the right pointer.
+	mov.q (y+fblk.prev), a	; Set the previous right pointer to the current block.
+@chklmerge:
+	and x, x		; Is the left pointer NULL?
+	bne @chklmerge2		; No, so keep checking.
+@newstart:
+	mov.q (a+fblk.prev), x	;
+	sta.q heapf		; Set the first block, to the current block.
+	bra @end2		; We are done.
+@chklmerge2:
+	mov.q e, (x+fblk.size)	; Get the size of the left block.
+	add e, x		; Add the size of the left block, to the left pointer.
+	cmp e, a		; Is the left block adjacent?
+	bne @nolmerge		; No, so don't merge the left block.
+@lmerge:
+	lea fblk.size		; Set the offset to the block size.
+	add.q (x+e), (a+e)	; Add the size of the left block, with the size of the current block.
+@lmerge2:
+	lea fblk.next		; Set the offset to the next block.
+	mov.q (x+e), (a+e)	; Set the next left pointer, to the next block.
+	mov.q b, (a+e)		; Get the next block.
+	beq @newlast		; The next block is NULL, so set the last block.
+@lprev:
+	mov.q (b+fblk.prev), x	; Set the next left pointer's previous pointer to the left pointer.
+	bra @end2		; We are done.
+@newlast:
+	stx.q heapl		; Set the last block, to the left pointer.
+	bra @end2		; We are done.
+@nolmerge:
+	mov.q (x+fblk.next), a	; Set the next left pointer, to the current block.
+@nolmerge2:
+	mov.q (a+fblk.prev), x	; Set the previous block, to the left pointer.
+@end2:
+	ple.q			; Restore E.
+	ply.q			; Restore Y.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of free.
+
+a
+q
diff --git a/programs/sub-suite/free-old.s b/programs/sub-suite/free-old.s
new file mode 100644
index 0000000..7f75edd
--- /dev/null
+++ b/programs/sub-suite/free-old.s
@@ -0,0 +1,200 @@
+.include "declare.s"
+
+.org 0
+
+; free: Free allocated memory.
+; Input: A = Pointer to allocated memory.
+; Output: none.
+; Caller preserved registers: none.
+; Callie preserved registers: A, B, Y.
+
+free:
+	pha.q		; Preserve A.
+	phb.q		; Preserve B.
+	phy.q		; Preserve Y.
+	pha.q		; Push the pointer argument to the stack.
+	and #0		; Reset A.
+	tay		; Reset Y.
+	sbs #$18	; Allocate 3 local variables onto the stack.
+	lda.q sp+25	; Get the passed pointer.
+	ora.d sp+29	; Is the passed pointer NULL?
+	bne @getrealblk	; No, so get the real block.
+	bra @end	; Yes, so we're done.
+@getrealblk:
+	lda.q sp+25	; Get the passed pointer.
+	sec		; Prepare for a non borrowing subtract.
+	sbc #8		; Move the passed pointer back by one.
+	sta.q sp+25	; Set the first local variable to the start of the used block.
+	lda.q (sp+25)	; Get the real block address.
+	sta.q sp+25	; Set the passed pointer to the start of the real block.
+	ldy #ublk.size	; Get the size of the real block.
+	lda.q (sp+25), y;
+	sta.q sp+17	; Save the size of the real block.
+	clc		; Prepare for a non carrying add.
+	adc.q sp+25	; Add the size of the real block with the start of the real block.
+	cmp.q heapptr	; Is this block on top of the heap?
+	bne @heapadd	; No, so add it to the free block list.
+@dectop:
+	lda.q sp+25	; Get the block.
+	sta.q heapptr	; Set the top of the heap to it.
+@chklastblk:
+	lda.q heapl	; Get the last free list entry.
+	sta.q sp+17	; Copy it into the second local variable.
+	ora.d sp+21	; Is the free list empty?
+	beq @end	; Yes, so we're done.
+	lda.q sp+17	; No, so Get the last free list entry.
+	ldy #fblk.size	; Get the size of the block.
+	lda.q (sp+17), y;
+	clc		; Prepare for a non carrying add.
+	adc.q sp+17	; Add the size of the block, with the address of the block entry.
+	cmp.q heapptr	; Is the last block on top of the heap?
+	bne @end	; No, so we're done.
+@delblk:
+	lda.q sp+17	; Yes, so remove the last block.
+	sta.q heapptr	;
+@correctblk:
+	ldy #fblk.prev	; Get the previous block.
+	lda.q (sp+17), y;
+	sta.q sp+25	; Save the previous block for now.
+	sta.q heapl	; Set the last block to the previous block.
+	ora.d sp+29	; Is the previous block non NULL?
+	bne @delnxtblk	; Yes, so delete the next block.
+	sta.q heapf	; No, so empty the free list.
+	bra @end	; We are done.
+@delnxtblk:
+	and #0		; Reset A.
+	ldy #fblk.next	; Delete the next block.
+	sta.q (sp+25), y;
+@end:
+	ads #$20	; Clean up the stack frame.
+	ply.q		; Restore Y.
+	plb.q		; Restore B.
+	pla.q		; Restore A.
+	rts		; End of free.
+
+
+@heapadd:
+	lda.q heapf	; Get the first block.
+	sta.q sp+9	; Copy it into the third local variable.
+	ora.d sp+13	; Is the free list empty?
+	bne @srchflst	; No, so start searching the free list.
+@empty:
+	ldy #fblk.next	; Clear the next block.
+	sta.q (sp+25), y;
+	ldy #fblk.prev	; Clear the previous block.
+	sta.q (sp+25), y;
+	lda.q sp+25	; Reset A.
+	sta.q heapf	; Clear the first block entry.
+	sta.q heapf	; Clear the last block entry.
+	bra @end	; We are done.
+@srchflst:
+	and #0		; Reset A.
+	sta.q sp+1	; Reset the left pointer.
+	ldy #fblk.next	; Setup for the loop.
+@loop:
+	lda.q sp+9	; Get the right pointer.
+	cmp.q sp+25	; Is the right pointer at, or below the current block?
+	beq @nextright	; Yes, so get the next right pointer.
+	bcs @chkrmerge	; No, so do the right block merge.
+@nextright:
+	sta.q sp+1	; Set the left pointer, to the right pointer.
+	lda.q (sp+9), y	; Get the next right pointer.
+	sta.q sp+9	; Set the current right pointer to the next right pointer.
+	ora.d sp+13	; Is the next right pointer NULL?
+	bne @loop	; No, so keep looping.
+@st_lmerge2:
+	sta.q (sp+25), y; Clear the next block.
+	lda.q sp+25	; Get the current block.
+	sta.q heapl	; Set the last free block entry to it.
+	bra @chklmerge2	; Do the left block merge.
+@chkrmerge:
+	lda.q sp+25	; Get the current block.
+	clc		; Prepare for a non carrying add.
+	adc.q sp+17	; Add the size of the current block, to the current block.
+	cmp.q sp+9	; Is the right pointer NULL?
+	bne @normerge	; No, so don't merge the right block.
+@rmerge:
+	ldy #fblk.size	; Get the size of the right pointer.
+	lda.q sp+17	; Get the size of the current block.
+	clc		; Prepare for a non carrying add.
+	adc.q (sp+9), y	; Add the size of the current block, with the size of the right pointer.
+	sta.q (sp+25), y; Set the size of the current block, to the new size.
+@rmerge2:
+	ldy #fblk.next	; Get the next right pointer.
+	lda.q (sp+9), y	;
+	sta.q (sp+25), y; Set the next block, to the next right pointer.
+	sta.q sp+17	; Save the next block in the second local variable.
+	ora.d sp+21	; Is the next block NULL?
+	beq @setheapl	; Yes, so set the last block.
+@setprev:
+	lda.q sp+25	; Get the current block.
+	ldy #fblk.prev	; Set the previous block to the current block.
+	sta.q (sp+17), y;
+	bra @chklmerge	; Do the left block merge.
+@setheapl:
+	lda.q sp+25	; Get the current block.
+	sta.q heapl	; Set the last block to the current block.
+	bra @chklmerge	; Do the left block merge.
+@normerge:
+	lda.q sp+9	; Get the right pointer.
+	ldy #fblk.next	; Set the next block to the right pointer.
+	sta.q (sp+25), y;
+	lda.q sp+25	; Get the current block.
+	ldy #fblk.prev	; Set the previous right pointer to the current block.
+	lda.q (sp+9), y	;
+@chklmerge:
+	lda.q sp+1	; Get the left pointer.
+	ora.d sp+5	; Is the left pointer NULL?
+	bne @chklmerge2	; No, so keep checking.
+@newstart:
+	ldy #fblk.prev	; Clear the previous block.
+	sta.q (sp+25), y;
+	lda.q sp+25	; Get the current block.
+	sta.q heapf	; Set the first block, to the current block.
+	bra @end2	; We are done.
+@chklmerge2:
+	ldy #fblk.size	; Get the size of the left block.
+	lda.q (sp+1), y	;
+	clc		; Prepare for a non carrying add.
+	adc.q sp+1	; Add the size of the left block, to the left pointer.
+	cmp.q sp+25	; Is the left block adjacent?
+	bne @nolmerge	; No, so don't merge the left block.
+@lmerge:
+	lda.q (sp+1), y	; Get the size of the left block.
+	clc		; Prepare for a non carrying add.
+	ldb.q (sp+25), y; Get the size of the current block.
+	adc b		; Add the size of the left block, with the size of the current block.
+	sta.q (sp+1), y	; Set the size of the left block to the new size.
+@lmerge2:
+	ldy #fblk.next	; Get the next block.
+	lda.q (sp+25), y;
+	sta.q (sp+1), y	; Set the next left pointer, to the next block.
+	sta.q sp+17	; Set the second local variable to the next block.
+	ora.d sp+21	; Is the next left pointer NULL?
+	beq @newlast	; Yes, so set the last block.
+@lprev:
+	lda.q sp+1	; Get the left pointer.
+	ldy #fblk.prev	; Set the next left pointer's previous pointer to the left pointer.
+	sta.q (sp+17), y;
+	bra @end2	; We are done.
+@newlast:
+	lda.q sp+1	; Get the left pointer.
+	sta.q heapl	; Set the last block, to the left pointer.
+	bra @end2	; We are done.
+@nolmerge:
+	lda.q sp+25	; Get the current block.
+	ldy #fblk.next	; Set the next left pointer, to the current block.
+	sta.q (sp+1), y	;
+@nolmerge2:
+	lda.q sp+1	; Get the left pointer.
+	ldy #fblk.prev	; Set the previous block, to the left pointer.
+	sta.q (sp+25), y;
+@end2:
+	ads #$20	; Clean up the stack frame.
+	ply.q		; Restore Y.
+	plb.q		; Restore B.
+	pla.q		; Restore A.
+	rts		; End of free.
+
+a
+q
diff --git a/programs/sub-suite/lexer.s b/programs/sub-suite/lexer.s
index b2850aa..0d712ff 100644
--- a/programs/sub-suite/lexer.s
+++ b/programs/sub-suite/lexer.s
@@ -65,7 +65,7 @@ lex:
 ;@nextlline:
 ;	ldb #1		; No, so set the second pointer to the last line.
 ;	jsr set_ptr	;
-;	ldy #ln.next	; Set the next last line to the current line.
+;	ldy #line.next	; Set the next last line to the current line.
 ;	lda.q cline	;
 ;	sta.q (ptr2), y	;
 ;	bra @initline	; Initialize the line.
@@ -76,11 +76,11 @@ lex:
 ;	ldb #1		; Set the second pointer to the current line.
 ;	jsr set_ptr	;
 ;	and #0		; Reset A.
-;	ldy #ln.next	; Reset the next line.
+;	ldy #line.next	; Reset the next line.
 ;	sta.q (ptr2), y	;
-;	ldy #ln.tok	; Reset the token.
+;	ldy #line.tok	; Reset the token.
 ;	sta.q (ptr2), y	;
-;	ldy #ln.bline	; Reset the number of blank lines.
+;	ldy #line.bline	; Reset the number of blank lines.
 ;	sta.w (ptr2), y	;
 ;	tay		; Reset Y.
 @loop:
@@ -225,11 +225,10 @@ ptok_dot:
 	beq @found	; Yes, so create a new token.
 	inc idx1	; No, so increment the directive ID.
 @getlen:
+	mov d, a	; Get the string.
 	jsr strlen	; Get the string's length.
 	inc		; Add one to the length.
-	clc		; Prepare for a non carrying add.
-	adc.w idx2	; Add the string offset to the current length
-	sta.w idx2	; Save the offset in the third index.
+	add.w idx2, a	; Add the string offset to the current length
 	bra @dir_loop	; Keep looping.
 @found:
 	lda #TOK_DIR	; Set the lexeme type to TOK_DIR.
@@ -443,11 +442,10 @@ ptok_alph:
 	beq @found	; Yes, so create a new token.
 	inc idx1	; No, so increment the instruction ID.
 @offset:
+	mov d, a	; Get the string.
 	jsr strlen	; Get the string's length.
 	inc		; Add one to the length.
-	clc		; Prepare for a non carrying add.
-	adc.w idx2	; Add the string offset to the current length
-	sta.w idx2	; Save the offset in the third index.
+	add.w idx2, a	; Add the string offset to the current length
 	bra @isop_loop	; Keep looping.
 @found:
 	lda #TOK_MNE	; Set the lexeme type to TOK_MNE.
diff --git a/programs/sub-suite/libc.s b/programs/sub-suite/libc.s
index ae35146..53e936a 100644
--- a/programs/sub-suite/libc.s
+++ b/programs/sub-suite/libc.s
@@ -17,12 +17,10 @@ strtoull:
 	pla		; Get the character back.
 	beq @end	; No, so we're done.
 @alpha:
-	sec		; Yes, so prepare for a non borrowing subtract.
-	sbc #'a'-10	; Get the numeric value from this digit.
+	sub #'a'-10	; Yes, so get the numeric value from this digit.
 	bra @chkbase	; Check if the value matches the base.
 @digit:
-	sec		; Prepare for a non borrowing subtract.
-	sbc #'0'	; Get the numeric value from this digit.
+	sub #'0'	; Get the numeric value from this digit.
 @chkbase:
 	cmp sp+25	; Does the value match the base?
 	bcs @end	; No, so we're done.
@@ -30,8 +28,7 @@ strtoull:
 	tab		; Save the digit value.
 	lda.q sp+1	; Get the value from the value buffer.
 	mul sp+25	; Multiply the value by the base.
-	clc		; Prepare for a non carrying add.
-	adc b		; Add the digit value to the total value.
+	add a, b	; Add the digit value to the total value.
 	sta.q sp+1	; Place the value in the value buffer.
 	iny		; Increment the string index.
 	and #0		; Reset A.
@@ -44,80 +41,72 @@ strtoull:
 
 
 strlen:
-	phy.q		; Preserve Y.
-	pha.q		; Set the temp variable to the argument.
 	and #0		; Reset A.
-	tay		; Reset Y.
 @loop:
-	lda (sp+1), y	; Are we at the end of the string?
-	beq @end	; Yes, so we're done.
-	iny		; No, so increment the index.
-	bra @loop	; Keep looping.
+	inc		; Increment the index.
+	cmp (d+a-1), #0	; Are we at the end of the string?
+	bne @loop	; No, so keep looping.
 @end:
-	pla.q		; Get the argument back.
-	tya		; Get the return value.
-	ply.q		; Get the preserved value back.
+	dec		; Decrement the length to not include the terminator.
 	rts		; End of strlen.
 
 
 strcmp:
-	ldb #0		; Reset B.
-	tba		; Reset A.
+	phb.q		; Preserve B.
+	phx.q		; Preserve X.
 	phy.q		; Preserve Y.
+	and #0		; Reset A.
+	tab		; Reset B.
+	tax		; Reset X.
 	tay		; Reset Y.
 @loop:
-	ldb #0		; Set the islong flag to false.
-	lda (sp+25), y	; Are we at the end of the first string?
+	ldx #0		; Set the islong flag to false.
+	mov a, (d+y)	; Are we at the end of the first string?
 	beq cmpr	; Yes, so check if we're too short, or too long.
-	ldb #1		; No, so set the islong flag to true.
-	cmp (sp+19), y	; Is the character of both strings, the same?
+	ldx #1		; No, so set the islong flag to true.
+	cmp a, (s+y)	; Is the character of both strings, the same?
 	bne cmpr	; No, so check if we're too short, or too long.
 	iny		; Yes, so increment the index.
 	bra @loop	; Keep looping.
 
-strccmp:
 strcasecmp:
-	ldb #0		; Reset B.
-	tba		; Reset A.
+	phb.q		; Preserve B.
+	phx.q		; Preserve X.
 	phy.q		; Preserve Y.
+	and #0		; Reset A.
+	tab		; Reset B.
+	tax		; Reset X.
+	inx		; Set X to 1.
 	tay		; Reset Y.
 @loop:
-	ldb #0		; Set the islong flag to false.
-	lda (sp+25), y	; Are we at the end of the first string?
+	dex		; Set the islong flag to false.
+	mov a, (d+y)	; Are we at the end of the first string?
 	beq cmpr	; Yes, so check if we're too short, or too long.
-	ldb #1		; No, so set the islong flag to true.
+	inx		; No, so set the islong flag to true.
 	jsr tolower	; Convert the character of string 1 to lowercase.
-	phb		; Preserve the islong flag.
-	pha		; Preserve the converted character.
-	lda (sp+19), y	; Get the character of the second string.
+	tab		; Save the converted character.
+	mov a, (s+y)	; Get the character of the second string.
 	jsr tolower	; Convert the character of string 2 to lowercase.
-	tab		; Place it in B.
-	pla		; Get the character of string 1 back.
 	cmp b		; Is the character of both strings, the same?
-	plb		; Get the islong flag back.
 	bne cmpr	; No, so check if we're too short, or too long.
 	iny		; Yes, so increment the index.
 	bra @loop	; Keep looping.
 
 cmpr:
-	lda (sp+17), y	; Are we at the end of the second string?
+	mov a, (s+y)	; Are we at the end of the second string?
 	beq @islong	; Yes, so check the islong flag.
 @isshort:
-	lda (sp+25), y	; No, but are we at the end of the first string?
-	beq @short	; Yes, so return -1.
-@islong:
-	cpb #1		; Is the islong flag true?
-	bne @equ	; No, so return 0.
-@long:
-	lda #1		; Yes, so return 1.
+	mov a, (d+y)	; No, but are we at the end of the first string?
+	bne @islong	; No, so check if the islong flag is true.
+	lda #$FF	; Yes, so return -1.
 	bra @end	; We are done.
-@equ:
-	lda #0		; Return 0.
-	bra @end	; We are done.
-@short:
-	lda #$FF	; Return -1.
+@islong:
+	cpx #1		; Is the islong flag true?
+	set a, eq	; Return true if it is.
 @end:
-	ply.q		; Get the preserved value back.
+	ply.q		; Restore Y.
+	plx.q		; Restore X.
+	plb.q		; Restore B.
 	rts		; End of cmpr.
 
 
@@ -195,304 +184,226 @@ toupper:
 
 
 ; malloc: Dynamically allocate memory.
-; Input: A = size in bytes to allocate.
+; Input: D = size in bytes to allocate.
 ; Output: A = Pointer to allocated memory.
-; Caller preserved registers: none.
-; Callie preserved registers: Y.
+; Caller preserved registers: D.
+; Callie preserved registers: B, X, Y.
 
 malloc:
-	phy.q		; Preserve Y.
-	pha.q		; Preserve the size.
-	and #0		; Reset A.
-	tay		; Reset Y.
-	sbs #$10	; Allocate 2 local variables onto the stack.
-	lda.q sp+17	; Get the size.
-	ora.d sp+21	; Is the size zero?
-	beq @end	; Yes, so we're done.
-	lda.q sp+17	; No, so get back the size.
-	clc		; Prepare for a non carrying add.
-	adc #ublk	; Add the size of a used block struct, to the size.
-	sta.q sp+17	; Set the actual size.
-	lda.q heapf	; Get the first heap entry.
-	sta.q sp+9	; Save it in the second local variable.
-	bra @checkblk	; Check the block.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	phy.q			; Preserve Y.
+	xor b, b		; Reset B.
+	mov x, b		; Reset X.
+	txy			; Reset Y.
+	mov a, d		; Get the size.
+	beq @end		; The size is zero, so we're done.
+	add #ublk		; Add the size of a used block struct, to the size.
+	cmp #ublk		; Is the total size smaller than the size of a used block struct?
+	bcs @getheapf		; No, so get the first heap entry.
+@toosmall:
+	lda #ublk		; Yes, so set the total size to the size of a used block struct.
+@getheapf:
+	mov d, a		; Place the new size into the passed size.
+	ldb.q heapf		; Get the first heap entry.
+	bra @checkblk		; Check the block.
 @findfblk:
-	ldy #fblk.size	; Get the size of this free block.
-	lda.q (sp+9), y	;
-	sec		; Prepare for a non borrowing subtract.
-	sbc.q sp+17	; Subtract the size of this free block, with the passed size.
-	bcs @blkfound	; The result is less than, or equal to the free size, so return the found block.
-	ldy #fblk.next	; Get the next free block.
-	lda.q (sp+9), y	;
-	sta.q sp+9	; Set the current free block, to the next free block.
+	mov.q a, (b+fblk.size)	; Get the size of this free block.
+	sub a, d		; Subtract the size of this free block, with the passed size.
+	bcs @blkfound		; The result is less than, or equal to the free size, so return the found block.
+	mov.q b, (b+fblk.next)	; Set the current free block, to the next free block.
 @checkblk:
-	ora.d sp+13	; Is the address of this block, zero?
-	bne @findfblk	; No, so keep looping.
-	lda.q heapptr	; Yes, so get the current top of the heap.
-	clc		; Prepare for a non carrying add.
-	adc.q sp+17	; Add the top of the heap, with the passed size.
-	bcs @outofspace	; The result overflowed, so return zero.
-	cmp.q heapend	; Is the top of the heap, less than, or equal to the max heap size?
-	bcc @inctop	; Yes, so increase the current top of the heap.
-	beq @inctop	;
+	bne @findfblk		; The address of this block is non NULL, so keep looping.
+	mov a, d		; Get the passed size.
+	add.q heapptr		; Add the top of the heap, with the passed size.
+;	mov d, a		; Save the new size.
+	bcs @outofspace		; The result overflowed, so return zero.
+	cmp.q heapend		; Is the top of the heap, less than, or equal to the max heap size?
+	bcc @inctop		; Yes, so increase the current top of the heap.
+	beq @inctop		;
 @outofspace:
-	and #0		; Return zero.
-	bra @end	; We are done.
+	and #0			; Return zero.
+	bra @end		; We are done.
 @inctop:
-	pha.q		; Preserve heapptr + size.
-	lda.q heapptr	; Get the previous top of the heap.
-	sta.q sp+17	; Set the current free block to the previous top of the heap.
-	pla.q		; Restore heapptr + size.
-	sta.q heapptr	; Increment the current top of the heap by the passed size.
-	bra @setsize	; Set the size, and start address into the used space of the block.
+
+	ldb.q heapptr		; Set the current free block to the previous top of the heap.
+	sta.q heapptr		; Increment the current top of the heap by the passed size.
+	bra @setsize		; Set the size, and start address into the used space of the block.
 @blkfound:
-	bne @sliceblk	; The block is big enough to slice.
-	cmp #fblk	; Is the block big enough to slice?
-	bcs @sliceblk	; Yes, so slice the block.
-	ldy #fblk.prev	; No, so get the previous free block.
-	lda.q (sp+9), y	;
-	sta.q sp+1	; Set the third local variable, to the previous free block.
-	ora.d sp+5	; Is the previous block, set to zero?
-	beq @setheapf	; Yes, so set the first block.
-	ldy #fblk.next	; No, so get the next free block.
-	lda.q (sp+9), y	;
-	sta.q (sp+1), y	; Set the previous block's next block, to the next block.
-	bra @chknxtblk	; Check the next block.
+	bne @sliceblk		; The block is big enough to slice.
+	cmp #fblk		; Is the block big enough to slice?
+	bcs @sliceblk		; Yes, so slice the block.
+	mov.q x, (b+fblk.prev)	; Get the previous free block.
+	beq @setheapf		; The previous block is NULL, so set the first block.
+	ldy #fblk.next		; No, so set the offset to the next free block.
+	mov.q (x+y), (b+y)	; Set the previous block's next block, to the next block.
+	bra @chknxtblk		; Check the next block.
 @setheapf:
-	lda.q (sp+9), y	; Get the next block.
-	sta.q heapf	; Set the first heap entry to it.
+	ldy #fblk.next		; Set the offset to the next block.
+	mov.q heapf, (b+y)	; Set the first heap entry to the next block.
 @chknxtblk:
-	lda.q (sp+9), y	; Get the next free block.
-	sta.q sp+1	; Set the third local variable to the next free block.
-	ora.d sp+5	; Is the next block, zero?
-	beq @setheapl	; Yes, so set the least heap entry.
-	ldy #fblk.prev	; No, so get the current previous block.
-	lda.q (sp+9), y	;
-	sta.q (sp+1), y	; Set the next block's previous block to the current previous block.
-	bra @retptr	; Return the pointer.
+	mov.q x, (b+y)		; Get the next free block.
+	beq @setheapl		; The next block is NULL, so set the least heap entry.
+	ldy #fblk.prev		; Get the current previous block.
+	mov.q (x+y), (b+y)	; Set the next block's previous block to the current previous block.
+	bra @retptr		; Return the pointer.
 @setheapl:
-	ldy #fblk.prev	; Get the current previous block.
-	lda.q (sp+9), y	;
-	sta.q heapl	; Set the last heap entry to the current previous block.
-	bra @retptr	; Return the pointer.
+	ldy #fblk.prev		; Get the current previous block.
+	mov.q heapl, (b+y)	; Set the last heap entry to the current previous block.
+	bra @retptr		; Return the pointer.
 @sliceblk:
-	ldy #fblk.size	; Get the size of the current block.
-	lda.q (sp+9), y	;
-	sec		; Prepare for a non borrowing subtract.
-	sbc.q sp+17	; Subtract the current block's size from the passed size.
-	sta.q (sp+9), y	; Set the current block's size to the subtracted size.
-	clc		; Prepare for a non carrying add.
-	adc.q sp+9	; Add the current block's size to the pointer of the current block.
-	sta.q sp+9	; Set the current block to the space above it (return value).
+	ldy #fblk.size		; Get the size of the current block.
+	sub.q (b+y), d		; Subtract the current block's size from the passed size.
+	add.q b, (b+y)		; Add the current block's size to the pointer of the current block.
 @setsize:
-	ldy #ublk.size	; Start setting the used block's size, to the passed size.
-	lda.q sp+17	; Get the passed size.
-	sta.q (sp+9), y	; Set the used block's size to the passed size.
+	mov.q (b+ublk.size), d	; Set the used block's size to the passed size.
 @retptr:
-	ldy #ublk.start	; Start setting the used block's starting address, to the used block.
-	lda.q sp+9	; Get the used block.
-	sta.q (sp+9), y	; Set the used block's starting address, to the used block.
-	clc		; Prepare for a non carrying add.
-	adc #ublk	; Return the pointer to the real memory block.
+	mov.q (b+ublk.start), b	; Set the used block's starting address, to the used block.
+	add b, #ublk		; Get the pointer to the real memory block.
+	tba			; Return the pointer to the real memory block.
 @end:
-	ads #$18	; Clean up the stack frame.
-	ply.q		; Restore Y.
-	rts		; End of malloc.
+	ply.q			; Restore Y.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	rts			; End of malloc.
 
 
 ; free: Free allocated memory.
-; Input: A = Pointer to allocated memory.
+; Input: D = Pointer to allocated memory.
 ; Output: none.
-; Caller preserved registers: none.
-; Callie preserved registers: A, B, Y.
+; Caller preserved registers: D.
+; Callie preserved registers: A, B, X, Y, E.
 
 free:
-	pha.q		; Preserve A.
-	phb.q		; Preserve B.
-	phy.q		; Preserve Y.
-	pha.q		; Push the pointer argument to the stack.
-	and #0		; Reset A.
-	tay		; Reset Y.
-	sbs #$18	; Allocate 3 local variables onto the stack.
-	lda.q sp+25	; Get the passed pointer.
-	ora.d sp+29	; Is the passed pointer NULL?
-	bne @getrealblk	; No, so get the real block.
-	bra @end	; Yes, so we're done.
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	phy.q			; Preserve Y.
+	phe.q			; Preserve E.
+	and #0			; Reset A.
+	tab			; Reset B.
+	tax			; Reset X.
+	tay			; Reset Y.
+	mov a, d		; Get the passed pointer.
+	bne @getrealblk		; The pointer isn't NULL, so get the real block.
+	bra @end		; The pointer is NULL, so we're done.
 @getrealblk:
-	lda.q sp+25	; Get the passed pointer.
-	sec		; Prepare for a non borrowing subtract.
-	sbc #8		; Move the passed pointer back by one.
-	sta.q sp+25	; Set the first local variable to the start of the used block.
-	lda.q (sp+25)	; Get the real block address.
-	sta.q sp+25	; Set the passed pointer to the start of the real block.
-	ldy #ublk.size	; Get the size of the real block.
-	lda.q (sp+25), y;
-	sta.q sp+17	; Save the size of the real block.
-	clc		; Prepare for a non carrying add.
-	adc.q sp+25	; Add the size of the real block with the start of the real block.
-	cmp.q heapptr	; Is this block on top of the heap?
-	bne @heapadd	; No, so add it to the free block list.
+	sub #8			; Get the start of the used block.
+	mov.q a, (a)		; Get the start of the real block.
+	mov.q b, (a+ublk.size)	; Get the size of the real block.
+	lea e, (a+b)		; Add the size of the real block with the start of the real block.
+	cpe.q heapptr		; Is this block on top of the heap?
+	bne @heapadd		; No, so add it to the free block list.
 @dectop:
-	lda.q sp+25	; Get the block.
-	sta.q heapptr	; Set the top of the heap to it.
+	sta.q heapptr		; Set the top of the heap to the start of the current real block.
 @chklastblk:
-	lda.q heapl	; Get the last free list entry.
-	sta.q sp+17	; Copy it into the second local variable.
-	ora.d sp+21	; Is the free list empty?
-	beq @end	; Yes, so we're done.
-	lda.q sp+17	; No, so Get the last free list entry.
-	ldy #fblk.size	; Get the size of the block.
-	lda.q (sp+17), y;
-	clc		; Prepare for a non carrying add.
-	adc.q sp+17	; Add the size of the block, with the address of the block entry.
-	cmp.q heapptr	; Is the last block on top of the heap?
-	bne @end	; No, so we're done.
+	ldb.q heapl		; Get the last free list entry.
+	beq @end		; The free list is empty, so we're done.
+	ldy #fblk.size		; Get the size of the block.
+	mov.q a, (b+fblk.size)	; Get the size of the block.
+	lea e, (a+b)		; Add the size of the block, with the address of the block entry.
+	cpe.q heapptr		; Is the last block on top of the heap?
+	bne @end		; No, so we're done.
 @delblk:
-	lda.q sp+17	; Yes, so remove the last block.
-	sta.q heapptr	;
+	stb.q heapptr		; Yes, so remove the last block.
 @correctblk:
-	ldy #fblk.prev	; Get the previous block.
-	lda.q (sp+17), y;
-	sta.q sp+25	; Save the previous block for now.
-	sta.q heapl	; Set the last block to the previous block.
-	ora.d sp+29	; Is the previous block non NULL?
-	bne @delnxtblk	; Yes, so delete the next block.
-	sta.q heapf	; No, so empty the free list.
-	bra @end	; We are done.
+	mov.q a, (b+fblk.prev)	; Get the previous block.
+	sta.q heapl		; Set the last block to the previous block.
+	bne @delnxtblk		; The previous block isn't NULL, so delete the next block.
+	sta.q heapf		; The previous block is NULL, so empty the free list.
+	bra @end		; We are done.
 @delnxtblk:
-	and #0		; Reset A.
-	ldy #fblk.next	; Delete the next block.
-	sta.q (sp+25), y;
+	lea e, (a+fblk.next)	; Delete the next block.
+	stz.q (e)		;
 @end:
-	ads #$20	; Clean up the stack frame.
-	ply.q		; Restore Y.
-	plb.q		; Restore B.
-	pla.q		; Restore A.
-	rts		; End of free.
+	ple.q			; Restore E.
+	ply.q			; Restore Y.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of free.
 
 
 @heapadd:
-	lda.q heapf	; Get the first block.
-	sta.q sp+9	; Copy it into the third local variable.
-	ora.d sp+13	; Is the free list empty?
-	bne @srchflst	; No, so start searching the free list.
+	ldy.q heapf		; Get the first block.
+	bne @srchflst		; The Free list isn't empty, so start searching the free list.
 @empty:
-	ldy #fblk.next	; Clear the next block.
-	sta.q (sp+25), y;
-	ldy #fblk.prev	; Clear the previous block.
-	sta.q (sp+25), y;
-	lda.q sp+25	; Reset A.
-	sta.q heapf	; Clear the first block entry.
-	sta.q heapf	; Clear the last block entry.
-	bra @end	; We are done.
+	mov.q (a+fblk.next), y	; Clear the next block.
+	mov.q (a+fblk.prev), y	; Clear the previous block.
+	sta.q heapf		; Set the first block entry to the current block.
+	sta.q heapl		; Set the last block entry to the current block.
+	bra @end		; We are done.
 @srchflst:
-	and #0		; Reset A.
-	sta.q sp+1	; Reset the left pointer.
-	ldy #fblk.next	; Setup for the loop.
 @loop:
-	lda.q sp+9	; Get the right pointer.
-	cmp.q sp+25	; Is the right pointer at, or below the current block?
-	beq @nextright	; Yes, so get the next right pointer.
-	bcs @chkrmerge	; No, so do the right block merge.
+	cmp y, a		; Is the right pointer at, or below the current block?
+	beq @nextright		; Yes, so get the next right pointer.
+	bcs @chkrmerge		; No, so do the right block merge.
 @nextright:
-	sta.q sp+1	; Set the left pointer, to the right pointer.
-	lda.q (sp+9), y	; Get the next right pointer.
-	sta.q sp+9	; Set the current right pointer to the next right pointer.
-	ora.d sp+13	; Is the next right pointer NULL?
-	bne @loop	; No, so keep looping.
+	tyx			; Set the left pointer, to the right pointer.
+	mov.q y, (y+fblk.next)	; Set the current right pointer to the next right pointer.
+	bne @loop		; The next right pointer isn't NULL, so keep looping.
 @st_lmerge2:
-	sta.q (sp+25), y; Clear the next block.
-	lda.q sp+25	; Get the current block.
-	sta.q heapl	; Set the last free block entry to it.
-	bra @chklmerge2	; Do the left block merge.
+	mov.q (a+fblk.next), y	; Clear the next block.
+	sta.q heapl		; Set the last free block entry to it.
+	bra @chklmerge2		; Do the left block merge.
 @chkrmerge:
-	lda.q sp+25	; Get the current block.
-	clc		; Prepare for a non carrying add.
-	adc.q sp+17	; Add the size of the current block, to the current block.
-	cmp.q sp+9	; Is the right pointer NULL?
-	bne @normerge	; No, so don't merge the right block.
+	lea e, (a+b)		; Add the size of the current block, to the current block.
+	cmp e, y		; Is the current block the same as the right block?
+	bne @normerge		; No, so don't merge the right block.
 @rmerge:
-	ldy #fblk.size	; Get the size of the right pointer.
-	lda.q sp+17	; Get the size of the current block.
-	clc		; Prepare for a non carrying add.
-	adc.q (sp+9), y	; Add the size of the current block, with the size of the right pointer.
-	sta.q (sp+25), y; Set the size of the current block, to the new size.
+	mov e, b		; Get the size of the current block.
+	add.q e, (y+fblk.size)	; Add the size of the current block, with the size of the right pointer.
+	mov.q (a+fblk.size), e	; Set the size of the current block, to the new size.
 @rmerge2:
-	ldy #fblk.next	; Get the next right pointer.
-	lda.q (sp+9), y	;
-	sta.q (sp+25), y; Set the next block, to the next right pointer.
-	sta.q sp+17	; Save the next block in the second local variable.
-	ora.d sp+21	; Is the next block NULL?
-	beq @setheapl	; Yes, so set the last block.
+	lea fblk.next		; Get the next right pointer.
+	mov.q (a+e), (y+e)	; Set the next block, to the next right pointer.
+	mov.q b, (y+e)		; Save the next block.
+	beq @setheapl		; The next block is NULL, so set the last block.
 @setprev:
-	lda.q sp+25	; Get the current block.
-	ldy #fblk.prev	; Set the previous block to the current block.
-	sta.q (sp+17), y;
-	bra @chklmerge	; Do the left block merge.
+	mov.q (b+fblk.prev), a	; Set the previous block to the current block.
+	bra @chklmerge		; Do the left block merge.
 @setheapl:
-	lda.q sp+25	; Get the current block.
-	sta.q heapl	; Set the last block to the current block.
-	bra @chklmerge	; Do the left block merge.
+	sta.q heapl		; Set the last block to the current block.
+	bra @chklmerge		; Do the left block merge.
 @normerge:
-	lda.q sp+9	; Get the right pointer.
-	ldy #fblk.next	; Set the next block to the right pointer.
-	sta.q (sp+25), y;
-	lda.q sp+25	; Get the current block.
-	ldy #fblk.prev	; Set the previous right pointer to the current block.
-	lda.q (sp+9), y	;
+	mov.q (a+fblk.next), y	; Set the next block to the right pointer.
+	mov.q (y+fblk.prev), a	; Set the previous right pointer to the current block.
 @chklmerge:
-	lda.q sp+1	; Get the left pointer.
-	ora.d sp+5	; Is the left pointer NULL?
-	bne @chklmerge2	; No, so keep checking.
+	and x, x		; Is the left pointer NULL?
+	bne @chklmerge2		; No, so keep checking.
 @newstart:
-	ldy #fblk.prev	; Clear the previous block.
-	sta.q (sp+25), y;
-	lda.q sp+25	; Get the current block.
-	sta.q heapf	; Set the first block, to the current block.
-	bra @end2	; We are done.
+	mov.q (a+fblk.prev), x	;
+	sta.q heapf		; Set the first block, to the current block.
+	bra @end2		; We are done.
 @chklmerge2:
-	ldy #fblk.size	; Get the size of the left block.
-	lda.q (sp+1), y	;
-	clc		; Prepare for a non carrying add.
-	adc.q sp+1	; Add the size of the left block, to the left pointer.
-	cmp.q sp+25	; Is the left block adjacent?
-	bne @nolmerge	; No, so don't merge the left block.
+	mov.q e, (x+fblk.size)	; Get the size of the left block.
+	add e, x		; Add the size of the left block, to the left pointer.
+	cmp e, a		; Is the left block adjacent?
+	bne @nolmerge		; No, so don't merge the left block.
 @lmerge:
-	lda.q (sp+1), y	; Get the size of the left block.
-	clc		; Prepare for a non carrying add.
-	ldb.q (sp+25), y; Get the size of the current block.
-	adc b		; Add the size of the left block, with the size of the current block.
-	sta.q (sp+1), y	; Set the size of the left block to the new size.
+	lea fblk.size		; Set the offset to the block size.
+	add.q (x+e), (a+e)	; Add the size of the left block, with the size of the current block.
 @lmerge2:
-	ldy #fblk.next	; Get the next block.
-	lda.q (sp+25), y;
-	sta.q (sp+1), y	; Set the next left pointer, to the next block.
-	sta.q sp+17	; Set the second local variable to the next block.
-	ora.d sp+21	; Is the next left pointer NULL?
-	beq @newlast	; Yes, so set the last block.
+	lea fblk.next		; Set the offset to the next block.
+	mov.q (x+e), (a+e)	; Set the next left pointer, to the next block.
+	mov.q b, (a+e)		; Get the next block.
+	beq @newlast		; The next block is NULL, so set the last block.
 @lprev:
-	lda.q sp+1	; Get the left pointer.
-	ldy #fblk.prev	; Set the next left pointer's previous pointer to the left pointer.
-	sta.q (sp+17), y;
-	bra @end2	; We are done.
+	mov.q (b+fblk.prev), x	; Set the next left pointer's previous pointer to the left pointer.
+	bra @end2		; We are done.
 @newlast:
-	lda.q sp+1	; Get the left pointer.
-	sta.q heapl	; Set the last block, to the left pointer.
-	bra @end2	; We are done.
+	stx.q heapl		; Set the last block, to the left pointer.
+	bra @end2		; We are done.
 @nolmerge:
-	lda.q sp+25	; Get the current block.
-	ldy #fblk.next	; Set the next left pointer, to the current block.
-	sta.q (sp+1), y	;
+	mov.q (x+fblk.next), a	; Set the next left pointer, to the current block.
 @nolmerge2:
-	lda.q sp+1	; Get the left pointer.
-	ldy #fblk.prev	; Set the previous block, to the left pointer.
-	sta.q (sp+25), y;
+	mov.q (a+fblk.prev), x	; Set the previous block, to the left pointer.
 @end2:
-	ads #$20	; Clean up the stack frame.
-	ply.q		; Restore Y.
-	plb.q		; Restore B.
-	pla.q		; Restore A.
-	rts		; End of free.
+	ple.q			; Restore E.
+	ply.q			; Restore Y.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of free.
 
 
 ; memcpy: memory to memory copy.
diff --git a/programs/sub-suite/shift_line.c b/programs/sub-suite/shift_line.c
index 255d21b..365666b 100644
--- a/programs/sub-suite/shift_line.c
+++ b/programs/sub-suite/shift_line.c
@@ -24,6 +24,12 @@ uint8_t bitpos(unsigned int row, uint8_t *mask) {
 
 }
 
+uint8_t getbit(unsigned int row, unsigned int offset) {
+	uint8_t mask;
+	uint8_t byte = bitpos(row+offset, &mask);
+	return (bitabl[byte] & mask);
+}
+
 void setbit(unsigned int row) {
 	uint8_t mask;
 	uint8_t byte = bitpos(row, &mask);
@@ -48,7 +54,7 @@ void shift_line(char *str, int cursor, int left) {
 	if (left) {
 		int i = end-1;
 		int j = end;
-		for (; i > cursor; i--, j--) {
+		for (; i >= cursor; i--, j--) {
 			if (i < 0) {
 				i = 0;
 				str[i] = 0;
@@ -72,7 +78,7 @@ void shift_line(char *str, int cursor, int left) {
 			str[i] = 0;
 		}
 		end = find_end(str, i);
-		if ((end % maxcol) == 0 && (end/maxcol) > scr_row) {
+		if (((end-1) % maxcol) == 0 && ((end-1)/maxcol) > scr_row) {
 			clrbit(end/maxcol);
 		}
 	}
diff --git a/programs/sub-suite/subasm-syntax b/programs/sub-suite/subasm-syntax
new file mode 100644
index 0000000..1337914
--- /dev/null
+++ b/programs/sub-suite/subasm-syntax
@@ -0,0 +1,56 @@
+/* Assembly language syntax for SuBAsm. */
+
+/* Comments begin with "/*", and end with "*/".
+ * Directives begin with a `\`.
+ */
+
+/* mnemonic is the instruction name/mnemonic.
+ * expr is an expression.
+ * Indirect Indexed means applying the index after the indirection.
+ * Indexed Indirect means applying the index before the indirection.
+ */
+
+Expression syntax:
+	/* TODO */
+Instruction syntax:
+	Base ISA, and Base Extension:
+		Implied:
+			<mnemonic>
+		B register:
+			<mnemonic> b
+		Absolute/Zero Matrix:
+			/* [, <x|y>] means Indexed with x, or y. */
+			<mnemonic> <expr>[, <x|y>]
+		Immediate Data:
+			<mnemonic> #<expr>
+		Absolute/Zero Matrix Indirect:
+			/* Indexing with x means Indexed Indirect.
+			 * Indexing with y means Indirect Indexed.
+			 */
+			<mnemonic> (<expr>[, x])[, y]
+		E Indirect:
+			<mnemonic> (e)
+	Orthogonal Extension:
+		<mnemonic> <operand>[, operand]
+		Operand syntax:
+			<\(
+				/* The operand starts with a register.
+				 * If the statment is inside brackets, then
+				 * it's a register indirect mode.
+				 */
+				[(]reg[+<reg>][\(+|-\)<expr>][)]
+				/* The operand starts with an expression.
+				 * If the statment is inside brackets, then
+				 * it's an indirect mode.
+				 */
+				|[(]expr
+				/* Is the operand using Indirect, or Indirect Indexed? */
+				\if (ind || ind_indexed) {
+					[)]
+				\}
+				[\(+|-\)<reg[+<reg>]>]
+				/* Is the operand using Indexed Indirect? */
+				\if (indexed_ind) {
+					[)]
+				\}
+			\)>
diff --git a/programs/sub-suite/subasm.s b/programs/sub-suite/subasm.s
index 80aaa47..f22ee60 100644
--- a/programs/sub-suite/subasm.s
+++ b/programs/sub-suite/subasm.s
@@ -3,153 +3,260 @@
 ;
 ; by mr b0nk 500 <b0nk@b0nk.xyz>
 
+;subasm:
+;	ldb #0		; Set the first pointer
+;	lda.q cmd_buf	; to the command buffer.
+;	jsr set_ptr	;
+;	tba		; Reset A.
+;	tax		; Reset X.
+;	jsr chk_shcmd	; Did we get a shortend command?
+;	bne @cmd	; Yes, so skip everything else.
+;	jsr chk_cmd	; No, but did we get a full command?
+;	bne @cmd	; Yes, so skip everything else.
+;	jsr lex		; No, so start lexing this line.
+;	bra @end	; We are done.
+;@cmd:
+;	lda regf	; Get the command ID.
+;	cmp #8		; Is the command ID greater than the command count?
+;	bcs @end	; Yes, so we're done.
+;	lsl #1		; No, so multiply the command ID by two.
+;	phx.q		; Preserve X.
+;	tax             ; Set the index to the offset that we just calculated.
+;	lea.w (cmd_srt, x); Get the pointer, from the command subroutine table.
+;	plx.q		; Restore X.
+;	and #0		; Reset A.
+;	tab		; Reset B.
+;	jsr (e)		; Run the command's subroutine.
+;@end:
+;	and #0		; Reset A.
+;	jsr update_ptr	; Get the screen buffer index.
+;	tay		; Save it in Y.
+;	and #0		; Reset A.
+;	rts		; End of subasm.
+;
+;chk_shcmd:
+;	and #0		; Reset A.
+;	tab		; Reset B.
+;;	inb		; Set the second pointer
+;;	lda.w #sh_cmds	; to the shortend command table.
+;;	jsr set_ptr	;
+;;	deb		; Reset B.
+;;	tba		; Reset A.
+;	lea sh_cmds	; Get the address of the short command table.
+;	phy.w		; Preserve the screen buffer position.
+;	txy		; Set our index to zero.
+;	lda (ptr), y	; Is there nothing in the command buffer?
+;	beq @false	; Yes, so return that we failed.
+;	cmp #' '	; No, but is this character, a space?
+;	beq @false	; Yes, so return that we failed.
+;	jsr tolower	; No, so convert it to lowercase.
+;@loop:
+;;	ldb (ptr2), y	; Are we at the end of the table?
+;	ldb (e)		; Are we at the end of the table?
+;	beq @false	; Yes, so return that we failed.
+;	cmp b		; No, so did the character match?
+;	beq @found	; Yes, so check if there are any arguments.
+;	ine		; No, so check the next command.
+;	iny		;
+;	bra @loop	; Keep looping.
+;@found:
+;	sty regf	; Save the command ID.
+;	lea (ptr)	; Get the address of the next character.
+;	ine		;
+;;	ldy #1		; Check the next character in the command buffer.
+;;	lda (ptr), y	; Is this the end of the buffer?
+;	lda (e)		; Is this the end of the buffer?
+;	beq @true	; Yes, so return true.
+;	cmp #' '	; No, but is this a space?
+;	beq @true	; Yes, so return true.
+;@false:
+;	ldb #0		; Reset B.
+;	tba		; Return false.
+;	tax		; Reset X.
+;	bra @end	; We are done.
+;@true:
+;	lda #1		; Return true.
+;@end:
+;	ply.w		; Get back the screen buffer position.
+;	rts		; End of chk_shcmd.
+;
+;
+;chk_cmd:
+;	and #0		; Reset A.
+;	tab		; Reset B.
+;	tax		; Reset X.
+;	sta.q idx0	; Reset the first index.
+;	sta.q idx1	; Reset the second index.
+;	mov.q ptr, d	; Set the first pointer to the command buffer.
+;@loop:
+;	lda.w #cmds	; Get pointer to the start of the command table.
+;	add.w idx0	; Offset the pointer, by the length of the previous string.
+;	pha.q		; Preserve the command string pointer.
+;	jsr strcaseg	; Is the command buffer, the same as the command string?
+;	pla.q		; Get the command string pointer back.
+;	beq @true	; Yes, so return true.
+;	ldb idx1	; No, so Get the command ID.
+;	cpb #7		; Have we reached the end of the command table?
+;	beq @false	; Yes, so return false.
+;	inc idx1	; No, so increment the command ID.
+;@getlen:
+;	mov d, a	; Get the string.
+;	jsr strlen	; Get the string's length.
+;	inc		; Add one to the length.
+;	add.w idx0, a	; Add the string offset to the current length
+;	bra @loop	; Keep looping.
+;@true:
+;	ldb idx1	; Get the command ID.
+;	stb regf	; Return the command ID.
+;	ldb #1		; Return true.
+;	bra @end	; We are done.
+;@false:
+;	ldb #0		; Return false.
+;@end:
+;	rts		; End of chk_cmd.
+
+
 subasm:
-	ldb #0		; Set the first pointer
-	lda.q cmd_buf	; to the command buffer.
-	jsr set_ptr	;
-	tba		; Reset A.
-	tax		; Reset X.
-	jsr chk_shcmd	; Did we get a shortend command?
-	bne @cmd	; Yes, so skip everything else.
-	jsr chk_cmd	; No, but did we get a full command?
-	bne @cmd	; Yes, so skip everything else.
-	jsr lex		; No, so start lexing this line.
-	bra @end	; We are done.
+	pha.q			; Preserve A.
+	phe.q			; Preserve E.
+	des			; Make room for the command id.
+	and #0			; Reset A.
+	lea d, (cmd_buf)	; Get the command buffer.
+	lea s, (sp+1)		; Get the pointer to the command id.
+	jsr chk_shcmd		; Did we get a shortend command?
+	bne @cmd		; Yes, so skip everything else.
+	jsr chk_cmd		; No, but did we get a full command?
+	bne @cmd		; Yes, so skip everything else.
+	mov.q ptr, d		;
+	jsr lex			; No, so start lexing this line.
+	bra @end		; We are done.
 @cmd:
-	lda regf	; Get the command ID.
-	cmp #8		; Is the command ID greater than the command count?
-	bcs @end	; Yes, so we're done.
-	lsl #1		; No, so multiply the command ID by two.
-	phx.q		; Preserve X.
-	tax             ; Set the index to the offset that we just calculated.
-	lea.w (cmd_srt, x); Get the pointer, from the command subroutine table.
-	plx.q		; Restore X.
-	and #0		; Reset A.
-	tab		; Reset B.
-	jsr (e)		; Run the command's subroutine.
+	mov s, (s)		; Get the command ID.
+	cmp s, #7		; Is the command ID greater than the command count?
+	bcs @end		; Yes, so we're done.
+	lsl s, #1		; No, so multiply the command ID by two.
+	lea.w e, (cmd_srt+s)	; Get the pointer, from the command subroutine table.
+	and #0			; Reset A.
+	tab			; Reset B.
+	jsr (e)			; Run the command's subroutine.
 @end:
-	and #0		; Reset A.
-	jsr update_ptr	; Get the screen buffer index.
-	tay		; Save it in Y.
-	and #0		; Reset A.
-	rts		; End of subasm.
+	and #0			; Reset A.
+	jsr update_ptr		; Get the screen buffer index.
+	tay			; Save it in Y.
+	ins			; Cleanup the stack frame.
+	ple.q			; Restore E.
+	pla.q			; Restore A.
+	rts			; End of subasm.
+
 
 chk_shcmd:
-	and #0		; Reset A.
-	tab		; Reset B.
-;	inb		; Set the second pointer
-;	lda.w #sh_cmds	; to the shortend command table.
-;	jsr set_ptr	;
-;	deb		; Reset B.
-;	tba		; Reset A.
-	lea sh_cmds	; Get the address of the short command table.
-	phy.w		; Preserve the screen buffer position.
-	txy		; Set our index to zero.
-	lda (ptr), y	; Is there nothing in the command buffer?
-	beq @false	; Yes, so return that we failed.
-	cmp #' '	; No, but is this character, a space?
-	beq @false	; Yes, so return that we failed.
-	jsr tolower	; No, so convert it to lowercase.
+	phb.q			; Preserve B.
+	lea b, sh_cmds		; Get the address of the short command table.
+	mov a, (d)		; Is the string empty?
+	beq @false		; Yes, so return that we failed.
+	cmp #' '		; No, but is this character, a space?
+	beq @false		; Yes, so return that we failed.
+	jsr tolower		; No, so convert it to lowercase.
 @loop:
-;	ldb (ptr2), y	; Are we at the end of the table?
-	ldb (e)		; Are we at the end of the table?
-	beq @false	; Yes, so return that we failed.
-	cmp b		; No, so did the character match?
-	beq @found	; Yes, so check if there are any arguments.
-	ine		; No, so check the next command.
-	iny		;
-	bra @loop	; Keep looping.
+	cmp (b), #0		; Are we at the end of the table?
+	beq @false		; Yes, so return that we failed.
+	cmp a, (b)		; No, so did the character match?
+	beq @found		; Yes, so check if there are any arguments.
+	inb			; No, so check the next command.
+	bra @loop		; Keep looping.
 @found:
-	sty regf	; Save the command ID.
-	lea (ptr)	; Get the address of the next character.
-	ine		;
-;	ldy #1		; Check the next character in the command buffer.
-;	lda (ptr), y	; Is this the end of the buffer?
-	lda (e)		; Is this the end of the buffer?
-	beq @true	; Yes, so return true.
-	cmp #' '	; No, but is this a space?
-	beq @true	; Yes, so return true.
+	sub.w b, #sh_cmds	; Get the command ID.
+	mov (s), b		; Save the command ID.
+	mov a, (d+1)		; Is this the end of the string?
+	beq @true		; Yes, so return true.
+	cmp #' '		; No, but is this a space?
+	beq @true		; Yes, so return true.
 @false:
-	ldb #0		; Reset B.
-	tba		; Return false.
-	tax		; Reset X.
-	bra @end	; We are done.
+	and #0			; Return false.
+	bra @end		; We are done.
 @true:
-	lda #1		; Return true.
+	lda #1			; Return true.
 @end:
-	ply.w		; Get back the screen buffer position.
-	rts		; End of chk_shcmd.
+	plb.q			; Restore B.
+	rts			; End of chk_shcmd.
 
 
 chk_cmd:
-	tba		; Reset A.
-	tax		; Reset X.
-	sta.q idx0	; Reset the first index.
-	sta.q idx1	; Reset the second index.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	phy.q			; Preserve Y.
+	and #0			; Reset A.
+	tab			; Reset B.
+	mov x, s		; Preserve the command ID pointer.
+	mov y, d		; Preserve the string pointer.
+	lea s, cmds		; Get pointer to the start of the command table.
 @loop:
-	lda.w #cmds	; Get pointer to the start of the command table.
-	clc		; Prepare for a non carrying add.
-	adc.w idx0	; Offset the pointer, by the length of the previous string.
-	pha.q		; Preserve the command string pointer.
-	jsr strcaseg	; Is the command buffer, the same as the command string?
-	pla.q		; Get the command string pointer back.
-	beq @true	; Yes, so return true.
-	ldb idx1	; No, so Get the command ID.
-	cpb #7		; Have we reached the end of the command table?
-	beq @false	; Yes, so return false.
-	inc idx1	; No, so increment the command ID.
+	jsr strcasecmp		; Is the command buffer, the same as the command string?
+	beq @true		; Yes, so return true.
+	inb			; No, so increment the command ID.
+	cpb #7			; Have we reached the end of the command table?
+	bcs @false		; Yes, so return false.
 @getlen:
-	jsr strlen	; Get the string's length.
-	inc		; Add one to the length.
-	clc		; Prepare for a non carrying add.
-	adc.w idx0	; Add the string offset to the current length
-	sta.w idx0	; Save the offset in the first index.
-	bra @loop	; Keep looping.
+	mov d, s		; Get the command table string.
+	jsr strlen		; Get the string's length.
+	mov d, y		; Restore the string pointer.
+	inc			; Add one to the length.
+	add s, a		; Add the string offset to the current length
+	bra @loop		; Keep looping.
 @true:
-	ldb idx1	; Get the command ID.
-	stb regf	; Return the command ID.
-	ldb #1		; Return true.
-	bra @end	; We are done.
+	lda #1			; Return true.
+	bra @end		; We are done.
 @false:
-	ldb #0		; Return false.
+	lda #0			; Return false.
 @end:
-	rts		; End of chk_cmd.
+	mov s, x		; Restore the command ID pointer.
+	mov (s), b		; Save the command ID.
+	and a, a		; Set the flags accordingly.
+	ply.q			; Restore Y.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	rts			; End of chk_cmd.
+
 
 viewmem:
-	lda.q prg_cnt	; Get the program counter.
-	sta.q idx0	; Save the address in the first index.
-	and #$F0	; Clear the first four bits of the address.
-	sta idx0	; Overwrite the first byte, with the masked byte.
-	lda #19		; Move the cursor to the right, by 19 columns.
-	sta scr_col	;
-	jsr update_pos	;
-	jsr print_lo	; Print the low nibble offsets.
-	ldx #0		; Reset X.
-	ldb #0		; Reset B.
-	stb idx1	; Reset the byte count.
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	sbs #$50		; Make room for the string buffer.
+	and #0			; Reset A.
+	tab			; Reset B.
+	ldx.q prg_cnt		; Get the program counter.
+	lda #19			; Move the cursor to the right, by 19 columns.
+	sta scr_col		;
+	jsr update_pos		;
+	jsr print_lo		; Print the low nibble offsets.
 @loop:
-	lda #'\n'	; Print a newline.
-	jsr print_char	;
-	jsr print_hi	; Place the address in the string buffer.
-	jsr print_chunk	; Place the next 16 bytes in the string buffer.
-	lea strbuf	; Print the string buffer.
-;	jsr print_str	;
-	jsr print_sfast	;
-	inc idx1	; Increment the chunk count.
-	ldb idx1	; Get the chunk count.
-	cpb #$10	; Did we print 16 chunks?
-	beq @end	; Yes, so we're done.
-	lda.q idx0	; No, so get the address index.
-	clc		; Prepare for a non carrying add.
-	adc #$10	; Add 16 to the address.
-	sta.q idx0	; Put it back into the address.
-	and #0		; Reset A.
-	bra @loop	; Keep looping.
+	lda #'\n'		; Print a newline.
+	jsr print_char		;
+	lea d, (sp+1)		; Get the address of the string buffer.
+	mov s, x		; Get the program counter.
+	jsr print_hi		; Print the address to the string buffer.
+	mov d, a		; Get the string buffer pointer after the printed address.
+	mov s, x		; Get the program counter.
+	jsr print_chunk		; Print the next 16 bytes to the string buffer.
+	lea d, (sp+1)		; Get the address of the string buffer.
+	lea s, (buffer)+y	; Get the address of the screen buffer, at the current cursor position.
+;	jsr print_str		; Print the string buffer.
+	jsr print_sfast		;
+	inb			; Increment the chunk count.
+	cpb #$10		; Did we print 16 chunks?
+	beq @end		; Yes, so we're done.
+	add x, #$10		; No, so add 16 to the address.
+	and #0			; Reset A.
+	bra @loop		; Keep looping.
 @end:
-	lda #'\n'	; Print a newline.
-	jsr print_char	;
-	and #0		; Reset A.
-	rts		; End of viewmem.
+	lda #'\n'		; Print a newline.
+	jsr print_char		;
+	ads #$50		; Cleanup the stack frame.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of viewmem.
 
 
 list:
@@ -164,10 +271,10 @@ help:
 	nop		;
 @end:
 	rts		; End of help.
-inst:
+instruction:
 	nop		;
 @end:
-	rts		; End of inst.
+	rts		; End of instruction.
 run:
 	nop		;
 @end:
diff --git a/programs/sub-suite/subeditor.s b/programs/sub-suite/subeditor.s
index 387b5db..f6b647f 100644
--- a/programs/sub-suite/subeditor.s
+++ b/programs/sub-suite/subeditor.s
@@ -11,8 +11,8 @@ reset:
 	ldy #0		; Reset Y.
 	tyx		; Reset X.
 	jsr init_heap	; Initialize the heap.
-	tax		; Set the stack pointer to the end of RAM.
-	txs		;
+	mov sp, a	; Set the stack pointer to the end of RAM.
+;	txs		;
 	sub.d #STKSIZE	; Subtract the stack size, from the end of RAM.
 	sta.q heapend	; Save the end of the heap.
 	and #0		; Reset A.
@@ -28,45 +28,39 @@ reset:
 init_heap:
 	lea HEAPORG	; Get the heap's starting point.
 	ste.q heapptr	;
+	mov d, e	;
 	jsr findramend	; Find the end of the heap.
 	rts		; End of init_heap.
 
 
 init_tables:
-	and #0		; Reset A.
-	lda.w #SCRSIZE	; Allocate SCRSIZE bytes of RAM for the screen buffer.
+	lea d, SCRSIZE	; Allocate SCRSIZE bytes of RAM for the screen buffer.
 	jsr malloc	;
 	sta.q buffer	;
-	and #0		; Reset A.
-	lda.w #CMDSIZE	; Allocate CMDSIZE bytes of RAM for the command buffer.
+	lea d, CMDSIZE	; Allocate CMDSIZE bytes of RAM for the command buffer.
 	jsr malloc	;
 	sta.q cmd_buf	;
-	and #0		; Reset A.
-	lda.w #LWSIZE	; Allocate LWSIZE bytes of RAM for the linewrap table.
+	lea d, LWSIZE	; Allocate LWSIZE bytes of RAM for the linewrap table.
 	jsr malloc	;
 	sta.q bitabl	;
-	and #0		; Reset A.
 	rts		; End of init_tables.
 
 
 ;test_free:
 ;	inc step	;
-;	lda.q bitabl	;
+;	mov.q d, bitabl	;
 ;	jsr free	;
-;	lda.q buffer	;
+;	mov.q d, buffer	;
 ;	jsr free	;
-;	and #0		; Reset A.
-;	lda.w #LWSIZE	; Allocate LWSIZE bytes of RAM for the linewrap table.
+;	lea d, LWSIZE	; Allocate LWSIZE bytes of RAM for the linewrap table.
 ;	jsr malloc	;
 ;	sta.q bitabl	;
-;	lda.q cmd_buf	;
+;	mov.q d, cmd_buf;
 ;	jsr free	;
-;	and #0		; Reset A.
-;	lda.w #SCRSIZE	; Allocate SCRSIZE bytes of RAM for the screen buffer.
+;	lea d, SCRSIZE	; Allocate SCRSIZE bytes of RAM for the screen buffer.
 ;	jsr malloc	;
 ;	sta.q buffer	;
-;	and #0		; Reset A.
-;	lda.w #CMDSIZE	; Allocate CMDSIZE bytes of RAM for the command buffer.
+;	lea d, CMDSIZE	; Allocate CMDSIZE bytes of RAM for the command buffer.
 ;	jsr malloc	;
 ;	sta.q cmd_buf	;
 ;	and #0		; Reset A.
@@ -74,33 +68,38 @@ init_tables:
 
 
 clr_arr:
-	stz.q (e)	; Clear eight bytes.
-	ade #8		; Increment the pointer by 8.
-	stz.q (e)	; Clear eight bytes.
-	ade #8		; Increment the pointer by 8.
-	sub #$10	; Subtract 16 from the size.
+	pha.q		; Preserve A.
+	and #0		; Reset A.
+@loop:
+	mov.q (d), a	; Clear 16 bytes.
+	mov.q (d+8), a	;
+	add d, #$10	; Increment the pointer by 16.
+	sub s, #$10	; Subtract 16 from the size.
 	bcc @end	; We've reached the end of the array, so we're done.
 	beq @end	;
-	bra clr_arr	; Keep looping.
+	bra @loop	; Keep looping.
 @end:
+	pla.q		; Restore A.
 	rts		; End of clr_arr.
 
 
 pnt_strt:
-	lea ed_name	; Print the name of the editor.
+	lea d, ed_name	; Print the name of the editor.
 	jsr print_str	;
-	lea ver_str	; Print the version text.
+	lea d, ver_str	; Print the version text.
 	jsr print_str	;
-	lea ed_ver	; Print the version number.
+	lea d, ed_ver	; Print the version number.
 	jsr print_str	;
-	lea ed_sver	; Print the sub version number.
+	lea d, ed_sver	; Print the sub version number.
 	jsr print_str	;
+	lea d, '\n'	; Print a newline.
 	lda #'\n'	; Print a newline.
 	jsr print_char	;
-	lea made	; Print the "Created by" text.
+	lea d, made	; Print the "Created by" text.
 	jsr print_str	;
-	lea author	; Print the name of the author.
+	lea d, author	; Print the name of the author.
 	jsr print_str	;
+	lea d, '\n'	; Print a newline.
 	lda #'\n'	; Print a newline.
 	jsr print_char	;
 	rts		; End of pnt_strt.
@@ -109,8 +108,8 @@ pnt_strt:
 clr_cmd:
 	and #0		; Reset A.
 	tay		; Reset Y.
-	lda.w #CMDSIZE	; Set the clear count to CMDSIZE.
-	lea (cmd_buf)	; Set the array to be cleared to the command buffer.
+	lea s, CMDSIZE	; Set the clear count to CMDSIZE.
+	lea d, (cmd_buf); Set the array to be cleared to the command buffer.
 	jsr clr_arr	; Clear the command buffer.
 	rts		; End of clr_cmd.
 
@@ -149,140 +148,68 @@ getchar:
 
 
 print_str:
+	pha.q		; Preserve A.
+	phb.q		; Preserve B.
 	and #0		; Reset A.
 	tba		; Reset B.
 @loop:
-	ldb #1		; Enable replace mode.
-	stb regb	;
-	and #0		; No, reset the accumulator.
-	ldb (e)		; Are we at the end of the string?
+	mov regb, #1	; Enable replace mode.
+	and #0		; Reset A.
+	mov b, (d)	; Are we at the end of the string?
 	beq @end	; Yes, so we're done.
 	jsr update_ptr	; No, so get the screen buffer index.
 	tay		; Save it in Y.
 	tba		; Get the character back.
-	ine             ; Increment the string pointer.
+	inc d		; Increment the string pointer.
 	jsr print_char	; Print the character.
 	bra @loop	; Keep looping.
 @end:
 	stz regb	; Enable insert mode.
 	and #0		; Reset A.
 	tab		; Reset B.
+	pla.q		; Restore A.
+	plb.q		; Restore B.
 	rts		; End of print_str.
 
 
-;print_str:
-;	ldx #0		; Reset X.
-;	sta.q end	; Save the parameter.
-;@reset:
-;	lda.q end	; Get the parameter.
-;	ldb #0		; Clear the B register.
-;	jsr set_ptr	; Set the first pointer to the parameter.
-;	tba		; Clear the Accumulator.
-;@loop:
-;	ldb #1		; Enable replace mode.
-;	stb regb	;
-;	lda.q ptr	; Get the first pointer.
-;	cmp.q end	; Did the pointer change?
-;	bne @reset	; Yes, so set it back.
-;	and #0		; No, reset the accumulator.
-;	txy		; Copy the string index into Y.
-;	ldb (ptr), y    ; Are we at the end of the string?
-;	beq @end	; Yes, so we're done.
-;	jsr update_ptr	; No, so get the screen buffer index.
-;	tay		; Save it in Y.
-;	tba		; Get the character back.
-;	inx             ; Increment the string index.
-;	phx		; Preserve the string index.
-;	jsr print_char	; Print the character.
-;	plx		; Get the string index back.
-;	bra @loop	; Keep looping.
-;@end:
-;	stz regb	; Enable insert mode.
-;	and #0		; Reset A.
-;	tab		; Reset B.
-;	rts		; End of print_str.
-
 getbit:
-	clc		; Clear the carry flag.
-	lda scr_str	; Has the screen been scrolled?
-	bne getbt0	; Yes, so add the screen offset to the current line number.
-	ldx scr_row	; No, so just use the current line number.
-	bra getbt1	; Start getting the bit.
-getbt0:
-	lda scr_row	; Get the current line number.
-	adc scr_str	; Add the screen offset to it.
-	tax		; Use it as the wrap index.
-getbt1:
-	pha 		; Save the parameter.
-	ldb #1		; Make sure that set_ptr sets the second pointer.
-	lda.q bitabl	; Set the second pointer to the linewrap table.
-	jsr set_ptr	;
-	lsr #$10	; Clear the Accumulator.
-	pla 		; Get the return byte back.
-	jsr bitpos	; Get the bit, and byte position.
-	phy.w		; Save the screen index.
-	txy		; Get the byte position.
-	ldb (ptr2), y	; Get one byte of the wrap table.
-	ply.w		; Get the screen index back.
-	and b		; Mask out the bit of the current line number.
-	cmp #1		; Set the carry flag, if true.
-	bra bitout	; We are done.
+	des			; Create the stack frame.
+	add d, s		; Add the row position with the row offset position.
+	lea s, (sp+1)		; Get the address of the bitmask.
+	jsr bitpos		; Get the bit, and byte position.
+	ins			; Cleanup the stack frame.
+	mov a, (bitabl)+a	; Get the bit of the row position.
+	and a, (s)		; Return the masked bit.
+	rts			; End of getbit.
+
 
 clrbit:
-	pha 		; Save the parameter.
-	ldb #1		; Make sure that set_ptr sets the second pointer.
-	lda.q bitabl	; Set the second pointer to the linewrap table.
-	jsr set_ptr	;
-	and #0		; Clear the Accumulator.
-	pla 		; Get the return byte back.
-	jsr bitpos	; Get the bit, and byte position.
-	xor #$FF	; Invert the bitmask.
-	phy.w		; Save the screen index.
-	txy		; Get the byte position.
-	ldb (ptr2), y	; Get one byte of the wrap table.
-	and b		; Clear the bit of the current line number.
-bitsav:
-	sta (ptr2), y	; Update the wrap table.
-	ply.w		; Get the screen index back.
-bitout:
-	ldx bitmask	; Return the bitmask.
-	rts		; We are done.
+	pha.q			; Preserve A.
+	des			; Create the stack frame.
+	lea s, (sp+1)		; Get the address of the bitmask.
+	jsr bitpos		; Get the bit, and byte position.
+	ins			; Cleanup the stack frame.
+	not (s)			; Invert the bitmask.
+	and (bitabl)+a, (s)	; Set the bit of the current row number to zero.
+	pla.q			; Restore A.
+	rts			; End of clrbit.
 
 setbit:
-	pha 		; Save the parameter.
-	ldb #1		; Make sure that set_ptr sets the second pointer.
-	lda.q bitabl	; Set the second pointer to the linewrap table.
-	jsr set_ptr	;
-	and #0		; Clear the Accumulator.
-	pla 		; Get the return byte back.
-	jsr bitpos	; Get the bit, and byte position.
-	phy.w		; Save the screen index.
-	txy		; Get the byte position.
-	ldb (ptr2), y	; Get one byte of the wrap table.
-	ora b		; Set the bit of the current line number.
-	bra bitsav	; Save the bit.
+	pha.q			; Preserve A.
+	des			; Create the stack frame.
+	lea s, (sp+1)		; Get the address of the bitmask.
+	jsr bitpos		; Get the bit, and byte position.
+	ins			; Cleanup the stack frame.
+	or  (bitabl)+a, (s)	; Set the bit of the current row number to one.
+	pla.q			; Restore A.
+	rts			; End of setbit.
 
 bitpos:
-	pha 		; Save the parameter.
-	ldb #0		; Make sure that set_ptr sets the first pointer.
-	lda.w #bits	; Set the first pointer to the bitmask table.
-	jsr set_ptr	;
-	and #0		; Clear the Accumulator.
-	pla 		; Get the parameter back.
-	stx bitmask	; Make the line number the bitmask.
-	txa		; Copy it to the Accumulator.
-	and #7		; Get the bit position.
-	phy.w		; Save the cursor index.
-	tay		; Use the bit position as the index.
-	tax		; Copy it into X.
-	lda (ptr), y	; Get the bitmask.
-	ply.w		; Get back the cursor index.
-	pha 		; Save the bitmask.
-	lda bitmask	; Get the line number.
-	lsr #3		; Get the byte position.
-	tax		; Copy it into X.
-	pla 		; Get back the bitmask.
-	rts		; End of bitpos.
+	mov a, d		; Preserve the row number.
+	and d, #7		; Get the bit position.
+	lsr #3			; Return the byte position.
+	mov (s), (d+bits)	; Place the bitmask into the mask argument.
+	rts			; End of bitpos.
 
 
 handle_char:
@@ -328,7 +255,10 @@ handle_char:
 cmd_cpy:
 	lda scr_row	; Get the row position.
 	sta scr_trow	; Save it for later.
-	jsr findend	; Find the end of the line.
+	lea d, (buffer)	; Get the screen buffer.
+	mov s, y	; Get the cursor index.
+	jsr find_end	; Find the end of the line.
+	div #maxcol+1	; Get the ending line.
 	ldb scr_str	; Has the screen been scrolled?
 	beq @start	; No, so don't subtract the screen's starting point from the line number.
 @offset:
@@ -388,48 +318,45 @@ cmd_cpy:
 
 
 findst:
-	lda #0		; Reset A.
+;	lda #0		; Reset A.
+;	xor d, d	; Reset D.
+;	xor s, s	; Reset S.
+	mov d, scr_row	; Get the row position.
+	mov s, scr_str	; Get the row offset.
 @loop:
-	pha 		; Save the current line number.
+;	pha 		; Save the current line number.
 	jsr getbit	; Is this the start of the line?
-	pla 		; Get the current line number back.
-	bcc @end	; Yes, so we're done.
-	inc		; No, so check the next physical line.
+;	pla 		; Get the current line number back.
+	beq @end	; Yes, so we're done.
+	inc d		; No, so check the next physical line.
 	dec scr_row	; Are we at the top of the screen?
 	bpo @loop	; No, so keep looping.
-	dec		; Yes, so move back one line.
+	dec d		; Yes, so move back one line.
 	inc scr_row	; Put the row postiion back to zero.
 @end:
-	cmp #0		; Update all the flags.
+	cmp d, #0	; Update all the flags.
 	rts		; End of findst.
 
 
-fndend:
-	phb 		; Save the contents of the B register.
-	ldb #0		; Make sure that set_ptr sets the first pointer.
-	lda.q buffer	; Set the first pointer to the start of the screen buffer.
-	jsr set_ptr	;
-	tba		; Set the Accumulator to zero.
-	plb 		; Restore the contents of the B register.
-	phy.w		;
+find_end:
+	mov a, s	; Set the loop counter.
 @loop:
-	lda (ptr), y	; Are we at the end of the string?
-	beq @end	; Yes, so we're done.
-	iny		; No, so increment the cursor index.
-	bra @loop	; Keep looping.
+	inc		; Increment the loop counter.
+	cmp (d+a-1), #0	; Did we hit the null terminator?
+	bne @loop	; No, so keep looping.
 @end:
-	sty.w scr_ptr3	;
-	ply.w		;
-	rts		; End of fndend.
-
-findend:
-	jsr fndend	;
-	lda.w scr_ptr3	;
-	div #maxcol+1	;
-	rts		;
+	rts		; End of find_end.
+
+
+get_endrow:
+	jsr find_end	; Find the end of the line.
+	div #maxcol+1	; Get the ending row.
+	rts		; End of get_endrow
 
 
 print_char:
+	phb.q		; Preserve B.
+	phx.q		; Preserve X.
 	phe.q		; Preserve E.
 	sta rega	; Preserve the character.
 	ldb #2		; Make sure that set_ptr sets the third pointer.
@@ -441,15 +368,13 @@ print_char:
 	lda rega	; Get the character back.
 	jsr get_ctrlidx	; Get the control code jump table index.
 	lsl #1		; Multiply the return value by two, to get the index.
-	tax		;
-	lea.w (ct_jtb, x); Get the address of the control code handler.
-;	pha.q		;
-;	ple.q		;
-;	jsr set_ptr	; Set the second pointer to the control code handler.
+	lea.w e, (ct_jtb+a); Get the address of the control code handler.
 	deb		; Reset B.
 	tba		; Reset A.
 	jsr (e)		; Jump to the handler for that control code.
 	ple.q		; Restore E.
+	plx.q		; Restore X.
+	plb.q		; Restore B.
 	rts
 printc:
 	lda #0		; start trying to print a character.
@@ -458,18 +383,20 @@ printc:
 	beq @save	; Yes, so just print the character.
 	lda regb	; No, but was the flag set?
 	bne @save	; Yes, so don't shift the line.
-	sty.w scr_ptr	; No, so save the cursor index for later.
-	jsr fndend	; Find the end of the line.
+;	sty.w scr_ptr	; No, so save the cursor index for later.
+;	jsr fndend	; Find the end of the line.
 	bra @shift	; Start shifting the line right.
 @update:
 	lda scr_col	; Save the current column position for later.
 	sta scr_tcol	;
 @update1:
-	jsr findend	; Find the end of the line.
-	sta rege	; Use it for redrawing the line.
+	lea d, (buffer)	; Get the screen buffer.
+	mov s, y	; Get the cursor index.
+	jsr get_endrow	; Get the ending line.
+	mov d, a	;
+	mov s, scr_trow	; Get the current row position.
 	lda scr_trow	; Get the current row position.
 @update2:
-	sta regf	; Set the starting line, to the current row position.
 	jsr rdrw_ln	; Redraw the line.
 	lda scr_trow	; Get the real row position back.
 	sta scr_row	;
@@ -479,12 +406,15 @@ printc:
 	dec regd	;
 	bra @save1	;
 @shift:
-	ldy.w scr_ptr3	;
-	inc scr_ptr3	;
-	tyx		;
-	dey		;
-	ldb #1		;
-	stb regd	;
+;	ldy.w scr_ptr3	;
+;	inc scr_ptr3	;
+;	tyx		;
+;	dey		;
+;	ldb #1		;
+;	stb regd	;
+	lea d, (buffer)	; Get the screen buffer.
+	mov.w s, scr_ptr; Get the cursor index.
+	mov f, #1	; Set the left flag to true.
 	jsr shftln	;
 	ldb #1		;
 	stb regd	;
@@ -501,6 +431,7 @@ printc:
 	sta (ptr3), y	; store typed character into the input buffer.
 @incr:
 	inc scr_col	; Increment the cursor's x coordinate.
+	inc.w scr_ptr	; Increment the screen index.
 	iny		;
 @wrapped:
 	ldb #1		;
@@ -536,13 +467,15 @@ printc:
 @wrap1:
 	inc scr_row	;
 @wrap2:
-	phx.w		;
-	clc		;
-	lda scr_row	;
-	adc scr_str	;
-	tax		;
-	jsr setbit	;
-	plx.w		;
+;	phx.w		;
+;	clc		;
+;	lda scr_row	;
+;	adc scr_str	;
+;	tax		;
+	mov d, scr_row	; Get the row position.
+	add d, scr_str	; Add the row offset to the row position.
+	jsr setbit	; Set the bit of that row.
+;	plx.w		;
 	jsr update_pos	;
 printc_end:
 	rts		;
@@ -573,11 +506,11 @@ clr_scr:
 	sta scr_end	;
 	stz scr_str	;
 	tay		;
-	lda.w #LWSIZE	; Set the clear count to LWSIZE.
-	lea (bitabl)	; Set the array to be cleared to the linewrap table.
+	lea s, LWSIZE	; Set the clear count to LWSIZE.
+	lea d, (bitabl)	; Set the array to be cleared to the linewrap table.
 	jsr clr_arr	; Clear the linewrap table.
-	lda.w #SCRSIZE	; Set the clear count to SCRSIZE.
-	lea (buffer)	; Set the array to be cleared to the screen buffer.
+	lea s, SCRSIZE	; Set the clear count to SCRSIZE.
+	lea d, (buffer)	; Set the array to be cleared to the screen buffer.
 	jsr clr_arr	; Clear the screen buffer.
 ;	lda.w #CMDSIZE	; Set the clear count to CMDSIZE.
 ;	lea (cmd_buf)	; Set the array to be cleared to the command buffer.
@@ -613,8 +546,10 @@ bs:
 	beq @wrap	; Yes, so check for a wrapped line.
 	bra back	; No, so add the backspace to the buffer.
 @wrap:
+	mov d, scr_row	; Get the row position.
+	mov s, scr_str	; Get the row offset.
 	jsr getbit	; Is this line, a wrapped line?
-	bcs @wrap1	; Yes, so check if the cursor is at the top.
+	bne @wrap1	; Yes, so check if the cursor is at the top.
 	rts		; No, so we're done.
 @wrap1:
 	lda scr_row	; Are we at the top of the screen?
@@ -644,7 +579,9 @@ back:
 	stb regf	;
 	lda scr_row	; Save the current row position for later.
 	sta scr_trow	;
-	jsr findend	; Find the end of the line.
+	lea d, (buffer)	; Get the screen buffer.
+	mov s, y	; Get the cursor index.
+	jsr get_endrow	; Get the ending line.
 	sta scr_row	; Set our row position to the end of the line.
 @find_st:
 	jsr findst	; Does this line take up more than one real line?
@@ -660,14 +597,20 @@ back:
 	iny		; Increment cursor index.
 	ldb #0		; Set shifting direction to left.
 	stb regd	;
+	lea d, (buffer)	; Get the screen buffer.
+	mov s, y	; Get the cursor index.
+	mov f, #0	; Set the left flag to false.
 	jsr shftln	; Shift line back by one character.
 	lda #$7F	; Print a backspace to the screen.
 	sta scr		;
 	lda rege	; Are we updating more than one line?
 	beq @load	; No, so skip to the next step.
 @find_end:
-	jsr findend	; Yes, so find the end of the line.
-	sta rege	; Set the end parameter to it.
+	lea d, (buffer)	; Get the screen buffer.
+	mov s, y	; Get the cursor index.
+	jsr get_endrow	; Yes, so Get the ending line.
+	mov d, a	;
+	mov s, scr_trow	; Get the current row position.
 	lda scr_col	; Save the current column position for now.
 	sta scr_tcol	;
 	jsr rdrw_ln	; Start redrawing the line.
@@ -683,88 +626,73 @@ back:
 	lda (ptr3), y	; Are we at the end of the line?
 	beq @shift	; Yes, so skip redrawing.
 	lda scr_trow	; No, so set the line to start redrawing, to the line that the cursor is on.
-	sta regf	;
 	inc rege	; Set the redraw flag to true.
 	bra @shift	; Start shifting the line back.
 
 
 shftln:
-	ldb regd	; Is the flag not set?
-	beq @dec_loop	; Yes, so shift, and decrement.
-	ldb #0		; Clear the B register.
-	bra @inc_loop	; No, so shift, and increment.
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	and f, f		; Is the left flag not set?
+	beq @right		; Yes, so shift the line to the right.
+;	txa			; Get the end of the line.
+	jsr find_end		; Find the end of the line.
+	dec			; Decrement the source position.
+	bra @left		; No, so shift the line to the left.
 @minus:
-	ldy.w zero	; Set the source poition to 0.
-	stb (ptr3), y	; Clear the character that is in the source.
-	bra @end	; We are done.
-@inc_loop:
-	sty.w scr_ptr2	; Save the source position for later.
-	ldy.w scr_ptr	; Get the previous cursor index.
-	cpy.w scr_ptr2	; Is the source position, at, or below the cursor index?
-	beq @inc_loop1	; Yes, so keep looping.
-	bcs @end	; No, so we're done.
-@inc_loop1:
-	ldy.w scr_ptr2	; Get the source position.
-	lda (ptr3), y	; Get the character from the source position.
-	phy.w		; Save the source position for later.
-	txy		; Set our position to the destination.
-	sta (ptr3), y	; Place the character from the source position, to the destination position.
-	ply.w		; Set our position back to the source.
-	stb (ptr3), y	; Clear the character that is in the source.
-	bng @minus	; The source underflowed, so set it back to zero,
-	dey		; Decrement the source position.
-	dex		; Decrement the destination position.
-	bra @inc_loop	; Keep looping.
-@dec_loop:
-	stx.w scr_ptr2	; Save the destination position for later.
-	lda (ptr3), y	; Is the character at the source position, a null terminator?
-	beq @end3	; Yes, so we're done.
-	phy.w		; No, so save the source position for later.
-	txy		; Set our position to the destination.
-	sta (ptr3), y	; Place the character from the source position, to the destination position.
-	inx		; Increment the destination position.
-	ply.w		; Set our position back to the source.
-	stb (ptr3), y	; Clear the character that is in the source.
-	iny		; Increment the source position.
-	bra @dec_loop	; Keep looping.
+	and #0			; Set the source poition to 0.
+	mov (d), a		; Clear the character that is in the source.
+	bra @lend		; We are done.
+@left:
+	cmp s, a		; Is the cursor index, at, or below the source position?
+	beq @left1		; Yes, so keep looping.
+	bcs @lend		; No, so we're done.
+@left1:
+	cmp #0			; Is the source position less than 0?
+	bcc @minus		; Yes, so set the source position to zero.
+	mov (d+a+1), (d+a)	; No, so shift the current character to the left by one.
+	mov (d+a), #0		; Clear the current character.
+	dec			; Decrement the source position.
+	bra @left		; Keep looping.
+@right:
+	cmp (d+s), #0		; Is this character a null terminator?
+	beq @rend		; Yes, so we're done.
+	mov (d+s-1), (d+s)	; No, so shift the current character to the right by one.
+	mov (d+s), #0		; Clear the current character.
+	inc s			; Increment the source position.
+	bra @right		; Keep looping.
 @wrap:
-	tax		; Use the ending line as a parameter for setbit.
-	jsr setbit	; Set the wrap bit of the ending line.
-	bra @end5	; We are done.
+	mov d, a		; Get the ending line.
+	jsr setbit		; Set the wrap bit of the ending line.
+	bra @end		; We are done.
 @wrap1:
-	tax		; Use the ending line as a parameter for clrbit.
-	jsr clrbit	; Clear the wrap bit of the ending line.
-	bra @end5	; We are done.
+	mov d, a		; Get the ending line.
+	jsr clrbit		; Clear the wrap bit of the ending line.
+	bra @end		; We are done.
+@lend:
+	lea s, (a+2)		; Add 2 to the source position.
+	jsr find_end		; Find the end of the line.
+	dec			; Decrement the end of line position.
+	div #maxcol+1		; Get the ending line.
+@lend2:
+	cmp scr_row		; Is the ending line greater than the starting line?
+	beq @end		; No, so we're done.
+	bcs @wrap		; Yes, so set the wrap bit.
+	bra @end		; No, so we're done.
+@rend:
+	jsr find_end		; Find the end of the line.
+	dec			; Decrement the end of line position.
+	div #maxcol+1		; Get the ending line.
+	cpb #0			; Is the remainder zero?
+	bne @end		; No, so we're done.
+@rend2:
+	cmp scr_row		; Is the ending line greater than the starting line?
+	beq @end		; No, so we're done.
+	bcs @wrap1		; Yes, so clear the wrap bit.
 @end:
-	lda (ptr3), y	; Is this character a null terminator?
-	bne @end1	; No, so just find the end of the line.
-	lda #$20	; Yes, so convert it to a space for now.
-	sta (ptr3), y	;
-@end1:
-	jsr findend	; Find the ending line.
-	sta regd	; Save ending line for later.
-	lda (ptr3), y	; Is this character a space?
-	cmp #$20	;
-	bne @end5	; No, so skip the conversion.
-	lda #0		; Yes, so convert it back to zero.
-	sta (ptr3), y	;
-@end2:
-	lda regd	; Get the ending line.
-	cmp scr_row	; Is the ending line greater than the starting line?
-	beq @end5	; No, so we're done.
-	bcs @wrap	; Yes, so set the wrap bit.
-	bra @end5	; No, so we're done.
-@end3:
-	jsr findend	; Find the ending line.
-	cpb #0		; Is the remainder zero?
-	beq @end4	; Yes, so check if the ending line is greater than the starting line.
-	bra @end5	; No, so we're done.
-@end4:
-	cmp scr_row	; Is the ending line greater than the starting line?
-	beq @end5	; No, so we're done.
-	bcs @wrap1	; Yes, so clear the wrap bit.
-@end5:
-	rts		; End of shftln.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of shftln.
 
 
 esc:
@@ -883,8 +811,10 @@ isright:
 	bra @right	; No, so move the cursor right, like normal.
 @wrap:
 	inc scr_row	; Move down a row.
+	mov d, scr_row	; Get the row position.
+	mov s, scr_str	; Get the row offset.
 	jsr getbit	; Is the current line, a wrapped line?
-	bcs @incr	; Yes, so leave the cursor where it is.
+	bne @incr	; Yes, so leave the cursor where it is.
 	dec scr_row	; No, so move the cursor back up a row.
 	bra @end2	; We are done.
 @scroll:
@@ -927,8 +857,10 @@ isleft:
 	beq @left	; Yes, so move the cursor left.
 	bra @end1	; No, so we're done.
 @wrap:
+	mov d, scr_row	; Get the row position.
+	mov s, scr_str	; Get the row offset.
 	jsr getbit	; Is the current line, a wrapped line?
-	bcs @decr	; Yes, so wrap back up a line.
+	bne @decr	; Yes, so wrap back up a line.
 	bra @end1	; No, so we're done.
 @decr:
 	lda scr_row	; Is the cursor at the top of the screen?
@@ -999,12 +931,11 @@ isshftdown:
 
 
 update_ptr:
-	clc		; Clear the carry flag.
 	lda scr_row	; Add the cursor's line number,
-	adc scr_str	; with the starting line number to get the absolute line number.
+	add scr_str	; with the starting line number to get the absolute line number.
 	mul #maxcol+1	; Multiply the line number by the screen's max column count, plus 1.
-	clc		; Clear the carry flag.
-	adc scr_col	; Add the cursor's column number to get the screen index.
+	add scr_col	; Add the cursor's column number to get the screen index.
+	sta.w scr_ptr	; Save the screen index.
 ;	cmp.w #$2000	; Is the index greater than, or equal to the end of the screen buffer?
 ;	bcc @end	; No, so we're done.
 ;@wrap:
@@ -1021,22 +952,21 @@ update_ptr:
 
 
 update_pos:
+	phb.q		; Preserve B.
+	and #0		; Reset A.
+	tab		; Reset B.
 	ldb #1		; Set the F pseudo register to one, to fix some bugs.
 	stb regf	;
 	jsr update_ptr	; Update the screen buffer index.
 	tay		; Place the index into the Y register.
 	tba		; Reset A.
-	lda #$1B	; Print an escape character
-	sta scr		; to the screen.
-	lda #'['	; Print '['
-	sta scr		; to the screen, and start the escape sequence.
+	mov scr, #$1B	; Print an escape character to the screen.
+	mov scr, #'['	; Print '[' to the screen, and start the escape sequence.
 	jsr getrow	; Start printing the row number to the screen.
-	lda #';'	; Print ';'
-	sta scr		; to the screen.
+	mov scr, #';'	; Print ';' to the screen.
 	jsr getcol	; Start printing the column number to the screen.
-	lda #'H'	; Print 'H'
-	sta scr		; to the screen.
-	;inc step	;
+	mov scr, #'H'	; Print 'H' to the screen.
+	plb.q		; Restore B.
 	rts		; End of update_pos.
 
 getrow:
@@ -1068,6 +998,7 @@ scrl_down:
 	lda wrapped	; Was the wrapped flag set?
 	beq @save	; Yes, so save the cursor position.
 @redraw:
+	lea d, (buffer)	; Get the screen buffer.
 	jsr rdrw_row	; No, so redraw this row.
 	lda wrapped	; Was the wrapped flag set?
 	beq @load	; Yes, so load the previous cursor position back.
@@ -1103,6 +1034,7 @@ scrl_up:
 	pha 		;
 	lda #0		;
 	sta scr_row	;
+	lea d, (buffer)	; Get the screen buffer.
 	jsr rdrw_row	;
 	pla 		;
 	sta scr_col	;
@@ -1112,64 +1044,54 @@ scrl_up:
 @end:
 	rts		;
 
+
 rdrw_row:
-	lda #0		;
-	sta scr_col	;
-	jsr update_pos	;
+	pha.q		; Preserve A.
+	phb.q		; Preserve B.
+	stz scr_col	; Reset the column position.
+	jsr update_pos	; Update the cursor position.
+	xor b, b	; Reset B.
+	tya		; Get the screen index.
+	tab		;
+	add b, #maxcol+1; Get the end of the row plus one.
 @loop:
-	lda (ptr3), y	;
-	beq @incr	;
-	sta scr		;
-@incr:
-	inc scr_col	;
-	lda (ptr3), y	;
-	beq @skip	;
-@incr1:
-	iny		;
-@incr2:
-	lda scr_col	;
-	cmp #maxcol+1	;
-	bcs @end	;
-	bra @loop	;
-@skip:
-	lda #' '	;
-	sta scr		; to the screen.
-	bra @incr1	;
+	cmp (d+a), #0	; Is this a null terminator?
+	mne scr, (d+a)	; No, so print the character.
+	meq scr, #' '	; Yes, so print a space.
+	inc		; Increment the screen index.
+	cmp b		; Is the column position at, or above the maximum column count?
+	bcc @loop	; No, so keep looping.
 @end:
-	lda #0		;
-	sta scr_col	;
-	jsr update_pos	;
-@end1:
-	rts		;
+	stz scr_col	; Reset the column position.
+	jsr update_pos	; Update the cursor position.
+	plb.q		; Restore B.
+	pla.q		; Restore A.
+	rts		; End of rdrw_row.
+
 
 rdrw_ln:
-	lda scr_row	;
-	pha 		;
-	lda regf	;
-	sta scr_row	;
-	lda scr_col	;
-	pha 		;
-	jsr update_pos	;
+	pha.q		; Preserve A.
+	psh scr_row	; Preserve the row position.
+	psh scr_col	; Preserve the column position.
+	mov scr_row, s	; Set the row position to the starting position.
+	jsr update_pos	; Update the cursor position.
+	mov a, d	; Get the ending position.
+	lea d, (buffer)	; Get the address of the screen buffer.
 @loop:
-	lda scr_row	;
-	cmp rege	;
-	beq @loop1	;
-	bcs @end	;
-@loop1:
-	jsr rdrw_row	;
+	cmp scr_row, a	; Is the row position at, or below the ending position?
+	beq @redraw	; Yes, so redraw the row.
+	bcs @end	; No, so we're done.
+@redraw:
+	jsr rdrw_row	; Redraw the line.
 @incr:
-	inc scr_row	;
-	bra @loop	;
+	inc scr_row	; Increment the row position.
+	bra @loop	; Keep looping
 @end:
-	pla 		;
-	sta scr_col	;
-	pla 		;
-	sta scr_row	;
-	jsr update_pos	;
-	lda #0		;
-	sta rege	;
-	sta regf	;
-	rts		;
+	pul scr_col	; Restore the column position.
+	pul scr_row	; Restore the row position.
+	jsr update_pos	; Update the cursor position.
+	pla.q 		; Restore A.
+	rts		; End of rdrw_ln.
 
 
 set_ptr:
diff --git a/programs/sub-suite/test-size.s b/programs/sub-suite/test-size.s
new file mode 100644
index 0000000..b543a36
--- /dev/null
+++ b/programs/sub-suite/test-size.s
@@ -0,0 +1,59 @@
+MAGIC = $AA
+
+
+.org 0
+findramend:
+	and #0		; Reset A.
+;	lda #MAGIC	; Set A to a magic number.
+@loop:
+	mov a, (d)	; Preserve the value.
+	mov (d), #MAGIC	; Write the magic number to the current end of RAM.
+	cmp (d), #MAGIC	; Is the value in RAM, the same as the magic number we wrote?
+	bne @moveback	; No, so move back until we find the last writable memory location.
+	mov (d), a	; Yes, so restore the previous value.
+	add.w d, #$4000	; Increment the end of RAM pointer by 16K.
+	bra @loop	; Keep looping.
+@moveback:
+	dec d		; Decrement the end of RAM pointer.
+	mov a, (d)	; Preserve the value.
+	mov (d), #MAGIC	; Write the magic number to the current end of RAM.
+	cmp (d), #MAGIC	; Is the value in RAM, the same as the magic number we wrote?
+	bne @moveback	; No, so keep looping.
+	mov (d), a	; Yes, so restore the previous value.
+@end:
+	mov a, d	; Return the end of RAM pointer.
+;	ple.q		; Restore E.
+	rts		; End of findramend.
+
+
+;findramend:
+;	phe.q		; Preserve E.
+;	phb.q		; Preserve B.
+;	mov e, d	; Set E to the RAM pointer.
+;	and #0		; Reset A.
+;	lda #MAGIC	; Set A to a magic number.
+;@loop:
+;	ldb (e)		; Preserve the value.
+;	sta (e)		; Write the magic number to the current end of RAM.
+;	cmp (e)		; Is the value in RAM, the same as the magic number we wrote?
+;	bne @moveback	; No, so move back until we find the last writable memory location.
+;	stb (e)		; Yes, so restore the previous value.
+;	ade.w #$4000	; Increment the end of RAM pointer by 16K.
+;	bra @loop	; Keep looping.
+;@moveback:
+;	dee		; Decrement the end of RAM pointer.
+;	ldb (e)		; Preserve the value.
+;	sta (e)		; Write the magic number to the current end of RAM.
+;	cmp (e)		; Is the value in RAM, the same as the magic number we wrote?
+;	bne @moveback	; No, so keep looping.
+;	stb (e)		; Yes, so restore the previous value.
+;@end:
+;	mov a, e	; Return the end of RAM pointer.
+;	ple.q		; Restore E.
+;	plb.q		; Restore B.
+;	rts		; End of findramend.
+
+a
+.org findramend
+v
+q
diff --git a/programs/sub-suite/utils.s b/programs/sub-suite/utils.s
index 3813a05..6479099 100644
--- a/programs/sub-suite/utils.s
+++ b/programs/sub-suite/utils.s
@@ -1,141 +1,125 @@
 ; Utility subroutines for SuBAsm.
 
 print_hi:
-	and #0		; Reset A.
-	sta idx3	; Clear the string index.
-	tax		; Reset X.
-	lda #'$'	; Print the hex delimiter.
-	sta strbuf, x	; Save it in the string buffer.
-	lda.q idx0	; Get the masked address.
-	ldx #$10	; Set digit count to 16.
-	jsr print_hex	; Print the address.
-	lda.q hex_str	; Get the lower half of the string.
-	sta.q strbuf+1	; Save it in the string buffer.
-	lda.q hex_str+8	; Get the upper half of the string.
-	sta.q strbuf+9	; Save it in the string buffer.
-	ldx #$11	; Add 16 to the index.
-	stx idx3	;
-	lda.w #': '	; Print a space.
-	sta.w strbuf, x	; Save it in the string buffer.
-	inc idx3	; Increment the string index twice.
-	inc idx3	;
-	and #0		; Reset A.
-	rts		; End of print_hi.
+	phb.q			; Preserve B.
+	sbs #$10		; Make room for the hex string buffer.
+	and #0			; Reset A.
+	mov b, d		; Get the string buffer pointer.
+	mov (b), #'$'		; Print the hex delimiter to the string buffer.
+	inb			; Increment the string buffer pointer.
+	lea d, (sp+1)		; Get the address of the hex string buffer.
+	mov f, #$10		; Set digit count to 16.
+	jsr print_hex		; Print the address.
+	mov.q (b), (a)		; Print the lower half of the hex string to the string buffer.
+	mov.q (b+8), (a+8)	; Print the upper half of the hex string to the string buffer.
+	add b, #$10		; Add 16 to the index.
+	mov.w (b), #': '	; Print a colon, and space to the string buffer.
+	add b, #2		; Add two to the string buffer pointer.
+	tba a			; Return the string buffer pointer after the printed string.
+	ads #$10		; Cleanup the stack frame.
+	plb.q			; Restore B.
+	rts			; End of print_hi.
 
 
 print_lo:
-	and #0		; Reset A.
-	sta idx3	; Clear the string index.
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	sbs #$33		; Make room for the hex string buffer, and the normal string buffer.
+	and #0			; Reset A.
+	tab			; Reset B.
+	lea d, (sp+1)		; Get the address of the hex string buffer.
+	lea x, (sp+3)		; Get the address of the string buffer.
 @loop:
-	ldx #2		; Set digit count to 2.
-	pha		; Preserve the nibble offset.
-	jsr print_hex	; Print the low nibble offset.
-	lda.w (ptr3)	; Get the two digits.
-	ldx idx3	; Get the string index.
-	sta.w strbuf, x	; Save it in the string buffer.
-	inc idx3	; Increment the string index twice.
-	inc idx3	;
-	ldx idx3	; Get the string index.
-	pla		; Get the nibble offset back.
-	inc		; Increment the offset.
-	cmp #$10	; Are we at the last offset?
-	bcs @end	; Yes, so we're done.
+	lea f, 2		; Set the digit count to two.
+	mov s, b		; Get the low nibble offset.
+	jsr print_hex		; Print the low nibble offset.
+	mov.w (x), (a)		; Place the hex digits in the string buffer.
+	add x, #2		; Add two to the string buffer pointer.
+	inb			; Increment the nibble offset.
+	cpb #$10		; Are we at the last offset?
+	bcs @end		; Yes, so we're done.
 @loop1:
-	pha		; No, so preserve the nibble offset.
-	lda #' '	; Add a space to the string buffer.
-	sta strbuf, x	; Save it in the string buffer.
-	inc idx3	; Increment the string index.
-	pla		; Get the nibble offset back.
-	bra @loop	; Keep looping.
+	mov (x), #' '		; No, so add a space to the string buffer.
+	inx			; Increment the string buffer pointer.
+	bra @loop		; Keep looping.
 @end:
-	and #0		; Reset A.
-	sta strbuf, x	; Null terminate the string buffer.
-	tax		; Reset X.
-	lea strbuf	; Print the string buffer.
-;	jsr print_str	;
-	jsr print_sfast	; Use the faster, but less robust print string routine.
-	rts		; End of print_lo.
-;@end:
-;	lda #0		; Null terminate the string buffer.
-;	sta strbuf, x	;
-;	tax		; Reset X.
-;	lea strbuf	; Print the string buffer.
-;	jsr print_str	;
-;	rts		; End of print_lo.
+	mov (x), #0		; Null terminate the string buffer.
+	lea d, (sp+3)		; Get the address of the string buffer.
+	lea s, (buffer)+y	; Get the address of the screen buffer, at the current cursor position.
+;	jsr print_str		; Print the string buffer.
+	jsr print_sfast		; Use the faster, but less robust print string routine.
+	ads #$33		; Cleanup the stack frame.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of print_lo.
 
 
 print_chunk:
-	ldx #0		; Reset X.
-	phy.w		; Preserve the screen buffer index.
-	txy		; Copy the byte index to it.
+	pha.q			; Preserve A.
+	phb.q			; Preserve B.
+	phx.q			; Preserve X.
+	phy.q			; Preserve Y.
+	sbs #2			; Make room for the hex string buffer.
+	and #0			; Reset A.
+	tab			; Reset B.
+	mov x, d		; Get the address of the string buffer.
+	mov y, s		; Get the starting address.
+	lea d, (sp+1)		; Get the address of the hex string buffer.
+	xor s, s		; Reset S.
 @loop:
-	and #0		; Reset A.
-	ldx #2		; Set the digit count to 2.
-	lda (idx0), y	; Get the byte at that address.
-	jsr print_hex	; Print the byte.
-	lda.w (ptr3)	; Get the two digits.
-	ldx idx3	; Get the string index.
-	sta.w strbuf, x	; Save it in the string buffer.
-	inc idx3	; Increment the string index twice.
-	inc idx3	;
-	ldx idx3	; Get the string index.
-	iny		; Increment the byte index.
-	cpy #$10	; Have we read 16 bytes?
-	beq @end	; Yes, so we're done.
-	lda #' '	; No, so add a soace to the string buffer.
-	sta strbuf, x	; Save it in the string buffer.
-	inc idx3	; Increment the string index.
-	bra @loop	; Keep looping.
+	lea f, 2		; Set the digit count to two.
+	mov s, (y+b)		; Get the byte at that address.
+	jsr print_hex		; Print the byte.
+	mov.w (x), (a)		; Print the hex string to the string buffer.
+	add x, #2		; Add two to the string buffer pointer.
+	inb			; Increment the byte index.
+	cpb #$10		; Have we read 16 bytes?
+	beq @end		; Yes, so we're done.
+	mov (x), #' '		; No, so print a space to the string buffer.
+	inx			; Increment the string buffer pointer.
+	bra @loop		; Keep looping.
 @end:
-	ply.w		; Get the screen buffer index back.
-	inx		; Increment the index by one.
-	and #0		; Null terminate the string.
-	sta strbuf, x	;
-	tax		; Reset X.
-	sta idx3	; Clear the string index.
-	rts		; End of print_chunk.
+	mov (x), #0		; Null terminate the string.
+	ads #2			; Cleanup the stack frame.
+	ply.q			; Restore Y.
+	plx.q			; Restore X.
+	plb.q			; Restore B.
+	pla.q			; Restore A.
+	rts			; End of print_chunk.
 
 
 print_hex:
-	pha.q		; Preserve the hex value.
-	and #0		; Reset A.
-	ldb #1		; Set the second pointer
-	lda.w #hex_char	; to the start of hex character table.
-	jsr set_ptr	;
-	inb		; Set the third pointer
-	lda.d #hex_str	; to the end of hex string buffer.
-	clc		; Do a non carrying add.
-	adc #$10	;
-	jsr set_ptr	;
-	ldb #0		; Reset B.
-	pla.q		; Get the hex value back.
+	phb.q		; Preserve B.
+	phx.q		; Preserve X.
+	phy.q		; Preserve Y.
+	lea b, hex_char	; Get the address of the hex character table.
+	and f, f	; Is the digit count zero?
+	set x, eq	; Set the auto digit count flag if so.
+	mne f, #$10	; Also set the digit count to 16 if the digit count is zero.
+	mov a, f	; Get the digit count.
+	add a, d	; Add the string pointer with the digit count.
 @loop:
-	pha.q		; Preserve the hex value.
-	and #$F		; Mask the lowest nibble.
-	phy.w		; Preserve the screen buffer position.
-	tay		; Get the index for the hex digit.
-	lda (ptr2), y	; Get the hex digit.
-	dec ptr3	; Decrement the string pointer.
-	sta (ptr3)	; Save the hex digit character in the string.
-	ply.w		; Get back the screen buffer position.
-	pla.q		; Get the hex value back.
+	mov y, s	; No, so mask the low nibble of the value.
+	and y, #$F	;
+	dec		; Decrement the string pointer.
+	mov (a), (b+y)	; Place the hex digit character in the string.
+	lsr s, #4	; Is the next nibble zero?
+	bne @loop1	; No, so decrement the digit count.
 @isauto:
-	cpx #1		; Is the digit count less than one?
-	bcc @auto	; Yes, so don't decrement the digit count.
-	dex		; No, but was the digit count zero, when decremented?
-	beq @end	; Yes, so we're done.
-	bra @next	; No, so get the next nibble.
-@auto:
-	ldb #1		; Enable auto digit count.
-@next:
-	lsr #4		; Is the next nibble, a zero?
-	beq @isauto1	; Yes, so check if auto digit count is enabled.
-	bra @loop	; No, so print the next digit.
-@isauto1:
-	cpb #1		; Is auto digit count enabled?
-	beq @end	; Yes, so we're done.
-	bra @loop	; No, so keep printing more digits.
+	and x, x	; Is the auto digit count flag set?
+	bne @end	; Yes, so we're done.
+@loop1:
+	cpx #1		; Is the auto digit count flag set?
+	sbc f, #0	; Decrement the digit count if not.
+	mov y, f	; Get the digit count.
+	or  y, x	; Are both the digit count, and the auto digit count flag zero?
+	bne @loop	; No, so keep looping.
 @end:
+	ply.q		; Restore Y.
+	plx.q		; Restore X.
+	plb.q		; Restore B.
 	rts		; End of print_hex.
 
 
@@ -147,26 +131,18 @@ charcpy:
 
 
 strcmpg:
-	ldb.w #strcmp	; Get the address of strcmp.
-	phb.q		; Use it for an indirect call.
-	ldb.q ptr	; Get the first pointer.
+	lea strcmp	; Get the address of strcmp.
+	mov.q d, ptr	; Get the first pointer.
 	bra gargs	; Jump to the argument handler.
 strcaseg:
-	ldb.w #strccmp	; Get the address of strcasecmp.
-	phb.q		; Use it for an indirect call.
-	ldb.q ptr	; Get the first pointer.
+	lea strcasecmp	; Get the address of strcasecmp.
+	mov.q d, ptr	; Get the first pointer.
 	bra gargs	; Jump to the argument handler.
 gargs:
-	phb.q		; Use the pointer in B as the first arg.
-	pha.q		; Use the value in A as the second arg.
-	and #0		; reset a.
-	tab		; reset b.
-	jsr (sp+17)	; call the pushed routine.
-	tab		; Preserve the return value.
-	pla.q		; Get the second arg back.
-	pla.q		; Get the first arg back.
-	pla.q		; Get the pushed routine back.
-	tba		; Get the return value back.
+	mov s, a	; Use the value in A as the second arg.
+	and #0		; Reset a.
+	tab		; Reset b.
+	jsr (e)		; Call the pushed routine.
 	rts		; End of gargs.
 
 
@@ -310,11 +286,6 @@ get_ptok:
 
 
 get_ctrlidx:
-;	phe.q		; Preserve E.
-;	cmp #$7F	; Is this a delete character?
-;	beq @del	; Yes, so return the same value as backspace.
-;	sec		; Do a non borrowing subtract.
-;	sbc #8		; Subtract 8 from the character, to get the index.
 	sub #8		; Subtract 8 from the character, to get the index.
 	tax		; Copy the index to X.
 	and #0		; Reset A.
@@ -324,62 +295,41 @@ get_ctrlidx:
 	leq (e)		;
 	cmp #$7F	; Is this a delete character?
 	leq #2		; Return 2 if this is the delete character.
-;	bcc @get_rtval	; Yes, so get the return value from the table.
-;	beq @get_rtval	;
-;	ple.q		; Restore E.
 	rts		; End of get_ctrlidx.
-;@get_rtval:
-;	lda ct_rtb, x	; Get the return value from the table.
-;	rts		; End of get_ctrlidx.
-;@del:
-;	lda #2		; Return 2.
-;	rts		; End of get_ctrlidx.
 
 
 findramend:
-	phx.q		; Preserve X.
 	and #0		; Reset A.
-	lda #MAGIC	; Set A to a magic number.
 @loop:
-	ldx (e)		; Preserve the value.
-	sta (e)		; Write the magic number to the current end of RAM.
-	cmp (e)		; Is the value in RAM, the same as the magic number we wrote?
+	mov a, (d)	; Preserve the value.
+	mov (d), #MAGIC	; Write the magic number to the current end of RAM.
+	cmp (d), #MAGIC	; Is the value in RAM, the same as the magic number we wrote?
 	bne @moveback	; No, so move back until we find the last writable memory location.
-	stx (e)		; Yes, so restore the previous value.
-	ade.w #$4000	; Increment the end of RAM pointer by 16K.
+	mov (d), a	; Yes, so restore the previous value.
+	add.w d, #$4000	; Increment the end of RAM pointer by 16K.
 	bra @loop	; Keep looping.
 @moveback:
-	dee		; Decrement the end of RAM pointer.
-	ldx (e)		; Preserve the value.
-	sta (e)		; Write the magic number to the current end of RAM.
-	cmp (e)		; Is the value in RAM, the same as the magic number we wrote?
+	dec d		; Decrement the end of RAM pointer.
+	mov a, (d)	; Preserve the value.
+	mov (d), #MAGIC	; Write the magic number to the current end of RAM.
+	cmp (d), #MAGIC	; Is the value in RAM, the same as the magic number we wrote?
 	bne @moveback	; No, so keep looping.
-	stx (e)		; Yes, so restore the previous value.
+	mov (d), a	; Yes, so restore the previous value.
 @end:
-	phe.q		; Return the end of RAM pointer.
-	pla.q		;
-	plx.q		; Restore X.
+	mov a, d	; Return the end of RAM pointer.
 	rts		; End of findramend.
 
 
 print_sfast:
-;	inc step	;
-	pea (buffer), y	; Push the address of the cursor's postion in the screen buffer to the stack.
+	pha.q			; Preserve A.
+	and #0			; Reset A.
 @loop:
-	lda (e)		; Get the character.
-	beq @end	; We've hit the end of the string, so we're done.
-	cmp #'\n'	; Did we get a newline?
-	beq @nl		; Yes, so move the cursor to the next line.
-	sta (sp+1)	; Print the character to the screen buffer.
-	sta scr		; Print the character to the screen.
-	inc scr_col	; Move the cursor left by one character.
-	ine		; Increment the string pointer.
-	inc.q sp+1	; Increment the screen buffer pointer.
-	bra @loop	; Keep looping.
-@nl:
-	stz scr_col	; Move the cursor to the start of the line.
-	inc scr_row	; Move the cursor down by one line.
-	bra @loop	; Keep looping.
+	inc			; Increment the index.
+	cmp (d+a-1), #0		; Did we hit the end of the string?
+	beq @end		; Yes, so we're done.
+	mov (s+a-1), (d+a-1)	; No, so print the character to the buffer.
+	mov scr, (d+a-1)	; Print the character to the screen.
+	bra @loop		; Keep looping.
 @end:
-	ads #8		; Cleanup the stack frame.
-	rts		; End of print_sfast.
+	pla.q			; Restore A.
+	rts			; End of print_sfast.