changeset 0:605ff82c4618

Initial check in with cleaned up sources This is the initial check in the source code in a state where it builds byte accurate copies of all the various ROM versions included.
author William Astle <lost@l-w.ca>
date Sat, 08 Dec 2018 19:57:01 -0700
parents
children 704b2c9dc19e
files .hgignore 00README.txt Makefile bas10.s bas11.s bas12.s bas13.s defs.s disk.s exbas10.s exbas11.s secb.s
diffstat 12 files changed, 40310 insertions(+), 0 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgignore	Sat Dec 08 19:57:01 2018 -0700
@@ -0,0 +1,4 @@
+syntax: glob
+*~
+*.rom
+*.list
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/00README.txt	Sat Dec 08 19:57:01 2018 -0700
@@ -0,0 +1,82 @@
+The source files here build to byte accurate versions of the following ROMs
+that are found in various Color Computers:
+
+Color Basic 1.0
+Color Basic 1.1
+Color Basic 1.2
+Color Basic 1.3
+Extended Color Basic 1.0
+Extended Color Basic 1.1
+Extended Color Basic 2.0 (Coco3)
+Disk Extended Color Basic 1.0 (shows 2.0 on the Coco3)
+Disk Extended Color Basic 1.1 (shows 2.1 on the Coco3)
+
+The source files are based on the contents of the Unravelled series as
+published by Spectral Associates as updated by Walter K. Zydhek. As such,
+most of the symbols used will line up with those in the Unravelled series.
+There are, however, some significant changes.
+
+* All source has been convered to use a semicolon to introduce comments
+  instead of relying on the implied end of line comments.
+
+* Spaces have been used to line up the columns instead of tabs. 16 spaces
+  are allowed for the label field. 32 spaces are allowed for the instruction
+  (both opcode and operand, separated by a single space) in most cases, and
+  the majority of comments will line up starting at column 49.
+
+* Source code has been largely converted to lower case. This is a personal
+  preference, but it also feels a bit less "shouty". Labels, however, have
+  retained their original case.
+
+* C style hexadecimal constants have been used in most cases.
+
+* Features specific to LWASM have been used to create fairly clean listing
+  files for the various ROMs. LWASM is, of course, required to build the
+  ROMs from this source.
+
+* The comments have been extensively rewritten. Any typos now extant in said
+  comments are entirely the fault of the guy writing them.
+
+* A few cases where numeric addresses were used instead of labels have been
+  corrected.
+
+Comment Accuracy
+================
+
+This is important to point out. While reasonable efforts have been made to
+ensure that the comments accurately reflect what the relevant code is doing,
+there are certainly errors that have crept in, or been duplicated from the
+original disassembly sources.
+
+In some cases, the code is just convoluted enough that no reasonable
+comments can do it justice. This is especially true in relation to the
+floating point implementation.
+
+In other cases, what the code is doing is relatively clear but why it does
+it is not. In other cases, truly understanding what the code is doing
+requires a much more advanced understanding of mathematics or other fields
+than the commenter has. In these cases, inaccurate comments could well be
+present but the commenter would have no way of knowing for sure.
+
+There are also many cases in the original Unravelled comments where the
+comments were just plain wrong or had the sense of a flag or other test
+completely reversed. These have been corrected where they were detected, but
+there is a great deal of code across the combined 96K of ROM code.
+
+Finally, some care has been taken to avoid comments the merely describe what
+the instruction itself does in a manner that could have come right out of a
+CPU reference manual. For instance, an instruction like "STX V4D" is better
+left with no comment rather than writing "store X in V4D".
+
+
+Future Updates
+==============
+
+Since this code is basically frozen, any future modifications will be for
+aesthetic reasons. Most notably, replacing synthetic address based labels
+with more sensible ones would be beneficial. So would replacing variable
+names with more descriptive names since the assembler in use supports much
+longer symbol names.
+
+That said, any updates into the future must preserve the output as byte
+identicial for obvious reasons.
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Makefile	Sat Dec 08 19:57:01 2018 -0700
@@ -0,0 +1,39 @@
+LWASM=lwasm
+
+.PHONY: all
+all: defs.list bas10.rom bas11.rom bas12.rom bas13.rom exbas10.rom exbas11.rom disk10.rom disk11.rom secb.rom
+
+bas10.rom bas10.list: bas10.s defs.s
+	$(LWASM) --raw --list=bas10.list --symbols -o bas10.rom bas10.s
+
+bas11.rom bas11.list: bas11.s defs.s
+	$(LWASM) --raw --list=bas11.list --symbols -o bas11.rom bas11.s
+
+bas12.rom bas12.list: bas12.s defs.s
+	$(LWASM) --raw --list=bas12.list --symbols -o bas12.rom bas12.s
+
+bas13.rom bas13.list: bas13.s defs.s
+	$(LWASM) --raw --list=bas13.list --symbols -o bas13.rom bas13.s
+
+exbas10.rom exbas10.list: exbas10.s defs.s
+	$(LWASM) --raw --list=exbas10.list --symbols -o exbas10.rom exbas10.s
+
+exbas11.rom exbas11.list: exbas11.s defs.s
+	$(LWASM) --raw --list=exbas11.list --symbols -o exbas11.rom exbas11.s
+
+disk10.rom disk10.list: disk.s defs.s
+	$(LWASM) --raw --list=disk10.list --symbols -DDISKVER=0 -o disk10.rom disk.s
+
+disk11.rom disk11.list: disk.s defs.s
+	$(LWASM) --raw --list=disk11.list --symbols -DDISKVER=1 -o disk11.rom disk.s
+
+secb.rom secb.list: secb.s defs.s
+	$(LWASM) --raw --list=secb.list --symbols -o secb.rom secb.s
+
+defs.list: defs.s
+	$(LWASM) --list=defs.list -o defs.bin defs.s
+	rm -f defs.bin
+
+.PHONY: clean
+clean:
+	rm -f *.rom *.list *~
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bas10.s	Sat Dec 08 19:57:01 2018 -0700
@@ -0,0 +1,4064 @@
+                *pragma nolist
+                include defs.s
+                *pragma list
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; COLOR BASIC ROM
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+                org BASIC
+; This is the official set of ROM entry points. It is unfortunate that the generic input ("console in") routine is not exposed
+; here. It is also unfortunate that no open and close file routines are exposed. This and other oversignts led to a lot of
+; software either having to re-invent the wheel or calling directly into the ROM instead of via these official entry points.
+POLCAT          fdb KEYIN                       ; indirect jump, get a keystroke
+CHROUT          fdb PUTCHR                      ; indirect jump, output character
+CSRDON          fdb CASON                       ; indirect jump, turn cassette on and start reading
+BLKIN           fdb GETBLK                      ; indirect jump, read a block from tape
+BLKOUT          fdb SNDBLK                      ; indirect jump, write a block to tape
+JOYIN           fdb GETJOY                      ; indirect jump, read joystick axes
+WRTLDR          fdb WRLDR                       ; indirect jump, turn cassette on and write a leader
+; Initialization code.
+LA00E           lds #LINBUF+LBUFMX+1            ; put the stack in the line input buffer which is a safe place for now
+                lda #0x37                       ; enable the cartidge interrupt (to detect autostarting cartridges)
+                sta PIA1+3
+                lda RSTFLG                      ; get warm start flag
+                cmpa #0x55                      ; is it valid?
+                bne BACDST                      ; brif not - cold start
+                ldx RSTVEC                      ; get warm start routine pointer
+                lda ,x                          ; get first byte of the routine
+                cmpa #0x12                      ; is it NOP?
+                bne BACDST                      ; brif not - the routine is invalid so do a cold start
+                jmp ,x                          ; transfer control to the warm start routine
+; RESET/power on comes here
+RESVEC          ldu #LA00E                      ; point to warm start check code
+LA02A           clrb                            ; use page 0 as direct page
+                tfr b,dp
+                ldx #PIA0                       ; point to PIA0 (keyboard)
+                clr 1,x                         ; enable direction register for PIA0 DA
+                clr 3,x                         ; enable direction register for PIA0 DB
+                clr ,x                          ; set PIA0 DA to input (keyboard rows, comparator)
+                ldd #0xff34
+                sta 2,x                         ; set PIA0 DB to output (keyboard columns)
+                stb 1,x                         ; set PIA0 DA to data mode
+                stb 3,x                         ; set PIA0 DB to data mode
+                ldx #PIA1                       ; point to misc PIA
+                clr 1,x                         ; enable direction register for PIA1 DA
+                clr 3,x                         ; enable direction register for PIA1 DB
+                deca
+                sta ,x                          ; set PIA1 DA as output except for bit 0 (DAC, printer, cassette input)
+                lda #0xf8                       ; set VDG control to output, other bits input (printer handshake, etc.)
+                sta 2,x
+                stb 1,x                         ; enable data mode for PIA1 DA
+                stb 3,x                         ; enable data mode for PIA1 DB
+                clr 2,x                         ; set VDG to alphanumeric
+                lda #2                          ; set rs232 to marking
+                sta ,x
+                lda 2,x                         ; get RAM jumper setting
+                ldx #SAMREG                     ; point to SAM control register
+                ldb #16                         ; 16 bits to clear
+LA05E           sta ,x++                        ; clear a SAM bit
+                decb                            ; done all 16?
+                bne LA05E                       ; brif not
+                sta SAMREG+9                    ; put display at 0x400
+                anda #4                         ; keep only RAMSZ input
+                beq LA06C                       ; brif 4K RAM
+                sta -5,x                        ; set for 16K
+LA06C           jmp ,u                          ; go do warm/cold start
+BACDST          ldx #0                          ; point to start of memory
+LA071           clr ,x+                         ; clear byte
+                cmpx #VIDRAM                    ; at display?
+                bne LA071                       ; brif not
+                jsr LA928                       ; clear screen
+                ldx #LA10D                      ; point to variabl einitializers
+                ldu #CMPMID                     ; point to destination
+                ldb #28
+                jsr LA59A                       ; copy initializers
+                ldu #IRQVEC                     ; point to second destination
+                ldb #30
+                jsr LA59A                       ; copy initializers
+                ldx #LB277                      ; init extended basic's COMVEC stuff to error
+                stx 3,u
+                stx 8,u
+                ldx #RVEC0                      ; point to ram vectors
+                lda #$39                        ; RTS opcode
+LA094           sta ,x+                         ; init a byte
+                cmpx #RVEC0+25*3                ; end of vectors?
+                bne LA094                       ; brif not
+                sta LINHDR-1                    ; set "next line address" in line input buffer to nonzero
+                ldx #VIDRAM+$200                ; point to end of display screen
+                clr ,x+                         ; put a constant zero before start of program
+                stx TXTTAB                      ; set start ofprogram
+LA0AB           lda 2,x                         ; look for end of memory
+                coma
+                sta 2,x
+                cmpa 2,x
+                bne LA0BA                       ; brif it wasn't RAM
+                leax 1,x                        ; move pointer forward
+LA0B6           com 1,x                         ; restore memory value
+                bra LA0AB                       ; check another byte
+LA0BA           stx TOPRAM                      ; set top of memory
+                stx MEMSIZ                      ; set top of string space
+                stx STRTAB                      ; set bottom of allocated string space
+                leax -200,x                     ; allocate 200 bytes for string space
+                stx FRETOP                      ; save top of free memory
+                tfr x,s                         ; put the stack there too
+                jsr LAD19                       ; do a "NEW"
+                ldx #'E*256+'X                  ; magic number to detect ECB ROM
+                cmpx EXBAS                      ; is there an ECB ROM?
+                lbeq EXBAS+2                    ; brif so - launch it
+                andcc #0xaf                     ; start interrupts
+                ldx #LA147-1                    ; point to sign on message
+                jsr LB99C                       ; print it out
+                ldx #BAWMST                     ; warm start routine address
+                stx RSTVEC                      ; set vector there
+                lda #0x55                       ; warm start valid flag
+                sta RSTFLG                      ; mark warm start valid
+                bra LA0F3                       ; go to direct mode
+; Warm start entry point
+BAWMST          nop                             ; valid routine marker
+                clr DEVNUM                      ; reset output/input to screen
+                jsr LAD33                       ; do a partial NEW
+                andcc #0xaf                     ; start interrupts
+                jsr LA928                       ; clear the screen
+LA0F3           jmp LAC73                       ; go to direct mode
+; FIRQ service routine - this handles starting autostart cartridges
+BFRQSV          tst PIA1+3                      ; is it the cartridge interrupt?
+                bmi LA0FC                       ; brif so
+                rti
+LA0FC           jsr LA7D1                       ; delay for a while
+                jsr LA7D1                       ; delay for another while
+                ldu #LA108                      ; point to cartridge starter
+                jmp LA02A                       ; go initialize everything clean for the cartridge
+LA108           clr RSTFLG                      ; force a cold start a cartridge reset
+                jmp ROMPAK                      ; transfer control to the cartridge
+; Variable initializers (first batch)
+LA10D           fcb 18                          ; mid band partition of the 1200/2400 Hz period
+                fcb 24                          ; upper limit of 1200 Hz period
+                fcb 10                          ; upper limit of 2400 Hz period
+                fdb 128                         ; number of 0x55s for cassette leader
+                fcb 11                          ; cursor blink delay
+                fdb 87                          ; 600 baud delay constant
+                fdb 1                           ; printer carriage return delay constant
+                fcb 16                          ; printer tab field width
+                fcb 112                         ; last printer tab zone
+                fcb 132                         ; printer carriage width
+                fcb 0                           ; printer carriage position
+                fdb LB44A                       ; default execution address for EXEC
+                inc CHARAD+1                    ;* character fetching routines (DP portion) - we first do a two
+                bne LA123                       ;* two stage increment of CHARAD then load the value into A
+                inc CHARAD                      ;* before transferring control to the bottom half routine in ROM
+LA123           lda >0                          ; NOTE: the 0 is a placeholder, extended addressing is required
+                jmp BROMHK
+; Variable initializers (second batch)
+                jmp BIRQSV                      ; IRQ handler
+                jmp BFRQSV                      ; FIRQ handler
+                jmp LB44A                       ; default USR() address
+                fcb 0x80,0x4f,0xc7,0x52,0x59    ; random seed
+                fcb 0xff                        ; capslock flag - default to upper case
+                fdb DEBDEL                      ; keyboard debounce delay (why is it a variable?)
+                jmp LB277                       ; exponentiation handler vector
+                fcb 53                          ; (command interpretation table) 53 commands
+                fdb LAA66                       ; (command interpretation table) reserved words list (commands)
+                fdb LAB67                       ; (command interpretation table) jump table (commands)
+                fcb 20                          ; (command interpretation table) 20 functions
+                fdb LAB1A                       ; (command interpretation table) reserved words list (functions)
+                fdb LAA29                       ; (command interpretation table) jump table (functions)
+; This is the signon message.
+LA147           fcc 'COLOR BASIC 1.0'
+                fcb 0x0d
+                fcc '(C) 1980 TANDY'
+                fcb 0
+; This is the "invalid colour" CLS easter egg text. Basically 11 wasted bytes
+LA166           fcc 'MICROSOFT'
+                fcb 0x0d,0
+; Read a character from current device and mask off bit 7 (keep it as 7 bit ASCII)
+LA171           bsr LA176                       ; get character
+                anda #0x7f                      ; mask off high bit
+                rts
+; Generic read routine. Reads a character from the device specified by DEVNUM. If no input was available,
+; CINBFL will bet nonzero (on EOF). If input was available, CINBFL will be zero. Note that this routine
+; has undefined results when called on an output only device. All registers except CC and A are preserved.
+LA176           jsr RVEC4                       ; do RAM hook
+                clr CINBFL                      ; flag data available
+                tst DEVNUM                      ; is it keyboard?
+                beq LA1B1                       ; brif so - blink cursor and wait for key press
+                tst CINCTR                      ; is there anything in cassette input buffer?
+                bne LA186                       ; brif so
+                com CINBFL                      ; flag EOF
+                rts
+; Read character from cassette file
+LA186           pshs u,y,x,b                    ; preserve registers
+                ldx CINPTR                      ; get input buffer pointer
+                lda ,x+                         ; get character from buffer
+                pshs a                          ; save it for return
+                stx CINPTR                      ; save new input buffer pointer
+                dec CINCTR                      ; count character just consumed
+                bne LA197                       ; brif buffer is not empty yet
+                jsr LA635                       ; go read another block, if any, to refill the buffer
+LA197           puls a,b,x,y,u,pc               ; restore registers and return the character
+; Blink the cursor. This might be better timed via an interrupt or something.
+LA199           dec BLKCNT                      ; is it time to blink the cursor?
+                bne LA1AB                       ; brif not
+                ldb #11                         ; reset blink timer
+                stb BLKCNT
+                ldx CURPOS                      ; get cursor position
+                lda ,x                          ; get character at the cursor
+                adda #0x10                      ; move to next color
+                ora #0x8f                       ; make sure it's a grahpics block with all elements lit
+                sta ,x                          ; put new cursor block on screen
+LA1AB           ldx #DEBDEL                     ; we'll use the debounce delay for the cursor blink timer (10ms)
+LA1AE           jmp LA7D3                       ; go count X down
+; Blink cursor while waiting for a key press
+LA1B1           pshs x,b                        ; save registers
+LA1B3           bsr LA199                       ; go do a cursor iteration
+                bsr KEYIN                       ; go read a key
+                beq LA1B3                       ; brif no key pressed
+                ldb #0x60                       ; VDG screen space character
+                stb [CURPOS]                    ; blank cursor out
+                puls b,x,pc                     ; restore registers and return
+; This is the actual keyboard polling routine. Returns 0 if no new key is down. This version of the
+; routine has a few issues which are finally fixed mostly properly in Color Basic 1.2
+KEYIN           pshs x,b                        ; save registers
+                bsr LA1C8                       ; get keystroke
+                tsta                            ; set flags
+                puls b,x,pc                     ; restore registers and return
+LA1C8           leas -3,s                       ; make temp storage space
+                ldx #KEYBUF                     ; point to keyboard state table
+                clr 0,s                         ; reset column counter
+                ldb #0xfe                       ; set column strobe to first column
+                stb PIA0+2                      ; set strobe
+LA1D4           bsr LA238                       ; read keyboard data
+                sta 1,s                         ; save keyboard data
+                eora ,x                         ; set any bit where a key state changed
+                anda ,x                         ; ignore any where a key was released
+                ldb 1,s                         ; get new key data
+                stb ,x+                         ; save in state table
+                tsta                            ; was a key down?
+                bne LA1ED                       ; brif so
+                inc 0,s                         ; bump column counter
+                comb                            ; set C
+                rol PIA0+2                      ; move column strobe over
+                bcs LA1D4                       ; brif not done all columns
+                puls b,x,pc                     ; restore registers and return
+LA1ED           ldb PIA0+2                      ; get strobe data
+                stb 2,s                         ; save it
+                ldb #0xf8                       ; make sure B is 0 after first ADDB
+LA1F4           addb #8                         ; move to next row base
+                lsra                            ; at the right row base?
+                bcc LA1F4                       ; brif not
+                addb 0,s                        ; add in column offset
+                beq LA245                       ; brif @
+                cmpb #26                        ; alpha?
+                bhi LA247                       ; brif not
+                orb #0x40                       ; add in uppercase ASCII bias
+                bsr LA22D                       ; get shift status
+                beq LA20E                       ; brif shift down
+                lda CASFLG                      ; check casplock
+                bne LA20E                       ; brif not caps mode
+                orb #0x20                       ; convert to lower case
+LA20E           stb 0,s                         ; save ASCII value for return later
+                ldx DEBVAL                      ; get debounce delay
+                jsr LA7D3                       ; count X down
+                ldb 2,s                         ; get column strobe data
+                stb PIA0+2                      ; re-set strobe
+                bsr LA238                       ; read row data
+                cmpa 1,s                        ; does it match the result from before the delay?
+                puls a                          ; get back key code (return value)
+                bne LA22A                       ; brif not the same result
+                cmpa #0x12                      ; is it SHIFT-0?
+                bne LA22B                       ; brif not
+                com CASFLG                      ; flip capslock state
+LA22A           clra                            ; set Z, return 0 for no key down
+LA22B           puls x,pc                       ; clean up stack and return
+LA22D           lda #0x7f                       ; column strobe for SHIFT
+                sta PIA0+2                      ; strobe keyboard
+                lda PIA0                        ; get row data
+                anda #0x40                      ; keep only shift data
+                rts
+LA238           lda PIA0                        ; read row data
+                ora #0x80                       ; mask comparator
+                tst PIA0+2                      ; reading column 7?
+                bmi LA244                       ; brif not
+                ora #0xc0                       ; mask off SHIFT as well
+LA244           rts
+LA245           ldb #51                         ; code for @
+LA247           ldx #CONTAB-0x36                ; point to control code table, first batch
+                cmpb #33                        ; arrows, space, zero?
+                blo LA264                       ; brif not
+                ldx #CONTAB-0x54                ; point to control code table, second batch
+                cmpb #48                        ; enter, clear, break, @?
+                bhs LA264                       ; brif so
+                bsr LA22D                       ; get shift state
+                cmpb #43                        ; number, colon, semicolon?
+                bls LA25D                       ; brif so
+                eora #0x40                      ; invert shift state
+LA25D           tsta                            ; test shift status
+                beq LA20E                       ; brif shift down - we have a result so debounce things
+                addb #0x10                      ; add in ASCII offset correction
+                bra LA20E                       ; go debounce things
+LA264           aslb                            ; two bytes per entry
+                bsr LA22D                       ; test shift state
+                bne LA26A                       ; brif not shift
+                incb                            ; select shifted entry
+LA26A           ldb b,x                         ; get return value
+                bra LA20E                       ; go debounce keyboard
+CONTAB          fcb 0x5e,0x5f                   ; <UP> (^, _)
+                fcb 0x0a,0x5b                   ; <DOWN> (LF, [)
+                fcb 0x08,0x15                   ; <LEFT> (BS, ^U)
+                fcb 0x09,0x5d                   ; <RIGHT> (TAB, ])
+                fcb 0x20,0x20                   ; <SPACE>
+                fcb 0x30,0x12                   ; <0> (0, ^R)
+                fcb 0x0d,0x0d                   ; <ENTER> (CR, CR)
+                fcb 0x0c,0x5c                   ; <CLEAR> (FF, \)
+                fcb 0x03,0x03                   ; <BREAK> (^C, ^C)
+                fcb 0x40,0x13                   ; <@> (@, ^S)
+; Generic output routine.
+; Output character in A to the device specified by DEVNUM. All registers are preserved except CC.
+; Sending output to a device that does not support output is undefined.
+PUTCHR          jsr RVEC3                       ; call RAM hook
+                pshs b                          ; save B
+                ldb DEVNUM                      ; get desired device number
+                incb                            ; set flags (Z for -1, etc.)
+                puls b                          ; restore B
+                bmi LA2BF                       ; brif < -1 (line printer)
+                bne LA30A                       ; brif > -1 (screen)
+; Write character to tape file
+                pshs x,b,a                      ; save registers
+                ldb FILSTA                      ; get file status
+                decb                            ; input file?
+                beq LA2A6                       ; brif so
+                ldb CINCTR                      ; get character count
+                incb                            ; account for this character
+                bne LA29E                       ; brif buffer not full
+                bsr LA2A8                       ; write previously full block to tape
+LA29E           ldx CINPTR                      ; get output buffer pointer
+                sta ,x+                         ; put character in output
+                stx CINPTR                      ; save new buffer pointer
+                inc CINCTR                      ; account for this character
+LA2A6           puls a,b,x,pc                   ; restore registers and return
+; Write a block of data to tape.
+LA2A8           ldb #1                          ; data block type
+LA2AA           stb BLKTYP                      ; set block type
+                ldx #CASBUF                     ; point to output buffer
+                stx CBUFAD                      ; set buffer pointer
+                ldb CINCTR                      ; get number of bytes in the block
+                stb BLKLEN                      ; set length to write
+                pshs u,y,a                      ; save registers
+                jsr LA7E5                       ; write a block to tape
+                puls a,y,u                      ; restore registers
+                jmp LA650                       ; reset buffer pointers
+; This routine is changed to send 8 bits of data as of Color Basic 1.1.
+; Color Basic 1.2 adds a handshake ; before sending any data.
+LA2BF           pshs x,b,a,cc                   ; save registers and interrupt status
+                orcc #0x50                      ; disable interrupts
+                bsr LA2FB                       ; set to marking (stop bit)
+                asla                            ; send 7 data bits, one start bit
+                ldb #8                          ; 8 bits to send
+LA2C8           pshs b                          ; save bit counter
+                clrb                            ; initialize output byte
+                lsra                            ; get output bit to C
+                rolb                            ; now move it to the right bit in the output
+                rolb
+                stb PIA1                        ; send bit to printer
+                bsr LA302                       ; do the baud delay (this delay is improved in later versions)
+                nop
+                nop
+                nop
+                bsr LA302
+                puls b                          ; get bit counter back
+                decb                            ; sent all 8 bits?
+                bne LA2C8                       ; brif not
+                bsr LA2FB                       ; send stop bit
+                puls cc,a                       ; restore output character and interrupt status
+                cmpa #0x0d                      ; carriage return?
+                beq LA2ED                       ; brif so
+                inc LPTPOS                      ; bump output position
+                ldb LPTPOS                      ; get new position
+                cmpb LPTWID                     ; at end of line?
+                blo LA2F3                       ; brif not
+LA2ED           clr LPTPOS                      ; reset output position to start of line
+                bsr LA305                       ; do carriage return delay
+                bsr LA305
+LA2F3           ldb PIA1+2                      ; read rs232 status
+                lsrb                            ; get status bit to C
+                bcs LA2F3                       ; brif still not ready
+                puls b,x,pc                     ; restore registers and return
+LA2FB           ldb #2                          ; set output to high (marking)
+LA2FD           stb PIA1                        ; set RS232 output
+                bsr LA302                       ; do baud delay (first iteration) then fall through for second
+LA302           ldx LPTBTD                      ; get buard rate delay constant
+                skip2
+LA305           ldx LPTLND                      ; get carriage return delay constant
+                jmp LA7D3                       ; count X down
+; Output character to screen
+LA30A           pshs x,b,a                      ; save registers
+                ldx CURPOS                      ; get cursor pointer
+                cmpa #0x08                      ; backspace?
+                bne LA31D                       ; brif not
+                cmpx #VIDRAM                    ; at top of screen?
+                beq LA35D                       ; brif so - it's a no-op
+                lda #0x60                       ; VDG space character
+                sta ,-x                         ; put a space at previous location and move pointer back
+                bra LA344                       ; save new cursor position and return
+LA31D           cmpa #0x0d                      ; carriage return?
+                bne LA32F                       ; brif not
+                ldx CURPOS                      ; get cursor pointer (why? we already have it)
+LA323           lda #0x60                       ; VDG space character
+                sta ,x+                         ; put output space
+                tfr x,d                         ; see if we at a multiple of 32 now
+                bitb #0x1f
+                bne LA323                       ; brif not
+                bra LA344                       ; go check for scrolling
+LA32F           cmpa #0x20                      ; control character?
+                blo LA35D                       ; brif so
+                tsta                            ; is it graphics block?
+                bmi LA342                       ; brif so
+                cmpa #0x40                      ; number or special?
+                blo LA340                       ; brif so (flip "case" bit)
+                cmpa #0x60                      ; upper case alpha?
+                blo LA342                       ; brif so - keep it unmodified
+                anda #0xdf                      ; clear bit 5 (inverse video)
+LA340           eora #0x40                      ; flip inverse video bit
+LA342           sta ,x+                         ; output character
+LA344           stx CURPOS                      ; save new cursor position
+                cmpx #VIDRAM+511                ; end of screen?
+                bls LA35D                       ; brif not
+                ldx #VIDRAM                     ; point to start of screen
+LA34E           ldd 32,x                        ; get two characters from next row
+                std ,x++                        ; put them on this row
+                cmpx #VIDRAM+0x1e0              ; at start of last row on screen?
+                blo LA34E                       ; brif not
+                ldb #0x60                       ; VDG space
+                jsr LA92D                       ; blank out last line (borrow CLS's loop)
+LA35D           puls a,b,x,pc                   ; restore registers and return
+; Set up device parameters for output
+LA35F           jsr RVEC2                       ; do the RAM hook dance
+                pshs x,b,a                      ; save registers
+                clr PRTDEV                      ; flag device as a screen
+                lda DEVNUM                      ; get devicenumber
+                beq LA373                       ; brif screen
+                inca                            ; is it tape?
+                beq LA384                       ; brif so
+                ldx LPTCFW                      ; get tab width and last tab stop for printer
+                ldd LPTWID                      ; get line width and current position for printer
+                bra LA37C                       ; set parameters
+LA373           ldb CURPOS+1                    ; get LSB of cursor position
+                andb #0x1f                      ; now we have the offset into the line
+                ldx #0x1010                     ; 16 character tab, position 16 is last tab stop
+                lda #32                         ; screen is 32 characters wide
+LA37C           stx DEVCFW                      ; save tab width and last tab stop for active device
+                stb DEVPOS                      ; save line position for current device
+                sta DEVWID                      ; save line width for current device
+                puls a,b,x,pc                   ; restore registers and return
+LA384           com PRTDEV                      ; flag device as non-display
+                ldx #0x0100                     ; tab width is 1, last tab field is 0
+                clra                            ; line width is 0
+                clrb                            ; character position on line is 0
+                bra LA37C                       ; go set parameters
+; This is the line input routine used for reading lines for Basic, both in immediate mode and for
+; INPUT and LINE INPUT. Exit with C set if terminated by BREAK and C clear if terminated by ENTER.
+; The actualy entry point is LA390. Note that this routine echoes to *all* devices.
+LA38D           jsr LA928                       ; clear screen (CLEAR key handling)
+LA390           jsr RVEC12                      ; do the RAM hook dance
+                clr IKEYIM                      ; reset cached input character from BREAK check
+                ldx #LINBUF+1                   ; point to line input buffer (input pointer)
+                ldb #1                          ; Number of characters in line (we start at 1 so BS handling is easier)
+LA39A           jsr LA171                       ; get an input character, only keep low 7 bits
+                tst CINBFL                      ; is it EOF?
+                bne LA3CC                       ; brif EOF
+                tst DEVNUM                      ; is it keyboard input?
+                bne LA3C8                       ; brif not - don't do line editing
+                cmpa #0x0c                      ; form feed (CLEAR)?
+                beq LA38D                       ; brif so - clear screen and reset
+                cmpa #0x08                      ; backspace?
+                bne LA3B4                       ; brif not
+                decb                            ; move back one character
+                beq LA390                       ; brif we were at the start of the line - reset and start again
+                leax -1,x                       ; move input pointer back
+                bra LA3E8                       ; echo the backspace and continue
+LA3B4           cmpa #0x15                      ; SHIFT-LEFT (kill line)?
+                bne LA3C2                       ; brif not
+LA3B8           decb                            ; at start of line?
+                beq LA390                       ; brif so - reset and restart
+                lda #0x08                       ; echo a backspace
+                jsr PUTCHR
+                bra LA3B8                       ; see if we've erased everything yet
+LA3C2           cmpa #0x03                      ; BREAK?
+                orcc #1                         ; set C if it is (only need Z for the next test
+                beq LA3CD                       ; brif BREAK - exit
+LA3C8           cmpa #0x0d                      ; ENTER (CR)
+                bne LA3D9                       ; brif not
+LA3CC           clra                            ; clear carry (it might not be clear on EOF)
+LA3CD           pshs cc                         ; save ENTER/BREAK flag
+                jsr LB958                       ; echo a carriage return
+                clr ,x                          ; make sure we have a NUL at the end of the buffer
+                ldx #LINBUF                     ; point to input buffer
+                puls cc,pc                      ; restore ENTER/BREAK flag and return
+LA3D9           cmpa #0x20                      ; control character?
+                blo LA39A                       ; brif so - skip it
+                cmpa #'z+1                      ; above z?
+                bhs LA39A                       ; brif so - ignore it
+                cmpb #LBUFMX                    ; is the buffer full?
+                bhs LA39A                       ; brif so - ignore extra characters
+                sta ,x+                         ; put character in the buffer
+                incb                            ; bump character count
+LA3E8           jsr PUTCHR                      ; echo character
+                bra LA39A                       ; go handle next input character
+; Check if DEVNUM Is valid for reading. Raise FM error if open but not for reading. NO error if not open.
+LA3ED           jsr RVEC5                       ; do the RAM hook dance
+                lda DEVNUM                      ; get device number
+                beq LA415                       ; brif keyboard - always valid
+                inca                            ; is it tape?
+                bne LA403                       ; brif not
+                lda FILSTA                      ; get tape file status
+                bne LA400                       ; brif file is open
+LA3FB           ldb #22*2                       ; raise NO error
+                jmp LAC46
+LA400           deca                            ; is it in input mode?
+                beq LA415                       ; brif so
+LA403           jmp LA616                       ; raise FM error
+; Check if DEVNUM is valid for writing. Raise FM error if open but not for writing. NO error if not open.
+LA406           jsr RVEC6                       ; do the RAM hook dance
+                lda DEVNUM                      ; get device number
+                inca                            ; is it tape?
+                bne LA415                       ; brif not
+                lda FILSTA                      ; get file status
+                beq LA3FB                       ; brif not open
+                deca                            ; is it open for reading?
+                beq LA403                       ; brif so - bad mode
+LA415           rts
+; CLOSE command
+CLOSE           beq LA426                       ; brif no file specified - close all files
+                jsr LA5A5                       ; parse device number
+LA41B           bsr LA42D                       ; close specified file
+                jsr GETCCH                      ; is there more?
+                beq LA44B                       ; brif not
+                jsr LA5A2                       ; check for comma and parse another device number
+                bra LA41B                       ; go close this one
+; Close all files handler.
+LA426           jsr RVEC7                       ; Yup. The RAM hook dance.
+                lda #-1                         ; start with tape file
+                sta DEVNUM
+; Close file specified in DEVNUM. Note that this never fails.
+LA42D           jsr RVEC8                       ; You know it. RAM hook.
+                lda DEVNUM                      ; get device we're closing
+                clr DEVNUM                      ; reset to screen/keyboard
+                inca                            ; is it tape?
+                bne LA44B                       ; brif not
+                lda FILSTA                      ; get file status
+                cmpa #2                         ; is it output?
+                bne LA449                       ; brif not
+                lda CINCTR                      ; is there anything waiting to be written?
+                beq LA449                       ; brif not
+                jsr LA2A8                       ; write final block of data
+LA444           ldb #0xff                       ; write EOF block
+                jsr LA2AA
+LA449           clr FILSTA                      ; mark tape file closed
+LA44B           rts
+; CSAVE command
+CSAVE           jsr LA578                       ; parse filename
+                jsr GETCCH                      ; see what we have after the file name
+                beq LA469                       ; brif none
+                jsr LB26D                       ; make sure there's a comma
+                ldb #'A                         ; make sure there's an A after
+                jsr LB26F
+                bne LA44B                       ; brif not end of line
+                clra                            ; file type 0 (basic program)
+                jsr LA65C                       ; write out header block
+                lda #-1                         ; set output to tape
+                sta DEVNUM
+                clra                            ; set Z so we list the whole program
+                jmp LIST                        ; go list the program to tape
+LA469           clra                            ; file type 0 (basic program)
+                ldx ZERO                        ; set to binary file mode
+                jsr LA65F                       ; write header block
+                clr FILSTA                      ; close files
+                inc BLKTYP                      ; set block type to data
+                jsr WRLDR                       ; write out a leader
+                ldx TXTTAB                      ; point to start of program
+LA478           stx CBUFAD                      ; set buffer location
+                lda #255                        ; block size to 255 bytes (max size)
+                sta BLKLEN
+                ldd VARTAB                      ; get end of program
+                subd CBUFAD                     ; how much is left?
+                beq LA491                       ; brif we have nothing left
+                cmpd #255                       ; do we have a full block worth?
+                bhs LA48C                       ; brif so
+                stb BLKLEN                      ; save actual remainder as block length
+LA48C           jsr SNDBLK                      ; write a block out
+                bra LA478                       ; go do another block
+LA491           neg BLKTYP                      ; set block type to 0xff (EOF)
+                clr BLKLEN                      ; no data in EOF block
+                jmp LA7E7                       ; write EOF, stop tape, and return
+; CLOAD and CLOADM commands
+CLOAD           clr FILSTA                      ; close tape file
+                cmpa #'M                        ; is it ClOADM?
+                beq LA4FE                       ; brif so
+                leas 2,s                        ; clean up stack
+                jsr LA5C5                       ; parse file name
+                jsr LA648                       ; go find the file
+                tst CASBUF+10                   ; is it binary?
+                beq LA4C8                       ; brif so
+                lda CASBUF+9                    ; is it ASCII?
+                beq LA4CD                       ; brif not
+                jsr LAD19                       ; clear out existing program
+                lda #-1                         ; set up for reading from tape
+                sta DEVNUM
+                inc FILSTA                      ; set tape file to input
+                jsr LA635                       ; go read first block
+                jmp LAC7C                       ; go to immediate mode to read in the program
+; This is the EOF handler for immediate mode. It's rather assinine for this to be located here. It is
+; probably an artifact of a substantially different code layout prior to compacting the ROM to fit in
+; 8K.
+LA4BF           jsr RVEC13                      ; do the RAM hook dance
+                jsr LA42D                       ; close file
+                jmp LAC73                       ; go back to immediate mode
+LA4C8           lda CASBUF+8                    ; get file type
+                beq LA4D0                       ; brif basic program
+LA4CD           jmp LA616                       ; raise FM error
+LA4D0           jsr LAD19                       ; erase existing program
+                jsr CASON                       ; start reading tape
+                ldx TXTTAB                      ; get start of program storage
+LA4D8           stx CBUFAD                      ; set load address for block
+                ldd CBUFAD                      ; get start of block
+                inca                            ; bump by 256
+                jsr LAC37                       ; check if there's room for a maximum sized block of 255
+                jsr GETBLK                      ; go read a block
+                bne LA4F8                       ; brif there was an error during reading
+                lda BLKTYP                      ; get type of block read
+                beq LA4F8                       ; brif header block - IO error
+                bpl LA4D8                       ; brif data block - read another
+                stx VARTAB                      ; save new end of program
+                bsr LA53B                       ; stop tape
+                ldx #LABED-1                    ; point to "OK" prompt
+                jsr LB99C                       ; show prompt
+                jmp LACE9                       ; reset various things and return
+LA4F8           jsr LAD19                       ; clear out partial program load
+LA4FB           jmp LA619                       ; raise IO error
+; This is the CLOADM command
+LA4FE           jsr GETNCH                      ; eat the "M"
+                bsr LA578                       ; parse file name
+                jsr LA648                       ; go find the file
+LA505           ldx ZERO                        ; default offset is 0
+                jsr GETCCH                      ; see if there's something after the file name
+                beq LA511                       ; brif no offset
+                jsr LB26D                       ; make sure there's a comma
+                jsr LB73D                       ; evaluate offset to X
+LA511           lda CASBUF+8                    ; get file mode
+                cmpa #2                         ; M/L program?
+                bne LA4CD                       ; brif not - FM error
+                ldd CASBUF+11                   ; get load address
+                leau D,x                        ; add in offset
+                stu EXECJP                      ; set EXEC default address
+                tst CASBUF+10                   ; is it binary?
+                bne LA4CD                       ; brif not
+                ldd CASBUF+13                   ; get load address
+                leax d,x                        ; add in offset
+                stx CBUFAD                      ; set buffer address for loading
+                jsr CASON                       ; start up tape
+LA52E           jsr GETBLK                      ; read a block
+                bne LA4FB                       ; brif error reading
+                stx CBUFAD                      ; save new load address
+                tst BLKTYP                      ; set flags on block type
+                beq LA4FB                       ; brif another header - IO error
+                bpl LA52E                       ; brif it was data - read more
+LA53B           jmp LA7E9                       ; turn off tape and return
+; The EXEC command
+EXEC            beq LA545                       ; brif no argument - use default address
+                jsr LB73D                       ; evaluate EXEC address to X
+                stx EXECJP                      ; set new default EXEC address
+LA545           jmp [EXECJP]                    ; transfer control to execution address
+; Break check for LIST so it doesn't interrupt ASCII saves. Why is this here instead of with the rest of the break
+; check logic or packaged up with LIST?
+LA549           jsr RVEC11                      ; do the RAM hook dance
+                lda DEVNUM                      ; get device number
+                inca                            ; is it tape?
+                beq LA5A1                       ; brif so - don't do break check
+                jmp LADEB                       ; do the actual break check
+; Evaluate an expression and make sure it is within the limits of the screen and sets the cursor position.
+; This really should be located with the PRINT command.
+LA554           jsr LB3E4                       ; evaluate a positive expression to D
+                subd #511                       ; is it within bounds?
+                lbhi LB44A                      ; brif not - error out
+                addd #VIDRAM+511                ; adjust to be within the screen (and undo the SUBD above)
+                std CURPOS                      ; set cursor position
+                rts
+; INKEY$ function
+INKEY           lda IKEYIM                      ; was a key down during break check?
+                bne LA56B                       ; brif so
+                jsr KEYIN                       ; poll the keyboard
+LA56B           clr IKEYIM                      ; reset the break check cache
+                sta FPA0+3                      ; store result for later return
+                lbne LB68F                      ; brif a key was down - return it as a string
+                sta STRDES                      ; set string length to 0 (no key down)
+                jmp LB69B                       ; return the NULL string
+; Parse a filename
+LA578           ldx #CFNBUF                     ; point to file name buffer
+                clr ,x+                         ; zero out file name length
+                lda #0x20                       ; space character to initialize file name
+LA57F           sta ,x+                         ; put a space in the buffer
+                cmpx #CASBUF                    ; at end of file name?
+                bne LA57F                       ; brif not
+                jsr GETCCH                      ; get input character
+                beq LA5A1                       ; brif no name present
+                jsr LB156                       ; evaluate the file name expression
+                jsr LB654                       ; point to start of the file name
+                ldu #CFNBUF                     ; point to file name buffer
+                stb ,u+                         ; save string length
+                beq LA5A1                       ; brif empty - we're done
+                skip2
+LA598           ldb #8                          ; copy 8 bytes
+; Move B bytes from (X) to (U)
+LA59A           lda ,x+                         ; copy a byte
+                sta ,u+
+                decb                            ; done yet?
+                bne LA59A                       ; brif not
+LA5A1           rts
+; Parse a device number and check validity
+LA5A2           jsr LB26D                       ; check for comma and SN error if not
+LA5A5           cmpa #'#                        ; do we have a #?
+                bne LA5AB                       ; brif not (it's optional)
+                jsr GETNCH                      ; munch the #
+LA5AB           jsr LB141                       ; evaluate the expression
+LA5AE           jsr INTCNV                      ; convert it to an integer in D
+                rolb                            ; move sign of B into C
+                adca #0                         ; add sign of B to A
+                bne LA61F                       ; brif A doesn't match the sign of B
+                rorb                            ; restore B (ADCA will have set C if B was negative)
+                stb DEVNUM                      ; set device number
+                jsr RVEC1                       ; do the RAM hook dance
+                beq LA5C4                       ; brif device number set to screen/keyboard (valid)
+                bpl LA61F                       ; brif not negative (not valid)
+                cmpb #-2                        ; is it printer or tape?
+                blt LA61F                       ; brif not (not valid)
+LA5C4           rts
+; Read file name from the line and do an error if anything follows it
+LA5C5           bsr LA578                       ; parse file name
+                jsr GETCCH                      ; set flags on current character
+LA5C9           beq LA5C4                       ; brif nothing there - it's good
+                jmp LB277                       ; raise SN error
+; EOF functoin
+EOF             jsr RVEC14                      ; do the RAM hook dance
+                lda DEVNUM                      ; get device number
+                pshs a                          ; save it (so we can restore it later)
+                bsr LA5AE                       ; check the device number (which is in FPA0)
+                jsr LA3ED                       ; check validity for reading
+LA5DA           clrb                            ; not EOF = 0 (FALSE)
+                lda DEVNUM                      ; get device number
+                beq LA5E4                       ; brif keyboard - never EOF
+                tst CINCTR                      ; is there anything in the input buffer?
+                bne LA5E4                       ; brif so - not EOF
+                comb                            ; set EOF flag to -1 (true)
+LA5E4           puls a                          ; get back original device
+                sta DEVNUM                      ; restore it
+LA5E8           sex                             ; sign extend result to 16 bits
+                jmp GIVABF                      ; go return the result
+; SKIPF command
+SKIPF           bsr LA5C5                       ; parse file name
+                bsr LA648                       ; look for the file
+                jsr LA6D1                       ; read the file
+                bne LA619                       ; brif error reading file
+                rts
+; OPEN command
+OPEN            jsr RVEC0                       ; do the RAM hook dance
+                jsr LB156                       ; get file status (input/output)
+                jsr LB6A4                       ; get first character of status string
+                pshs b                          ; save status
+                bsr LA5A2                       ; parse a comma then the device number
+                jsr LB26D                       ; make sure there's a comma
+                bsr LA5C5                       ; parse the file name
+                lda DEVNUM                      ; get device number of the file
+                clr DEVNUM                      ; reset actual device to the screen
+                puls b                          ; get back status
+                cmpb #'I                        ; INPUT?
+                beq LA624                       ; brif so - open a file for INPUT
+                cmpb #'O                        ; OUTPUT?
+                beq LA658                       ; brif so - open a file for OUTPUT
+LA616           ldb #21*2                       ; raise FM error
+                skip2
+LA619           ldb #20*2                       ; raise I/O error
+                skip2
+LA61C           ldb #18*2                       ; raise AO error
+                skip2
+LA61F           ldb #19*2                       ; raise DN error
+                jmp LAC46
+LA624           inca                            ; are we opening the tape?
+                bmi LA616                       ; brif printer - FM error; printer can't be opened for READ
+                bne LA657                       ; brif screen - screen is always open
+                bsr LA648                       ; read header block
+                lda CASBUF+9                    ; clear A if binary or machine language file
+                anda CASBUF+10
+                beq LA616                       ; bad file mode if not data file
+                inc FILSTA                      ; open file for input
+LA635           jsr LA701                       ; start tape, read block           
+                bne LA619                       ; brif error during read
+                tst BLKTYP                      ; check block type
+                beq LA619                       ; brif header block - something's wrong
+                bmi LA657                       ; brif EOF
+                lda BLKLEN                      ; get length of block
+                beq LA635                       ; brif empty block - read another
+LA644           sta CINCTR                      ; set buffer count
+                bra LA652                       ; reset buffer pointer
+LA648           tst FILSTA                      ; is the file open?
+                bne LA61C                       ; brif so - AO error
+                bsr LA681                       ; search for file
+                bne LA619                       ; brif error on read
+LA650           clr CINCTR                      ; mark buffer empty
+LA652           ldx #CASBUF                     ; set buffer pointer to start of buffer
+                stx CINPTR
+LA657           rts
+LA658           inca                            ; check for tape device
+                bne LA657                       ; brif not tape (nothing doing - it's always open)
+                inca                            ; make file type 1
+LA65C           ldx #0xffff                     ; ASCII and data mode
+LA65F           tst FILSTA                      ; is file open?
+                bne LA61C                       ; brif so - raise error
+                ldu #CASBUF                     ; point to tape buffer
+                stu CBUFAD                      ; set address of block to write
+                sta 8,u                         ; set file type
+                stx 9,u                         ; set ASCII flag and mode
+                ldx #CFNBUF+1                   ; point to file name
+                jsr LA598                       ; move file name to the tape buffer
+                clr BLKTYP                      ; set for header block
+                lda #15                         ; 15 bytes in a header block
+                sta BLKLEN                      ; set block length
+                jsr LA7E5                       ; write the block
+                lda #2                          ; set file type to output
+                sta FILSTA
+                bra LA650                       ; reset file pointers
+; Search for correct cassette file name
+LA681           ldx #CASBUF                     ; point to cassette buffer
+                stx CBUFAD                      ; set location to read blocks to
+LA686           lda CURLIN                      ; are we in immediate mode?
+                inca
+                bne LA696                       ; brif not
+                jsr LA928                       ; clear screen
+                ldx CURPOS                      ; get start of screen (set after clear)
+                ldb #'S                         ; for "searching"
+                stb ,x++                        ; put it on the screen
+                stx CURPOS                      ; save cursor position to be one past the search indicator
+LA696           bsr LA701                       ; read a block
+                orb BLKTYP                      ; merge error flag with block type
+                bne LA6D0                       ; brif error or not header
+                ldx #CASBUF                     ; point to block just read
+                ldu #CFNBUF+1                   ; point to the desired name
+                ldb #8                          ; compare 8 characters
+                clr ,-s                         ; set flag to "match"
+LA6A6           lda ,x+                         ; get character from just read block
+                ldy CURLIN                      ; immediate mode?
+                leay 1,y
+                bne LA6B4                       ; brif not
+                clr DEVNUM                      ; set output to screen
+                jsr PUTCHR                      ; display character
+LA6B4           suba ,u+                        ; subtract from desired file name (nonzero if no match)
+                ora ,s                          ; merge with match flag
+                sta ,s                          ; save new match flag (will be nonzero if any character differs)
+                decb                            ; done all characters?
+                bne LA6A6                       ; brif not - do another
+                lda ,s+                         ; get match flag (and set flags)
+                beq LA6CB                       ; brif we have a match
+                tst -9,u                        ; did we actually have a file name or will any file do?
+                beq LA6CB                       ; brif any file will do
+                bsr LA6D1                       ; go read past the file
+                bne LA6D0                       ; return on error
+                bra LA686                       ; keep looking
+LA6CB           lda #'F                         ; for "found"
+                bsr LA6F8                       ; put "F" on screen
+                clra                            ; set Z to indicat eno errors
+LA6D0           rts
+LA6D1           tst CASBUF+10                   ; check type of file
+                bne LA6DF                       ; brif "blocked" file
+                jsr CASON                       ; turn on tape
+LA6D9           bsr GETBLK                      ; read a block
+                bsr LA6E5                       ; error or EOF?
+                bra LA6D9                       ; read another block
+LA6DF           bsr LA701                       ; read a single block
+                bsr LA6E5                       ; error or EOF?
+                bra LA6DF                       ; read another block
+LA6E5           bne LA6ED                       ; got error reading block
+                lda BLKTYP                      ; check block type
+                nega                            ; A is 0 now if EOF
+                bmi LA6F3                       ; brif not end of file
+                deca                            ; clear error indicator
+LA6ED           sta CSRERR                      ; set error flag
+                leas 2,s                        ; don't return to original caller
+                bra LA705                       ; turn off motor and return
+LA6F3           lda VIDRAM                      ; get first char on screen
+                eora #0x40                      ; flip case
+LA6F8           ldb CURLIN                      ; immediate mode?
+                incb
+                bne LA700                       ; brif not
+                sta VIDRAM                      ; save flipped case character
+LA700           rts
+; Read a single block from tape (for a "blocked" file)
+LA701           bsr CASON                       ; start tape going
+                bsr GETBLK                      ; read block
+LA705           jsr LA7E9                       ; stop tape
+                ldb CSRERR                      ; get error status
+                rts
+; Read a block from tape - this does the heavy lifting
+GETBLK          orcc #0x50                      ; disable interrupts (timing is important)
+                bsr LA6F3                       ; reverse video of upper left character in direct mode
+                ldx CBUFAD                      ; point to destination buffer
+                clra                            ; reset read byte
+LA712           bsr LA755                       ; read a bit
+                rora                            ; move bit into accumulator
+                cmpa #0x3c                      ; have we synched on the start of the block data yet?
+                bne LA712                       ; brif not
+                bsr LA749                       ; read block type
+                sta BLKTYP
+                bsr LA749                       ; get block size
+                sta BLKLEN
+                adda BLKTYP                     ; accumulate checksum
+                sta CCKSUM                      ; save current checksum
+                lda BLKLEN                      ; get back count
+                sta CSRERR                      ; initialize counter; we use this since it will be ovewritten later anyway
+                beq LA73B                       ; brif empty block
+LA72B           bsr LA749                       ; read a byte
+                sta ,x                          ; save in buffer
+                cmpa ,x+                        ; make sure it wrote
+                bne LA744                       ; brif error if it didn't match
+                adda CCKSUM                     ; accumulate checksum
+                sta CCKSUM
+                dec CSRERR                      ; read all bytes?
+                bne LA72B                       ; brif not
+LA73B           bsr LA749                       ; read checksum from tape
+                suba CCKSUM                     ; does it match?
+                beq LA746                       ; brif so
+                lda #1                          ; checksum error flag
+                skip2
+LA744           lda #2                          ; non-RAM error flag
+LA746           sta CSRERR                      ; save error status
+                rts
+LA749           lda #8                          ; read 8 bits
+                sta CPULWD                      ; initialize counter
+LA74D           bsr LA755                       ; read a bit
+                rora                            ; put it into accumulator
+                dec CPULWD                      ; got all 8 bits?
+                bne LA74D                       ; brif not
+                rts
+LA755           bsr LA75D                       ; get time between transitions
+                ldb CPERTM                      ; get timer
+                decb
+                cmpb CMPMID                     ; set C if timer is below the transition point - high or 1; clear otherwise
+                rts
+LA75D           clr CPERTM                      ; reset timer
+                tst CBTPHA                      ; check which phase we synched on
+                bne LA773                       ; brif HI-LO synch
+LA763           bsr LA76C                       ; read input
+                bcs LA763                       ; brif still high
+LA767           bsr LA76C                       ; read input
+                bcc LA767                       ; brif still low
+                rts
+LA76C           inc CPERTM                      ; bump timer
+                ldb PIA1                        ; get input bit to C
+                rorb
+                rts
+LA773           bsr LA76C                       ; read input
+                bcc LA773                       ; brif still low
+LA777           bsr LA76C                       ; read output
+                bcs LA777                       ; brif still high
+                rts
+; Start tape and look for sync bytes
+CASON           orcc #0x50                      ; disable interrupts
+                bsr LA7CA                       ; turn on tape
+                clr CPULWD                      ; reset timer
+LA782           bsr LA763                       ; wait for low-high transition
+LA784           bsr LA7AD                       ; wait for it to go low again
+                bhi LA797                       ; brif in range for 1200 Hz
+LA788           bsr LA7A7                       ; wait for it to go high again
+                blo LA79B                       ; brif in range for 2400 Hz
+                dec CPULWD                      ; decrement counter (synched on low-high)
+                lda CPULWD                      ; get counter
+                cmpa #-96                       ; have we seen 96 1-0-1-0 patterns (48 0x55s)?
+LA792           bne LA782                       ; brif not - wait some more
+                sta CBTPHA                      ; save phase we synched on
+                rts
+LA797           bsr LA7A7                       ; wait for it to go high again
+                bhi LA784                       ; brif another 1200 Hz, 2 in a row, try again
+LA79B           bsr LA7AD                       ; wait for it to go low again
+                blo LA788                       ; brif another 2400 Hz; go try again for high
+                inc CPULWD                      ; bump counter
+                lda CPULWD                      ; get counter
+                suba #96                        ; set 0 if we've seen enought 0-1-0-1 patterns (0xaa)
+                bra LA792                       ; set phase and return or keep waiting
+LA7A7           clr CPERTM                      ; reset period timer
+                bsr LA767                       ; wait for high
+                bra LA7B1                       ; set flags on result
+LA7AD           clr CPERTM                      ; reset period timer
+                bsr LA777                       ; wait for low
+LA7B1           ldb CPERTM                      ; get period count
+                cmpb CMP0                       ; is it too long for 1200Hz?
+                bhi LA7BA                       ; brif so - reset counts
+                cmpb CMP1                       ; set C if 2400Hz, clear C if 1200 Hz
+                rts
+LA7BA           clr CPULWD                      ; reset sync counter (too slow or drop out)
+                rts
+; MOTOR command
+MOTOR           tfr a,b                         ; save ON/OFF
+                jsr GETNCH                      ; eat the ON/OFF token
+                cmpb #0xaa                      ; OFF?
+                beq LA7E9                       ; brif so - turn off tape
+                cmpb #0x88                      ; ON?
+                jsr LA5C9                       ; SN error if no match
+; Turn on tape
+LA7CA           lda PIA1+1                      ; get motor control value
+                ora #8                          ; turn on bit 3 (starts motor)
+                bsr LA7F0                       ; put it back (dumb but it saves a byte)
+LA7D1           ldx ZERO                        ; maximum delay timer
+LA7D3           leax -1,x                       ; count down
+                bne LA7D3                       ; brif not at 0 yet
+                rts
+; Write a synch leader to tape
+WRLDR           orcc #0x50                      ; disable interrupts
+                bsr LA7CA                       ; turn on tape
+                ldx SYNCLN                      ; get count of 0x55s to write
+LA7DE           bsr LA828                       ; write a 0x55
+                leax -1,x                       ; done?
+                bne LA7DE                       ; brif not
+                rts
+; Write sync bytes and a block, then stop tape
+LA7E5           bsr WRLDR                       ; write sync
+LA7E7           bsr SNDBLK                      ; write block
+; Turn off tape
+LA7E9           andcc #0xaf                     ; enable interrupts
+                lda PIA1+1                      ; get control register
+                anda #0xf7                      ; disable motor bit
+LA7F0           sta PIA1+1                      ; set motor enable bit
+                rts
+; Write a block to tape.
+SNDBLK          orcc #0x50                      ; disable interrupts
+                ldb BLKLEN                      ; get block size
+                stb CSRERR                      ; initialize character counter
+                lda BLKLEN                      ; initialize checksum
+                beq LA805                       ; brif empty block
+                ldx CBUFAD                      ; point to tape buffer
+LA800           adda ,x+                        ; accumulate checksum
+                decb                            ; end of block data?
+                bne LA800                       ; brif not
+LA805           adda BLKTYP                     ; accumulate block type into checksum
+                sta CCKSUM                      ; save calculated checksum
+                ldx CBUFAD                      ; point to buffer
+                bsr LA828                       ; send a 0x55
+                lda #0x3c                       ; and then a 0x3c
+                bsr LA82A
+                lda BLKTYP                      ; send block type
+                bsr LA82A
+                lda BLKLEN                      ; send block size
+                bsr LA82A
+                tsta                            ; empty block?
+                beq LA824                       ; brif so
+LA81C           lda ,x+                         ; send character from block data
+                bsr LA82A
+                dec CSRERR                      ; are we done yet?
+                bne LA81C                       ; brif not
+LA824           lda CCKSUM                      ; send checksum
+                bsr LA82A
+LA828           lda #0x55                       ; send a 0x55
+LA82A           pshs a                          ; save output byte
+                ldb #1                          ; initialize bit probe
+LA82E           lda CLSTSN                      ; get ending value of last cycle
+                sta PIA1                        ; set DA
+                ldy #LA85C                      ; point to sine wave table
+                bitb ,s                         ; is bit set?
+                bne LA848                       ; brif so - do high frequency
+LA83B           lda ,y+                         ; get next sample (use all for low frequency)
+                cmpy #LA85C+36                  ; end of table?
+                beq LA855                       ; brif so
+                sta PIA1                        ; set output sample
+                bra LA83B                       ; do another sample
+LA848           lda ,y++                        ; get next sample (use every other for high frequency)
+                cmpy #LA85C+36                  ; end of table?
+                beq LA855                       ; brif so
+                sta PIA1                        ; send output sample
+                bra LA848                       ; do another sample
+LA855           sta CLSTSN                      ; save last sample that *would* have been sent
+                lslb                            ; shift mask to next bit
+                bcc LA82E                       ; brif not done all 8 bits
+                puls a,pc                       ; get back original character and return
+; This is the sample table for the tape sine wave
+LA85C           fcb 0x82,0x92,0xaa,0xba,0xca,0xda
+                fcb 0xea,0xf2,0xfa,0xfa,0xfa,0xf2
+                fcb 0xea,0xda,0xca,0xba,0xaa,0x92
+                fcb 0x7a,0x6a,0x52,0x42,0x32,0x22
+                fcb 0x12,0x0a,0x02,0x02,0x02,0x0a
+                fcb 0x12,0x22,0x32,0x42,0x52,0x6a
+; SET command
+SET             bsr LA8C1                       ; get absolute screen position of graphics block
+                pshs x                          ; save character location
+                jsr LB738                       ; evaluate comma then expression in B
+                puls x                          ; get back character pointer
+                cmpb #8                         ; valid colour?
+                bhi LA8D5                       ; brif not
+                decb                            ; normalize colours
+                bmi LA895                       ; brif colour 0 (use current colour)
+                lda #0x10                       ; 16 patterns per colour
+                mul
+                bra LA89D                       ; go save the colour
+LA895           ldb ,x                          ; get current value
+                bpl LA89C                       ; brif not grahpic
+                andb #0x70                      ; keep only the colour
+                skip1
+LA89C           clrb                            ; reset block to all black
+LA89D           pshs b                          ; save colour
+                bsr LA90D                       ; force a )
+                lda ,x                          ; get current screen value
+                bmi LA8A6                       ; brif graphic block already
+                clra                            ; force all pixels off
+LA8A6           anda #0x0f                      ; keep only pixel data
+                ora GRBLOK                      ; set the desired pixel
+                ora ,s+                         ; merge with desired colour
+LA8AC           ora #0x80                       ; force it to be a graphic block
+                sta ,x                          ; put new block on screen
+                rts
+; RESET command
+RESET           bsr LA8C1                       ; get address of desired block
+                bsr LA90D                       ; force a )
+                clra                            ; zero block (no pixels)
+                ldb ,x                          ; is it graphics?
+                bpl LA8AC                       ; brif not - just blank the block
+                com GRBLOK                      ; invert pixel data
+                andb GRBLOK                     ; turn off the desired pixel
+                stb ,x                          ; put new pixel data on screen
+                rts
+; Parse SET/RESET/POINT coordinates except for closing )
+LA8C1           jsr LB26A                       ; make sure it starts with (
+LA8C4           jsr RVEC21                      ; do the RAM hook dance
+                jsr LB70B                       ; get first coordinate
+                cmpb #63                        ; valid horizontal coordinate
+                bhi LA8D5                       ; brif out of range
+                pshs b                          ; save horizontal coordinate
+                jsr LB738                       ; look for , followed by vertical coordinate
+                cmpb #31                        ; in range for vertical?
+LA8D5           bhi LA948                       ; brif not
+                pshs b                          ; save vertical coordinate
+                lsrb                            ; divide by two (two blocks per row)
+                lda #32                         ; 32 bytes per row
+                mul                             ; now we have the offset into video RAM
+                ldx #VIDRAM                     ; point to start of screen
+                leax d,x                        ; now X points to the correct character row
+                ldb 1,s                         ; get horizontal coordinate
+                lsrb                            ; divide by two (two per character cell)
+                abx                             ; now we're pointing to the correct character cell
+                puls a,b                        ; get back coordinates (vertical in A)
+                anda #1                         ; keep only row offset of vertical
+                rorb                            ; get column offset of horizontal to C
+                rola                            ; now we have "row * 2 + col" in A
+                ldb #0x10                       ; make a bit mask (one bit left of first pixel)
+LA8EE           lsrb                            ; move mask right
+                deca                            ; at the right pixel?
+                bpl LA8EE                       ; brif not
+                stb GRBLOK                      ; save graphics block mask
+                rts
+; POINT function
+POINT           bsr LA8C4                       ; evaluate coordinates
+                ldb #0xff                       ; default colour value is -1 (not graphics)
+                lda ,x                          ; get character
+                bpl LA90A                       ; brif not graphics
+                anda GRBLOK                     ; is desired pixel set?
+                beq LA909                       ; brif not - return 0 for "black"
+                ldb ,x                          ; get graphics data
+                lsrb                            ; shift right 4 to get colour in low bits
+                lsrb
+                lsrb
+                lsrb
+                andb #7                         ; lose the graphics block bias
+LA909           incb                            ; shift colours into 1 to 8 range
+LA90A           jsr LA5E8                       ; convert B to floating point
+LA90D           jmp LB267                       ; make sure we have a ) and return
+; CLS command
+CLS             jsr RVEC22                      ; do the RAM hook dance
+LA913           beq LA928                       ; brif no colour - just do a basic screen clear
+                jsr LB70B                       ; evaluate colour number
+                cmpb #8                         ; valid colour?
+                bhi LA937                       ; brif not - do the easter egg
+                tstb                            ; color 0?
+                beq LA925                       ; brif so
+                decb                            ; normalize to 0 based colour numbers
+                lda #0x10                       ; 16 blocks per colour
+                mul                             ; now we have the base code for that colour
+                orb #0x0f                       ; set all pixels
+LA925           orb #0x80                       ; make it a graphics block
+                skip2
+LA928           ldb #0x60                       ; VDG screen space character
+                ldx #VIDRAM                     ; point to start of screen
+LA92D           stx CURPOS                      ; set cursor position
+LA92F           stb ,x+                         ; blank a character
+                cmpx #VIDRAM+511                ; end of screen?
+                bls LA92F                       ; brif not
+                rts
+LA937           bsr LA928                       ; clear te screen
+                ldx #LA166-1                    ; point to the easter egg
+                jmp LB99C                       ; go display it
+; Evaluate an expression to B, prefixed by a comma, and do FC error if 0
+LA93F           jsr LB26D                       ; force a comma
+LA942           jsr LB70B                       ; evaluate expression to B
+                tstb                            ; is it 0?
+                bne LA984                       ; brif not - return
+LA948           jmp LB44A                       ; raise FC error
+; SOUND command
+SOUND           bsr LA942                       ; evaluate frequency
+                stb SNDTON                      ; save it
+                bsr LA93F                       ; evaluate duration (after a comma)
+LA951           lda #4                          ; constant factor for duration (each increment is 1/15 of a second)
+                mul
+                std SNDDUR                      ; save length of sound (IRQ will count it down)
+                lda PIA0+3                      ; enable 60 Hz interrupt
+                ora #1
+                sta PIA0+3
+                clr ARYDIS                      ; clear array disable flag for some reason
+                bsr LA9A2                       ; connect DAC to MUX output
+                bsr LA976                       ; turn on sound
+LA964           bsr LA985                       ; store mid range output value and delay
+                lda #0xfe                       ; store high value and delay
+                bsr LA987
+                bsr LA985                       ; store mid range value and delay
+                lda #2                          ; store low value and delay
+                bsr LA987
+                ldx SNDDUR                      ; has timer expired?
+                bne LA964                       ; brif not, do another wave
+; Disable sound output
+LA974           clra                            ; bit 3 to 0 will disable output
+                skip2
+; Enable sound output
+LA976           lda #8                          ; bit 3 set to enable output
+                sta ,-s                         ; save desired value
+                lda PIA1+3                      ; get control register value
+                anda #0xf7                      ; reset value
+                ora ,s+                         ; set to desired value
+                sta PIA1+3                      ; set new sound output status
+LA984           rts
+LA985           lda #0x7e                       ; mid range value for DAC
+LA987           sta PIA1                        ; set DAC output value
+                lda SNDTON                      ; get frequency
+LA98C           inca                            ; increment it (gives shorter count with higher values, so higher frequencies work)
+                bne LA98C                       ; brif not done yet
+                rts
+; AUDIO command
+AUDIO           tfr a,b                         ; save ON/OFF token
+                jsr GETNCH                      ; munch the ON/OFF token
+                cmpb #0xaa                      ; OFF?
+                beq LA974                       ; brif so
+                subb #0x88                      ; ON?
+                jsr LA5C9                       ; do SN error if not
+                incb                            ; now B is 1 - cassette sound source
+                bsr LA9A2                       ; set MUX input to tape
+                bra LA976                       ; enable sound
+; Set MUX source to value in B
+LA9A2           ldu #PIA0+1                     ; point to PIA0 control register A
+                bsr LA9A7                       ; program bit 0 then fall through for bit 1
+LA9A7           lda ,u                          ; get control register value
+                anda #0xf7                      ; reset mux control bit
+                asrb                            ; shift desired value to C
+                bcc LA9B0                       ; brif this bit is clear
+                ora #8                          ; set the bit
+LA9B0           sta ,u++                        ; set register value and move to next register
+                rts
+; IRQ service routine
+BIRQSV          lda PIA0+3                      ; check for VSYNC interrupt
+                bpl LA9C5                       ; brif not - return. BUG: should clear HSYNC interrupt status first
+                lda PIA0+2                      ; clear VSYNC interrupt status
+                ldx >SNDDUR                     ; are we counting down for SOUND? (force extended in case DP is modified)
+                beq LA9C5                       ; brif not
+                leax -1,x                       ; count down one tick
+                stx >SNDDUR                     ; save new count (forced extended in case DP is modified)
+LA9C5           rti
+; JOYSTK function
+JOYSTK          jsr LB70E                       ; evaluate which joystick axis is desired
+                cmpb #3                         ; valid axis?
+                lbhi LB44A                      ; brif not
+                tstb                            ; want axis 0?
+                bne LA9D4                       ; brif not
+                bsr GETJOY                      ; read axis data if axis 0
+LA9D4           ldx #POTVAL                     ; point to axis values
+                ldb FPA0+3                      ; get desired axis
+                ldb b,x                         ; get axis value
+                jmp LB4F3                       ; return value
+; Read all four joystick axes. Note that this routine will try 10 times to get a value that matches
+; the value obtained during the *previous call to this routine*. Thus, if the axis value has changed,
+; this routine will do the read *ten times* before just returning the last value. This is assininely
+; slow and probably a bug since it seems more logical to look for two matching reads in a row. Note
+; also that this routine should be using PSHS and PULS but it doesn't.
+GETJOY          bsr LA974                       ; turn off sound
+                ldx #POTVAL+4                   ; point to the end of the axis data (we'll work backwards)
+                ldb #3                          ; start with axis 3
+LA9E5           lda #10                         ; 10 tries to see if we match *the last call* to this routine
+                std ,--s                        ; save retry counter and axis number
+                bsr LA9A2                       ; set MUX for the correct axis
+LA9EB           ldd #0x4080                     ; set initial trial value to mid range and the next difference to add/subtract to half
+LA9EE           sta ,-s                         ; store the add/subtract value
+                orb #2                          ; keep rs232 output marking
+                stb PIA1                        ; set DAC output to the trial value
+                eorb #2                         ; remove RS232 output value
+                lda PIA0                        ; read the comparator
+                bmi LA9FF                       ; brif comparator output is high (DAC is lower than the axis value)
+                subb ,s                         ; subtract next bit value (split the difference toward 0)
+                skip2
+LA9FF           addb ,s                         ; add next bit value (split the different toward infinity)
+                lda ,s+                         ; get bit value back
+                lsra                            ; cut in half
+                cmpa #1                         ; have we done that last value for the DAC?
+                bne LA9EE                       ; brif not
+                lsrb                            ; normalize the axis value
+                lsrb
+                cmpb -1,x                       ; does it match the read from the last call to this routine?
+                beq LAA12                       ; brif so
+                dec ,s                          ; are we out of retries?
+                bne LA9EB                       ; brif not - try again
+LAA12           stb ,-x                         ; save new value and move pointer back
+                ldd ,s++                        ; get axis counter and clean up retry counter
+                decb                            ; move to next axis
+                bpl LA9E5                       ; brif still more axes to do
+                rts
+; This is the "bottom half" of the character fetching routines.
+BROMHK          cmpa #'9+1                      ; is it >= colon?
+                bhs LAA28                       ; brif so Z set if colon, C clear.
+                cmpa #0x20                      ; space?
+                bne LAA24                       ; brif not
+                jmp GETNCH                      ; move on to another character if space
+LAA24           suba #'0                        ; normalize ascii digit to 0-9; we already handled above digit 9
+                suba #-'0                       ; this will cause a carry for any value that was already positive
+LAA28           rts
+; Jump table for functions
+LAA29           fdb SGN                         ; SGN 0x80
+                fdb INT                         ; INT 0x81
+                fdb ABS                         ; ABS 0x82
+                fdb USRJMP                      ; USR 0x83
+                fdb RND                         ; RND 0x84
+                fdb SIN                         ; SIN 0x85
+                fdb PEEK                        ; PEEK 0x86
+                fdb LEN                         ; LEN 0x87
+                fdb STR                         ; STR$ 0x88
+                fdb VAL                         ; VAL 0x89
+                fdb ASC                         ; ASC 0x8a
+                fdb CHR                         ; CHR$ 0x8b
+                fdb EOF                         ; EOF 0x8c
+                fdb JOYSTK                      ; JOYSTK 0x8d
+                fdb LEFT                        ; LEFT$ 0x8e
+                fdb RIGHT                       ; RIGHT$ 0x8f
+                fdb MID                         ; MID$ 0x90
+                fdb POINT                       ; POINT 0x91
+                fdb INKEY                       ; INKEY$ 0x92
+                fdb MEM                         ; MEM 0x93
+; Operator precedence and jump table (binary ops except relational)
+LAA51           fcb 0x79                        ; +
+                fdb LB9C5
+                fcb 0x79                        ; -
+                fdb LB9BC
+                fcb 0x7b                        ; *
+                fdb LBACC
+                fcb 0x7b                        ; /
+                fdb LBB91
+                fcb 0x7f                        ; ^ (exponentiation)
+                fdb EXPJMP
+                fcb 0x50                        ; AND
+                fdb LB2D5
+                fcb 0x46                        ; OR
+                fdb LB2D4
+; Reserved words table for commands
+LAA66           fcs 'FOR'                       ; 0x80
+                fcs 'GO'                        ; 0x81
+                fcs 'REM'                       ; 0x82
+                fcs "'"                         ; 0x83
+                fcs 'ELSE'                      ; 0x84
+                fcs 'IF'                        ; 0x85
+                fcs 'DATA'                      ; 0x86
+                fcs 'PRINT'                     ; 0x87
+                fcs 'ON'                        ; 0x88
+                fcs 'INPUT'                     ; 0x89
+                fcs 'END'                       ; 0x8a
+                fcs 'NEXT'                      ; 0x8b
+                fcs 'DIM'                       ; 0x8c
+                fcs 'READ'                      ; 0x8d
+                fcs 'RUN'                       ; 0x8e
+                fcs 'RESTORE'                   ; 0x8f
+                fcs 'RETURN'                    ; 0x90
+                fcs 'STOP'                      ; 0x91
+                fcs 'POKE'                      ; 0x92
+                fcs 'CONT'                      ; 0x93
+                fcs 'LIST'                      ; 0x94
+                fcs 'CLEAR'                     ; 0x95
+                fcs 'NEW'                       ; 0x96
+                fcs 'CLOAD'                     ; 0x97
+                fcs 'CSAVE'                     ; 0x98
+                fcs 'OPEN'                      ; 0x99
+                fcs 'CLOSE'                     ; 0x9a
+                fcs 'LLIST'                     ; 0x9b
+                fcs 'SET'                       ; 0x9c
+                fcs 'RESET'                     ; 0x9d
+                fcs 'CLS'                       ; 0x9e
+                fcs 'MOTOR'                     ; 0x9f
+                fcs 'SOUND'                     ; 0xa0
+                fcs 'AUDIO'                     ; 0xa1
+                fcs 'EXEC'                      ; 0xa2
+                fcs 'SKIPF'                     ; 0xa3
+                fcs 'TAB('                      ; 0xa4
+                fcs 'TO'                        ; 0xa5
+                fcs 'SUB'                       ; 0xa6
+                fcs 'THEN'                      ; 0xa7
+                fcs 'NOT'                       ; 0xa8
+                fcs 'STEP'                      ; 0xa9
+                fcs 'OFF'                       ; 0xaa
+                fcs '+'                         ; 0xab
+                fcs '-'                         ; 0xac
+                fcs '*'                         ; 0xad
+                fcs '/'                         ; 0xae
+                fcs '^'                         ; 0xaf
+                fcs 'AND'                       ; 0xb0
+                fcs 'OR'                        ; 0xb1
+                fcs '>'                         ; 0xb2
+                fcs '='                         ; 0xb3
+                fcs '<'                         ; 0xb4
+; Reserved word list for functions
+LAB1A           fcs 'SGN'                       ; 0x80
+                fcs 'INT'                       ; 0x81
+                fcs 'ABS'                       ; 0x82
+                fcs 'USR'                       ; 0x83
+                fcs 'RND'                       ; 0x84
+                fcs 'SIN'                       ; 0x85
+                fcs 'PEEK'                      ; 0x86
+                fcs 'LEN'                       ; 0x87
+                fcs 'STR$'                      ; 0x88
+                fcs 'VAL'                       ; 0x89
+                fcs 'ASC'                       ; 0x8a
+                fcs 'CHR$'                      ; 0x8b
+                fcs 'EOF'                       ; 0x8c
+                fcs 'JOYSTK'                    ; 0x8d
+                fcs 'LEFT$'                     ; 0x8e
+                fcs 'RIGHT$'                    ; 0x8f
+                fcs 'MID$'                      ; 0x90
+                fcs 'POINT'                     ; 0x91
+                fcs 'INKEY$'                    ; 0x92
+                fcs 'MEM'                       ; 0x93
+; Jump table for commands
+LAB67           fdb FOR                         ; 0x80 FOR
+                fdb GO                          ; 0x81 GO
+                fdb REM                         ; 0x82 REM
+                fdb REM                         ; 0x83 '
+                fdb REM                         ; 0x84 ELSE
+                fdb IFTOK                       ; 0x85 IF
+                fdb DATA                        ; 0x86 DATA
+                fdb PRINT                       ; 0x87 PRINT
+                fdb ON                          ; 0x88 ON
+                fdb INPUT                       ; 0x89 INPUT
+                fdb ENDTOK                      ; 0x8a END
+                fdb NEXT                        ; 0x8b NEXT
+                fdb DIM                         ; 0x8c DIM
+                fdb READ                        ; 0x8d READ
+                fdb RUN                         ; 0x8e RUN
+                fdb RESTOR                      ; 0x8f RESTORE
+                fdb RETURN                      ; 0x90 RETURN
+                fdb STOP                        ; 0x91 STOP
+                fdb POKE                        ; 0x92 POKE
+                fdb CONT                        ; 0x93 CONT
+                fdb LIST                        ; 0x94 LIST
+                fdb CLEAR                       ; 0x95 CLEAR
+                fdb NEW                         ; 0x96 NEW
+                fdb CLOAD                       ; 0x97 CLOAD
+                fdb CSAVE                       ; 0x98 CSAVE
+                fdb OPEN                        ; 0x99 OPEN
+                fdb CLOSE                       ; 0x9a CLOSE
+                fdb LLIST                       ; 0x9b LLIST
+                fdb SET                         ; 0x9c SET
+                fdb RESET                       ; 0x9d RESET
+                fdb CLS                         ; 0x9e CLS
+                fdb MOTOR                       ; 0x9f MOTOR
+                fdb SOUND                       ; 0xa0 SOUND
+                fdb AUDIO                       ; 0xa1 AUDIO
+                fdb EXEC                        ; 0xa2 EXEC
+                fdb SKIPF                       ; 0xa3 SKIPF
+; Error message table
+LABAF           fcc 'NF'                        ; 0 NEXT without FOR
+                fcc 'SN'                        ; 1 Syntax error
+                fcc 'RG'                        ; 2 RETURN without GOSUB
+                fcc 'OD'                        ; 3 Out of data
+                fcc 'FC'                        ; 4 Illegal function call
+                fcc 'OV'                        ; 5 Overflow
+                fcc 'OM'                        ; 6 Out of memory
+                fcc 'UL'                        ; 7 Undefined line number
+                fcc 'BS'                        ; 8 Bad subscript
+                fcc 'DD'                        ; 9 Redimensioned array
+                fcc '/0'                        ; 10 Division by 0
+                fcc 'ID'                        ; 11 Illegal direct statement
+                fcc 'TM'                        ; 12 Type mismatch
+                fcc 'OS'                        ; 13 Out of string space
+                fcc 'LS'                        ; 14 String too long
+                fcc 'ST'                        ; 15 String formula too complex
+                fcc 'CN'                        ; 16 Can't continue
+                fcc 'FD'                        ; 17 Bad file data
+                fcc 'AO'                        ; 18 File already open
+                fcc 'DN'                        ; 19 Device number error
+                fcc 'IO'                        ; 20 Input/output error
+                fcc 'FM'                        ; 21 Bad file mode
+                fcc 'NO'                        ; 22 File not open
+                fcc 'IE'                        ; 23 Input past end of file
+                fcc 'DS'                        ; 24 Direct statement in file
+LABE1           fcn ' ERROR'
+LABE8           fcn ' IN '
+LABED           fcb 0x0d
+LABEE           fcc 'OK'
+                fcb 0x0d,0x00
+LABF2           fcb 0x0d
+                fcn 'BREAK'
+; Search stack for a FOR/NEXT stack frame. Stop search when something that isn't a FOR/NEXT
+; stack frame is found. Enter with the index variable descriptor pointer in VARDES, or NULL
+; for the first match.
+;
+; NOTE: this routine can be reworked to avoid needed two temporaries by taking advantage of the
+; 6809's registers. This requires some minor tweaks where the routine is called. Further, the
+; use of B is completely pointless and, even if B is going to be used, why is it reloaded on
+; every loop?
+LABF9           leax 4,s                        ; skip past our caller and the main command loop return address
+LABFB           ldb #18                         ; each FOR/NEXT frame is 18 bytes
+                stx TEMPTR                      ; save current search pointer
+                lda ,x                          ; get first byte of this frame
+                suba #0x80                      ; set to 0 if FOR/NEXT
+                bne LAC1A                       ; brif not FOR/NEXT (we hit the end of the stack for a GOSUB frame)
+                ldx 1,x                         ; get index variable descriptor
+                stx TMPTR1                      ; save it
+                ldx VARDES                      ; get desired index descriptor
+                beq LAC16                       ; brif NULL - we found something
+                cmpx TMPTR1                     ; does this one match?
+                beq LAC1A                       ; brif so
+                ldx TEMPTR                      ; get back frame pointer
+                abx                             ; move to next entry
+                bra LABFB                       ; check next block of data
+LAC16           ldx TMPTR1                      ; get index variable of this frame
+                stx VARDES                      ; set it as the one found
+LAC1A           ldx TEMPTR                      ; get matching frame pointer
+                tsta                            ; set Z if FOR/NEXT
+                rts
+; This is a block copy routine which copies from top to bottom. It's not clear that the use of
+; this routine actually saves any ROM space compared to just implementing the copies directly
+; once all the marshalling to set up the parameter variables is taken into account.
+LAC1E           bsr LAC37                       ; check to see if stack collides with D
+LAC20           ldu V41                         ; point to destination
+                leau 1,u                        ; offset for pre-dec
+                ldx V43                         ; point to source
+                leax 1,x                        ; offset for pre-dec
+LAC28           lda ,-x                         ; get source byte
+                pshu a                          ; store at destination (sta ,-u would be less weird)
+                cmpx V47                        ; at the bottom of the copy?
+                bne LAC28                       ; brif not
+                stu V45                         ; save final destination address
+LAC32           rts
+; Check for 2*B (0 <= B <= 127) bytes for free memory
+LAC33           clra                            ; zero extend
+                aslb                            ; times 2 (loses bit 7 of B)
+                addd ARYEND                     ; add to top of used memory
+LAC37           addd #STKBUF                    ; add a fudge factor for interpreter operation
+                bcs LAC44                       ; brif >65535!
+                sts BOTSTK                      ; get current stack pointer
+                cmpd BOTSTK                     ; is our new address above that?
+                blo LAC32                       ; brif not - no error
+LAC44           ldb #6*2                        ; raise OM error
+; The error servicing routine
+LAC46           jsr RVEC16                      ; do the RAM hook dance (ON ERROR reserved hook)
+LAC49           jsr RVEC17                      ; do the RAM hook dance again
+                jsr LA7E9                       ; turn off tape
+                jsr LA974                       ; disable sound
+                jsr LAD33                       ; reset stack, etc.
+                clr DEVNUM                      ; reset output to screen
+                jsr LB95C                       ; do a newline
+                jsr LB9AF                       ; send a ?
+                ldx #LABAF                      ; point to error table
+                abx                             ; offset to correct message
+                bsr LACA0                       ; send a char from X
+                bsr LACA0                       ; send another char from X
+                ldx #LABE1-1                    ; point to "ERROR" message
+LAC68           jsr LB99C                       ; print ERROR message (or BREAK)
+                lda CURLIN                      ; are we in immediate mode?
+                inca
+                beq LAC73                       ; brif not - go to immediate mode
+                jsr LBDC5                       ; print "IN ****"
+; This is the immediate mode loop
+LAC73           jsr LB95C                       ; do a newline if needed
+LAC76           ldx #LABEE-1                    ; point to prompt (without leading CR)
+                jsr LB99C                       ; show prompt
+LAC7C           jsr LA390                       ; read an input line
+                ldu #0xffff                     ; flag immediate mode
+                stu CURLIN
+                bcs LAC7C                       ; brif we ended on BREAK - just go for another line
+                tst CINBFL                      ; EOF?
+                lbne LA4BF                      ; brif so
+                stx CHARAD                      ; save start of input line as input pointer
+                jsr GETNCH                      ; get character from input line
+                beq LAC7C                       ; brif no input
+                bcs LACA5                       ; brif numeric - adding or removing a line number
+                ldb #2*24                       ; code for "direct statement in file"
+                tst DEVNUM                      ; keyboard input?
+                bne LAC46                       ; brif not - complain about direct statement
+                jsr LB821                       ; go tokenize the input line
+                jmp LADC0                       ; go execute the newly tokenized line
+LACA0           lda ,x+                         ; get character and advance pointer
+                jmp LB9B1                       ; output it
+LACA5           jsr LAF67                       ; convert line number to binary
+                ldx BINVAL                      ; get converted number
+                stx LINHDR                      ; put it before the line we just read
+                jsr LB821                       ; tokenize the input line
+                stb TMPLOC                      ; save line length
+                bsr LAD01                       ; find where the line should be in the program
+                bcs LACC8                       ; brif the line number isn't already present
+                ldd V47                         ; get address where the line is in the program
+                subd ,x                         ; get the difference between here and the end of the line (negative)
+                addd VARTAB                     ; subtract line length from the end of the program
+                std VARTAB                      ; save new end of program address
+                ldu ,x                          ; get start of next line
+LACC0           pulu a                          ; get source byte (lda ,u+ would be less weird)
+                sta ,x+                         ; move it down
+                cmpx VARTAB                     ; have we moved everything yet?
+                bne LACC0                       ; brif not
+LACC8           lda LINBUF                      ; see if there is actually a line to input
+                beq LACE9                       ; brif not - we just needed to remove the line
+                ldd VARTAB                      ; get current end of program
+                std V43                         ; set as source pointer
+                addb TMPLOC                     ; add in the length of the new line
+                adca #0
+                std V41                         ; save destination pointer
+                jsr LAC1E                       ; make sure there's enough room and then make a hole for the new line
+                ldu #LINHDR-2                   ; point to the line (well, 4 bytes before it, incl line number and fake next line pointer)
+LACDD           pulu a                          ; get byte from new line (lda ,u+ would be less weird)
+                sta ,x+                         ; stow it
+                cmpx V45                        ; at the end of the hole we just made?
+                bne LACDD                       ; brif not
+                ldx V41                         ; get save new top of program address
+                stx VARTAB
+LACE9           bsr LAD21                       ; reset variables, etc.
+                bsr LACEF                       ; adjust next line pointers
+                bra LAC7C                       ; go read another input line
+; Recompute next line pointers
+LACEF           ldx  TXTTAB                     ; point to start of program
+LACF1           ldd ,x                          ; get address of next line
+                beq LAD16                       ; brif end of program
+                leau 4,x                        ; move past pointer and line number
+LACF7           lda ,u+                         ; are we at the end of the line?
+                bne LACF7                       ; brif not
+                stu ,x                          ; save new next line pointer
+                ldx ,x                          ; point to next line
+                bra LACF1                       ; process the next line
+; Find a line in the program
+LAD01           ldd BINVAL                      ; get desired line number
+                ldx TXTTAB                      ; point to start of program
+LAD05           ldu ,x                          ; get address of next line
+                beq LAD12                       ; brif end of program
+                cmpd 2,x                        ; do we have a match?
+                bls LAD14                       ; brif our search number is <= the number here
+                ldx ,x                          ; move to next line
+                bra LAD05                       ; check another line
+LAD12           orcc #1                         ; set C for not found
+LAD14           stx V47                         ; save address of matching line *or* line just after where it would have been
+LAD16           rts
+; NEW command
+; This routine has multiple entry points used for various "levels" of NEW
+NEW             bne LAD14                       ; brif there was input given; should be LAD16!
+LAD19           ldx TXTTAB                      ; point to start of program
+                clr ,x+                         ; blank out program (with NULL next line pointer)
+                clr ,x+
+                stx VARTAB                      ; save end of program
+LAD21           ldx TXTTAB                      ; get start of program
+                jsr LAEBB                       ; put input pointer there
+LAD26           ldx MEMSIZ                      ; reset string space
+                stx STRTAB
+                jsr RESTOR                      ; reset DATA pointer
+                ldx VARTAB                      ; clear out scalars and arrays
+                stx ARYTAB
+                stx ARYEND
+LAD33           ldx #STRSTK                     ; reset the string stack
+                stx TEMPPT
+                ldx ,s                          ; get return address (we're going to reset the stack)
+                lds FRETOP                      ; reset the stack to top of memory
+                clr ,-s                         ; put stopper so FOR/NEXT search will actually stop here
+                clr OLDPTR                      ; reset "CONT" state
+                clr OLDPTR+1
+                clr ARYDIS                      ; un-disable arrays
+                jmp ,x                          ; return to original caller
+; FOR command
+FOR             lda #0x80                       ; disable array parsing
+                sta ARYDIS
+                jsr LET                         ; assign start value to index
+                jsr LABF9                       ; search stack for matching FOR/NEXT frame
+                leas 2,s                        ; lose return address
+                bne LAD59                       ; brif variable not already being used
+                ldx TEMPTR                      ; get address of matched data
+                leas b,x                        ; move stack pointer to the end of it (B is set to 18 in the stack search)
+LAD59           ldb #9                          ; is there room for 18 bytes in memory?
+                jsr LAC33
+                jsr LAEE8                       ; get address of the end of this statement in X
+                ldd CURLIN                      ; get line number
+                pshs x,b,a                      ; save next line address and current line number
+                ldb #0xa5                       ; make sure we have TO
+                jsr LB26F
+                jsr LB143                       ; make sure we have a numeric index
+                jsr LB141                       ; evaluate terminal condition value
+                ldb FP0SGN                      ; pack FPA0 in place
+                orb #0x7f
+                andb FPA0
+                stb FPA0
+                ldy #LAD7F                      ; where to come back to
+                jmp LB1EA                       ; stash terminal condition on the stack
+LAD7F           ldx #LBAC5                      ; point to FP 1.0 (default step)
+                jsr LBC14                       ; unpack it to FPA0
+                jsr GETCCH                      ; get character after the terminal
+                cmpa #0xa9                      ; is it STEP?
+                bne LAD90                       ; brif not
+                jsr GETNCH                      ; eat STEP
+                jsr LB141                       ; evaluate step condition
+LAD90           jsr LBC6D                       ; get "status" of FPA0
+                jsr LB1E6                       ; stash FPA0 on the stack (for step value)
+                ldd VARDES                      ; get variable descriptor pointer
+                pshs d                          ; put that on the stack too
+                lda #0x80                       ; flag the frame as a FOR/NEXT frame
+                pshs a
+; Main command interpretation loop
+LAD9E           jsr RVEC20                      ; do the RAM hook dance
+                andcc #0xaf                     ; make sure interrupts are running
+                bsr LADEB                       ; check for BREAK/pause
+                ldx CHARAD                      ; get input pointer
+                stx TINPTR                      ; save input pointer for start of line
+                lda ,x+                         ; get current input character
+                beq LADB4                       ; brif end of line - move to another line
+                cmpa #':                        ; end of statement?
+                beq LADC0                       ; brif so - keep processing
+LADB1           jmp LB277                       ; raise a syntax error
+LADB4           lda ,x++                        ; get MSB of next line pointer and skip past pointer
+                sta ENDFLG
+                beq LAE15                       ; brif MSB of next line address is 0 (do END)
+                ldd ,x+                         ; get line number but only advance one
+                std CURLIN                      ; set current line number
+                stx CHARAD                      ; set input pointer to one before line text
+LADC0           jsr GETNCH                      ; move past statement separator or to first character in line
+                bsr LADC6                       ; process a command
+                bra LAD9E                       ; handle next statement or line
+LADC6           beq LAE40                       ; return if end of statement
+                tsta                            ; is it a token?
+                lbpl LET                        ; brif not - do a LET
+                cmpa #0xa3                      ; above SKIPF?
+                bhi LADDC                       ; brif so
+                ldx COMVEC+3                    ; point to jump table
+                lsla                            ; two bytes per entry (loses the token bias)
+                tfr a,b                         ; put it in B for unsigned ABX
+                abx
+                jsr GETNCH                      ; move past token
+                jmp [,x]                        ; transfer control to the handler (which will return to the main loop)
+LADDC           cmpa #0xb4                      ; is it a non-executable token?
+                bls LADB1                       ; brif so
+                jmp [COMVEC+13]                 ; transfer control to ECB command handler
+; RESTORE command
+RESTOR          ldx TXTTAB                      ; point to beginning of the program
+                leax -1,x                       ; move back one (to compensate for "GETNCH")
+LADE8           stx DATPTR                      ; save as new data pointer
+                rts
+; BREAK check
+LADEB           jsr KEYIN                       ; read keyboard
+                beq LADFA                       ; brif no key down
+LADF0           cmpa #3                         ; BREAK?
+                beq STOP                        ; brif so - do a STOP
+                cmpa #0x13                      ; pause (SHIFT-@)?
+                beq LADFB                       ; brif so
+                sta IKEYIM                      ; cache key for later INKEY$ so break check doesn't break INKEY$
+LADFA           rts
+LADFB           jsr KEYIN                       ; read keyboard
+                beq LADFB                       ; brif no key down
+                bra LADF0                       ; process pressed key in case BREAK or SHIFT-@ again
+; END command
+ENDTOK          jsr LA426                       ; close files
+                jsr GETCCH                      ; re-get input character
+                bra LAE0B
+; STOP command
+STOP            orcc #1                         ; flag "STOP"
+LAE0B           bne LAE40                       ; brif not end of statement
+                ldx CHARAD                      ; save current input pointer
+                stx TINPTR
+LAE11           ror ENDFLG                      ; save END/STOP flag (C)
+                leas 2,s                        ; lose return address
+LAE15           ldx CURLIN                      ; get current input line (end of program comes here)
+                cmpx #0xffff                    ; immediate mode?
+                beq LAE22                       ; brif so
+                stx OLDTXT                      ; save line where we stopped executing
+                ldx TINPTR                      ; get input pointer
+                stx OLDPTR                      ; save location where we stopped executing
+LAE22           clr DEVNUM                      ; reset to screen/keyboard
+                ldx #LABF2-1                    ; point to BREAK message
+                tst ENDFLG                      ; are we doing "BREAK"?
+                lbpl LAC73                      ; brif not
+                jmp LAC68                       ; go do the BREAK message and return to main loop
+; CONT command
+CONT            bne LAE40                       ; brif not end of statement
+                ldb #2*16                       ; code for can't continue
+                ldx OLDPTR                      ; get saved execution pointer
+                lbeq LAC46                      ; brif no saved pointer - raise CN error
+                stx CHARAD                      ; reset input pointer
+                ldx OLDTXT                      ; reset current line number
+                stx CURLIN
+LAE40           rts
+; CLEAR command
+CLEAR           beq LAE6F                       ; brif no argument
+                jsr LB3E6                       ; evaluate string space size
+                pshs d                          ; save it
+                ldx MEMSIZ                      ; get memory size (top of memory)
+                jsr GETCCH                      ; is there anything after the string space size?
+                beq LAE5A                       ; brif not
+                jsr LB26D                       ; force a comma
+                jsr LB73D                       ; get top of memory value in X
+                leax -1,x                       ; move back one (top of cleared space)
+                cmpx TOPRAM                     ; is it within the memory available?
+                bhi LAE72                       ; brif higher than top of memory - OM error
+LAE5A           tfr x,d                         ; so we can do math for checking memory usage
+                subd ,s++                       ; subtract out string space value
+                bcs LAE72                       ; brif less than 0
+                tfr d,u                         ; U is bottom of cleared space
+                subd #STKBUF                    ; also account for slop space
+                bcs LAE72                       ; brif less than 0
+                subd VARTAB                     ; is there still room for the program?
+                blo LAE72                       ; brif not
+                stu FRETOP                      ; set top of free memory
+                stx MEMSIZ                      ; set size of usable memory
+LAE6F           jmp LAD26                       ; erase variables, etc.
+LAE72           jmp LAC44                       ; raise OM error
+; RUN command
+RUN             jsr RVEC18                      ; do the RAM hook dance
+                jsr LA426                       ; close any open files
+                jsr GETCCH                      ; is there a line number
+                lbeq LAD21                      ; brif no line number - start from beginning
+                jsr LAD26                       ; clear variables, etc.
+                bra LAE9F                       ; "GOTO" the line number
+; GO command (GOTO and GOSUB)
+GO              tfr a,b                         ; save TO/SUB
+LAE88           jsr GETNCH                      ; eat the TO/SUB token
+                cmpb #0xa5                      ; TO?
+                beq LAEA4                       ; brif GOTO
+                cmpb #0xa6                      ; SUB?
+                bne LAED7                       ; brif not
+                ldb #3                          ; room for 6 bytes?
+                jsr LAC33
+                ldu CHARAD                      ; get input pointer
+                ldx CURLIN                      ; get line number
+                lda #0xa6                       ; flag for GOSUB frame
+                pshs u,x,a                      ; set stack frame
+LAE9F           bsr LAEA4                       ; do "GOTO"
+                jmp LAD9E                       ; go back to main loop
+; Actual GOTO is here
+LAEA4           jsr GETCCH                      ; get current input
+                jsr LAF67                       ; convert number to binary
+                bsr LAEEB                       ; move input pointer to end of statement
+                leax 1,x                        ; point to start of next line
+                ldd BINVAL                      ; get desired line number
+                cmpd CURLIN                     ; is it beyond here?
+                bhi LAEB6                       ; brif so
+                ldx TXTTAB                      ; start search at beginning of program
+LAEB6           jsr LAD05                       ; find line number
+                bcs LAED2                       ; brif not found
+LAEBB           leax -1,x                       ; move to just before start of line
+                stx CHARAD                      ; reset input pointer
+LAEBF           rts
+; RETURN command
+RETURN          bne LAEBF                       ; exit if argument given
+                lda #0xff                       ; set VARDES to an illegal value so we ignore FOR frames
+                sta VARDES
+                jsr LABF9                       ; look for a GOSUB frame
+                tfr x,s                         ; reset stack
+                cmpa #0xa6-0x80                 ; is it a GOSUB frame?
+                beq LAEDA                       ; brif so
+                ldb #2*2                        ; code for RETURN without GOSUB
+                skip2
+LAED2           ldb #7*2                        ; code for undefined line number
+                jmp LAC46                       ; raise error
+LAED7           jmp LB277                       ; raise syntax error
+LAEDA           puls a,x,u                      ; get back saved line number and input pointer
+                stx CURLIN                      ; reset line number
+                stu CHARAD                      ; reset input pointer
+; DATA command
+DATA            bsr LAEE8                       ; move input pointer to end of statement
+                skip2
+; REM command (also ELSE)
+REM             bsr LAEEB                       ; move input pointer to end of line
+                stx CHARAD                      ; save new input pointer
+LAEE7           rts
+; Return end of statement (LAEE8) or line (AEEB) in X
+LAEE8           ldb #':                         ; colon is statement terminator
+                skip1lda
+LAEEB           clrb                            ; make main terminator NUL
+                stb CHARAC                      ; save terminator
+                clrb                            ; end of line - always terminates
+                ldx CHARAD                      ; get input pointer
+LAEF1           tfr b,a                         ; save secondary terminator
+                ldb CHARAC                      ; get main terminator
+                sta CHARAC                      ; save secondary
+LAEF7           lda ,x                          ; get input character
+                beq LAEE7                       ; brif end of line
+                pshs b                          ; save terminator
+                cmpa ,s+                        ; does it match?
+                beq LAEE7                       ; brif so - bail
+                leax 1,x                        ; move pointer ahead
+                cmpa #'"                        ; start of string?
+                beq LAEF1                       ; brif so
+                inca                            ; functon token?
+                bne LAF0C                       ; brif not
+                leax 1,x                        ; skip second part of function token
+LAF0C           cmpa #0x85+1                    ; IF?
+                bne LAEF7                       ; brif not
+                inc IFCTR                       ; bump "IF" count
+                bra LAEF7                       ; get check another input character
+; IF command
+IFTOK           jsr LB141                       ; evaluate condition
+                jsr GETCCH                      ; find out what's after the conditin
+                cmpa #0x81                      ; GO?
+                beq LAF22                       ; treat same as THEN
+                ldb #0xa7                       ; make sure we have a THEN
+                jsr LB26F
+LAF22           lda FP0EXP                      ; get true/false (false is 0)
+                bne LAF39                       ; brif condition true
+                clr IFCTR                       ; reset IF counter
+LAF28           bsr DATA                        ; skip over statement
+                tsta                            ; end of line?
+                beq LAEE7                       ; brif so
+                jsr GETNCH                      ; get start of this statement
+                cmpa #0x84                      ; ELSE?
+                bne LAF28                       ; brif not
+                dec IFCTR                       ; is it a matching ELSE?
+                bpl LAF28                       ; brif not - keep looking
+                jsr GETNCH                      ; eat the ELSE
+LAF39           jsr GETCCH                      ; get current input
+                lbcs LAEA4                      ; brif numeric - to a GOTO
+                jmp LADC6                       ; let main loop interpret the next command
+; ON command
+ON              jsr LB70B                       ; evaluate index expression
+LAF45           ldb #0x81                       ; make sure we have "GO"
+                jsr LB26F
+                pshs a                          ; save TO/SUB
+                cmpa #0xa6                      ; SUB?
+                beq LAF54                       ; brif so
+                cmpa #0xa5                      ; TO?
+LAF52           bne LAED7                       ; brif not
+LAF54           dec FPA0+3                      ; are we at the right index?
+                bne LAF5D                       ; brif not
+                puls b                          ; get TO/SUB token
+                jmp LAE88                       ; go do GOTO or GOSUB
+LAF5D           jsr GETNCH                      ; munch a character
+                bsr LAF67                       ; parse line number
+                cmpa #',                        ; is there another line following?
+                beq LAF54                       ; brif so - see if we're there yet
+                puls b,pc                       ; clean up TO/SUB token and return - we fell through
+; Parse a line number
+LAF67           ldx ZERO                        ; initialize line number accumulator to 0
+                stx BINVAL
+LAF6B           bcc LAFCE                       ; brif not numeric
+                suba #'0                        ; adjust to actual value of digit
+                sta CHARAC                      ; save digit
+                ldd BINVAL                      ; get accumulated number
+                cmpa #24                        ; will this overflow?
+                bhi LAF52                       ; brif so - raise syntax error
+                aslb                            ; times 2
+                rola
+                aslb                            ; times 4
+                rola
+                addd BINVAL                     ; times 5
+                aslb                            ; times 10
+                rola
+                addb CHARAC                     ; add in digit
+                adca #0
+                std BINVAL                      ; save new accumulated number
+                jsr GETNCH                      ; fetch next character
+                bra LAF6B                       ; process next digit
+; LET command (the LET keyword requires Extended Basic)
+LET             jsr LB357                       ; evaluate destination variable
+                stx VARDES                      ; save descriptor pointer
+                ldb #0xb3                       ; make sure we have =
+                jsr LB26F
+                lda VALTYP                      ; get destination variable type
+                pshs a                          ; save it for later
+                jsr LB156                       ; evaluate the expression to assign
+                puls a                          ; get back original variable type
+                rora                            ; put type in C
+                jsr LB148                       ; make sure the current result matches the type
+                lbeq LBC33                      ; bri fnumeric - copy FPA0 to variable
+LAFA4           ldx FPA0+2                      ; point to descriptor of replacement string
+                ldd FRETOP                      ; get bottom of string space
+                cmpd 2,x                        ; is the string already in string space?
+                bhs LAFBE                       ; brif so
+                cmpx VARTAB                     ; is the descriptor in variable space?
+                blo LAFBE                       ; brif not
+LAFB1           ldb ,x                          ; get length of string
+                jsr LB50D                       ; allocate space for this string
+                ldx V4D                         ; get descriptor pointer back
+                jsr LB643                       ; copy string into string space
+                ldx #STRDES                     ; point to temporary string descriptor
+LAFBE           stx V4D                         ; save descriptor pointer
+                jsr LB675                       ; remove string from string stack if appropriate
+                ldu V4D                         ; get back replacement descriptor
+                ldx VARDES                      ; get target descriptor
+                pulu a,b,y                      ; get string length (A) and data pointer (Y)
+                sta ,x                          ; save new length
+                sty 2,x                         ; save new pointer
+LAFCE           rts
+; READ and INPUT commands.
+LAFCF           fcc '?REDO'                     ; The ?REDO message
+                fcb 0x0d,0x00
+LAFD6           ldb #2*17                       ; bad file data code
+                tst DEVNUM                      ; are we reading from the keyboard?
+                beq LAFDF                       ; brif so
+LAFDC           jmp LAC46                       ; raise the error
+LAFDF           lda INPFLG                      ; are we doing INPUT?
+                beq LAFEA                       ; brif so
+                ldx DATTXT                      ; get line number where the DATA statement happened
+                stx CURLIN                      ; set current line number to that so can report the correct location
+                jmp LB277                       ; raise a syntax error on bad data
+LAFEA           ldx #LAFCF-1                    ; show the ?REDO if we're doing INPUT
+                jsr LB99C
+                ldx TINPTR                      ;* reset input pointer to start of statement (this will cause the
+                stx CHARAD                      ;* INPUT statement to be re-executed
+                rts
+INPUT           ldb #11*2                       ; code for illegal direct statement
+                ldx CURLIN                      ; are we in immediate mode?
+                leax 1,x
+                beq LAFDC                       ; brif so - raise ID error
+                bsr LB002                       ; go do the INPUT thing
+                clr DEVNUM                      ; reset device to screen/keyboard
+                rts
+LB002           cmpa #'#                        ; is there a device number?
+                bne LB00F                       ; brif not
+                jsr LA5A5                       ; parse device number
+                jsr LA3ED                       ; make sure it's valid for input
+                jsr LB26D                       ; make sure we have a comma after the device number
+LB00F           cmpa #'"                        ; is there a prompt string?
+                bne LB01E                       ; brif not
+                jsr LB244                       ; parse the prompt string
+                ldb #';                         ; make sure we have a semicolon after the prompt
+                jsr LB26F
+                jsr LB99F                       ; print the prompt
+LB01E           ldx #LINBUF                     ; point to line input buffer
+                clr ,x                          ; NUL first byte to indicate no data
+                tst DEVNUM                      ; is it keyboard input?
+                bne LB049                       ; brif not
+                bsr LB02F                       ; read a line from the keyboard
+                ldb #',                         ; put a comma at the start of the buffer
+                stb ,x
+                bra LB049                       ; go process some input
+LB02F           jsr LB9AF                       ; send a ?
+                jsr LB9AC                       ; send a space
+LB035           jsr LA390                       ; read input from the keyboard
+                bcc LB03F                       ; brif not BREAK
+                leas 4,s                        ; clean up stack
+LB03C           jmp LAE11                       ; go process BREAK
+LB03F           ldb #2*23                       ; input past end of file error code
+                tst CINBFL                      ; was it EOF?
+                bne LAFDC                       ; brif so - raise the error
+                rts
+READ            ldx DATPTR                      ; fetch current DATA pointer
+                skip1lda                        ; set A to nonzero (for READ)
+LB049           clra                            ; set A to zero (for INPUT)
+                sta INPFLG                      ; record whether we're doing READ or INPUT
+                stx DATTMP                      ; save current input location
+LB04E           jsr LB357                       ; evaluate a variable (destination of data)
+                stx VARDES                      ; save descriptor
+                ldx CHARAD                      ; save interpreter input pointer
+                stx BINVAL
+                ldx DATTMP                      ; get data pointer
+                lda ,x                          ; is there anything to read?
+                bne LB069                       ; brif so
+                lda INPFLG                      ; is it INPUT?
+                bne LB0B9                       ; brif not
+                jsr RVEC10                      ; do the RAM hook dance
+                jsr LB9AF                       ; send a ? (so subsequent lines get ??)
+                bsr LB02F                       ; go read an input line
+LB069           stx CHARAD                      ; save data pointer
+                jsr GETNCH                      ; fetch next data character
+                ldb VALTYP                      ; do we want a number?
+                beq LB098                       ; brif so
+                ldx CHARAD                      ; get input pointer
+                sta CHARAC                      ; save initial character as the delimiter
+                cmpa #'"                        ; do we have a string delimiter?
+                beq LB08B                       ; brif so - use " as both delimiters
+                leax -1,x                       ; back up input if we don't have a delimiter
+                clra                            ; set delimiter to NUL (end of line)
+                sta CHARAC
+                jsr LA35F                       ; set up print parameters
+                tst PRTDEV                      ; is it a file type device?
+                bne LB08B                       ; brif so - use two NULs
+                lda #':                         ; use colon as one delimiter
+                sta CHARAC
+                lda #',                         ; and use comma as the other
+LB08B           sta ENDCHR                      ; save second terminator
+                jsr LB51E                       ; parse out the string
+                jsr LB249                       ; move input pointer past the string
+                jsr LAFA4                       ; assign the string to the variable
+                bra LB09E                       ; go see if there's more to read
+LB098           jsr LBD12                       ; parse a numeric string
+                jsr LBC33                       ; assign the numbe to the variable
+LB09E           jsr GETCCH                      ; get current input character
+                beq LB0A8                       ; brif end of line
+                cmpa #',                        ; check for comma
+                lbne LAFD6                      ; brif not - we have bad data
+LB0A8           ldx CHARAD                      ; get current data pointer
+                stx DATTMP                      ; save the data pointer
+                ldx BINVAL                      ; restore the interpreter input pointer
+                stx CHARAD
+                jsr GETCCH                      ; get current input from program
+                beq LB0D5                       ; brif end of statement
+                jsr LB26D                       ; make sure there's a comma between variables
+                bra LB04E                       ; go read another item
+LB0B9           stx CHARAD                      ; reset input pointer
+                jsr LAEE8                       ; search for end of statement
+                leax 1,x                        ; move past end of statement
+                tsta                            ; was it end of line?
+                bne LB0CD                       ; brif not
+                ldb #2*3                        ; code for out of data
+                ldu ,x++                        ; get pointer to next line
+                beq LB10A                       ; brif end of program - raise OD error
+                ldd ,x++                        ; get line number
+                std DATTXT                      ; record it for raising errors in DATA statements
+LB0CD           lda ,x                          ; do we have a DATA statement?
+                cmpa #0x86
+                bne LB0B9                       ; brif not - keep scanning
+                bra LB069                       ; go process the input
+LB0D5           ldx DATTMP                      ; get data pointer
+                ldb INPFLG                      ; were we doing READ?
+                lbne LADE8                      ; brif so - save DATA pointer
+                lda ,x                          ; is there something after the input in the input buffer?
+                beq LB0E7                       ; brif not - we consumed everything
+                ldx #LB0E8-1                    ; print the ?EXTRA IGNORED message
+                jmp LB99C
+LB0E7           rts
+LB0E8           fcc '?EXTRA IGNORED'
+                fcb 0x0d,0x00
+; NEXT command
+NEXT            bne LB0FE                       ; brif argument given
+                ldx ZERO                        ; set to NULL descriptor pointer
+                bra LB101                       ; go process "any index will do"
+LB0FE           jsr LB357                       ; evaluate the variable
+LB101           stx VARDES                      ; save the index we're looking for
+                jsr LABF9                       ; search the stack for the matching frame
+                beq LB10C                       ; brif we found a matching frame
+                ldb #0                          ; code for NEXT without FOR
+LB10A           bra LB153                       ; raise the error
+LB10C           tfr x,s                         ; reset the stack to the start of the stack frame
+                leax 3,x                        ; point to the STEP value
+                jsr LBC14                       ; copy the value to FPA0
+                lda 8,s                         ; get step direction
+                sta FP0SGN                      ; save as sign of FPA0
+                ldx VARDES                      ; point to index variable
+                jsr LB9C2                       ; add (X) to FPA0 (steps the index)
+                jsr LBC33                       ; save new value to the index
+                leax 9,s                        ; point to terminal condition
+                jsr LBC96                       ; compare the new index value with the terminal
+                subb 8,s                        ; set B=0 if we hit the terminal (or passed it with nonzero step)
+                beq LB134                       ; brif loop complete
+                ldx 14,s                        ; restore line number and input pointer to start of loop
+                stx CURLIN
+                ldx 16,s
+                stx CHARAD
+LB131           jmp LAD9E                       ; return to interpretation loop
+LB134           leas 18,s                       ; remove the frame from the stack
+                jsr GETCCH                      ; get character after the index
+                cmpa #',                        ; do we have more indexes?
+                bne LB131                       ; brif not
+                jsr GETNCH                      ; munch the comma
+                bsr LB0FE                       ; go process another value
+; NOTE: despite the BSR on the preceding line, execution of the NEXT command will not fall
+; through this point, nor will the stack grow without bound. The BSR is required to make sure
+; the stack is aligned properly for the stack search for the subsequent index variable.
+;
+; The following is the expression evaluation system. It has various entry points including for type
+; checking. This really consists of two co-routines, one for evaluating operators and one for individual
+; terms. However, it does some rather confusing stack operations so it's a bit difficult to follow
+; just how some of this works.
+;
+; Evaluate numeric expression
+LB141           bsr LB156                       ; evaluate an expression
+; TM error if string
+LB143           andcc #0xfe                     ; clear C to indicate we want a number
+                skip2keepc
+; TM error if numeric
+LB146           orcc #1                         ; set C to indicate we want a string
+; TM error if: C = 1 and number, OR C = 0 and string
+LB148           tst VALTYP                      ; set flags on the current value to (doesn't change C)
+                bcs LB14F                       ; brif we want a string
+                bpl LB0E7                       ; brif we have a number (we want a number)
+                skip2
+LB14F           bmi LB0E7                       ; brif we have a string (we want a string)
+LB151           ldb #12*2                       ; code for TM error
+LB153           jmp LAC46                       ; raise the error
+; The general expression evaluation entry point
+LB156           bsr LB1C6                       ; back up input pointer to compensate for GETNCH below
+LB158           clra                            ; set operator precedence to 0 (no previous operator)
+                skip2
+LB15A           pshs b                          ; save relational operator flags
+                pshs a                          ; save previous operator precedence
+                ldb #1                          ; make sure we aren't overflowing the stack
+                jsr LAC33
+                jsr LB223                       ; go evaluate the first term
+LB166           clr TRELFL                      ; flag no relational operators seen
+LB168           jsr GETCCH                      ; get input character
+LB16A           suba #0xb2                      ; token for > (lowest relational operator)
+                blo LB181                       ; brif below relational operators
+                cmpa #3                         ; there are three relational operators, is it one?
+                bhs LB181                       ; brif not
+                cmpa #1                         ; set C if >
+                rola                            ; shift C into bit 0 (4: <, 2: =, 1: >)
+                eora TRELFL                     ; flip the bit for this operator
+                cmpa TRELFL                     ; did the result get lower?
+                blo LB1DF                       ; brif so - we have a duplicate so raise an error
+                sta TRELFL                      ; save new operator flags
+                jsr GETNCH                      ; munch the operator
+                bra LB16A                       ; go see if we have another one
+LB181           ldb TRELFL                      ; do we have a relational comparison?
+                bne LB1B8                       ; brif so
+                lbcc LB1F4                      ; brif the token is above the relational operators
+                adda #7                         ; put operators starting at 0
+                bhs LB1F4                       ; brif we're above 0 - it's an operator, Jim
+                adca VALTYP                     ; add carry, numeric flag, and modified token number
+                lbeq LB60F                      ; brif we have string and A is + - do concatenation
+                adca #-1                        ; restore operator number
+                pshs a                          ; save operator number
+                asla                            ; times 2
+                adda ,s+                        ; and times 3 (3 bytes per entry)
+                ldx #LAA51                      ; point to operator pecedence and jump table
+                leax a,x                        ; point to correct entry
+LB19F           puls a                          ; get precedence of previous operation
+                cmpa ,x                         ; is hit higher (or same) than the current one?
+                bhs LB1FA                       ; brif so - we need to process that operator
+                bsr LB143                       ; TM error if we have a string
+LB1A7           pshs a                          ; save previous operation precedence
+                bsr LB1D4                       ; push operator handler address and FPA0 onto the stack
+                ldx RELPTR                      ; get pointer to arithmetic/logical table entry for last operation
+                puls a                          ; get back precedence
+                bne LB1CE                       ; brif we had a relational operation
+                tsta                            ; check precedence of previous operation
+                lbeq LB220                      ; brif end of expression
+                bra LB203                       ; go handle operation
+LB1B8           asl VALTYP                      ; get type of value to C
+                rolb                            ; mix it in to bit 0 of relational flags
+                bsr LB1C6                       ; back up input pointer
+                ldx #LB1CB                      ; point to relational operator precedence and handler
+                stb TRELFL                      ; save relational comparison flags
+                clr VALTYP                      ; result will be numeric
+                bra LB19F                       ; to process the operation
+LB1C6           ldx CHARAD                      ; get input pointer
+                jmp LAEBB                       ; back it up one and put it back
+LB1CB           fcb 0x64                        ; precedence of relational comparison
+                fdb LB2F4                       ; handler address for relational comparison
+LB1CE           cmpa ,x                         ; is last done operation higher (or same) precedence?
+                bhs LB203                       ; brif so - go process it
+                bra LB1A7                       ; go push things on the stack and process this operation otherwise
+LB1D4           ldd 1,x                         ; get address of operatorroutine
+                pshs d                          ; save it
+                bsr LB1E2                       ; push FPA0 onto the stack
+                ldb TRELFL                      ; get back relational operator flags
+                lbra LB15A                      ; go evaluate another operation
+LB1DF           jmp LB277                       ; raise a syntax error
+LB1E2           ldb FP0SGN                      ; get sign of FPA0
+                lda ,x                          ; get precedence of this operation
+LB1E6           puls y                          ; get back original caller
+                pshs b                          ; save sign
+LB1EA           ldb FP0EXP                      ; get exponent
+                ldx FPA0                        ; get mantissa
+                ldu FPA0+2
+                pshs u,x,b                      ; stow FPA0 sign and mantissa
+                jmp ,y                          ; return to caller
+LB1F4           ldx ZERO                        ; point to dummy value
+                lda ,s+                         ; get precedence of previous operation (and set flags)
+                beq LB220                       ; brif end of expression
+LB1FA           cmpa #0x64                      ; relational operation?
+                beq LB201                       ; brif so
+                jsr LB143                       ; type mismatch if string
+LB201           stx RELPTR                      ; save pointer to operator routine
+LB203           puls b                          ; get relational flags
+                cmpa #0x5a                      ; NOT operation?
+                beq LB222                       ; brif so (it was unary)
+                cmpa #0x7d                      ; unary negation?
+                beq LB222                       ; brif so
+                lsrb                            ; shift value type flag out of relational flags
+                stb RELFLG                      ; save relational operator flag
+                puls a,x,u                      ; get FP value back
+                sta FP1EXP                      ; set exponent and mantissa in FPA1
+                stx FPA1
+                stu FPA1+2
+                puls b                          ; and the sign
+                stb FP1SGN
+                eorb FP0SGN                     ; set RESSGN if the two operand signs differ
+                stb RESSGN
+LB220           ldb FP0EXP                      ; get exponent of FPA0
+LB222           rts                             ; return or transfer control to operator handler routine
+LB223           jsr RVEC15                      ; do the RAM hook dance
+                clr VALTYP                      ; set type to numeric
+LB228           jsr GETNCH                      ; get first character in the term
+                bcc LB22F                       ; brif not numeric
+LB22C           jmp LBD12                       ; parse a number (and return)
+LB22F           jsr LB3A2                       ; set carry if not alpha
+                bcc LB284                       ; brif alpha character (variable)
+                cmpa #'.                        ; decimal point?
+                beq LB22C                       ; brif so - evaluate number
+                cmpa #0xac                      ; minus?
+                beq LB27C                       ; brif so - process unary negation
+                cmpa #0xab                      ; plus?
+                beq LB228                       ; brif so - ignore unary "posation"
+                cmpa #'"                        ; string delimiter?
+                bne LB24E                       ; brif not
+LB244           ldx CHARAD                      ; get input pointer
+                jsr LB518                       ; go parse the string
+LB249           ldx COEFPT                      ; get address of end of string
+                stx CHARAD                      ; move input pointer past string
+                rts
+LB24E           cmpa #0xa8                      ; NOT?
+                bne LB25F                       ; brif not
+                lda #0x5a                       ; precedence of unary NOT
+                jsr LB15A                       ; process the operand of NOT
+                jsr INTCNV                      ; convert to integer in D
+                coma                            ; do a bitwise complement
+                comb
+                jmp GIVABF                      ; resturn the result
+LB25F           inca                            ; is it a function token?
+                beq LB290                       ; brif so
+LB262           bsr LB26A                       ; only other legal thing must be a (expr)
+                jsr LB156                       ; evaluate parentheticized expression
+LB267           ldb #')                         ; force a )
+                skip2
+LB26A           ldb #'(                         ; force a (
+                skip2
+LB26D           ldb #',                         ; force a ,
+LB26F           cmpb [CHARAD]                   ; does character match?
+                bne LB277                       ; brif not
+                jmp GETNCH                      ; each the character and return the next
+LB277           ldb #2*1                        ; raise syntax error
+                jmp LAC46
+LB27C           lda #0x7d                       ; unary negation precedence
+                jsr LB15A                       ; evaluate argument
+                jmp LBEE9                       ; flip sign of FPA0 and return
+LB284           jsr LB357                       ; evaluate variable
+LB287           stx FPA0+2                      ; save descriptor address in FPA0
+                lda VALTYP                      ; test variable type
+                bne LB222                       ; brif string - we're done
+                jmp LBC14                       ; copy FP number from (X) into FPA0
+LB290           jsr GETNCH                      ; get the actual token number
+                tfr a,b                         ; save it (for offsetting X)
+                lslb                            ; two bytes per jump table entry (and lose high bit)
+                jsr GETNCH                      ; eat the token byte
+                cmpb #2*19                      ; is it a valid token for Color Basic?
+                bls LB29F                       ; brif so
+                jmp [COMVEC+18]                 ; transfer control to Extended Basic if not
+LB29F           pshs b                          ; save jump table offset
+                cmpb #2*14                      ; does it expect a numeric argument?
+                blo LB2C7                       ; brif so
+                cmpb #2*18                      ; does it need no arguments?
+                bhs LB2C9                       ; brif so
+                bsr LB26A                       ; force a (
+                lda ,s                          ; get token value
+                cmpa #2*17                      ; is it POINT?
+                bhs LB2C9                       ; brif so
+                jsr LB156                       ; evaluate first argument string
+                bsr LB26D                       ; force a comma
+                jsr LB146                       ; TM error if string
+                puls a                          ; get token value
+                ldu FPA0+2                      ; get string descriptor
+                pshs u,a                        ; now we save the first string argument and the token value
+                jsr LB70B                       ; evaluate first numeric argument
+                puls a                          ; get back token value
+                pshs b,a                        ; save second argument and token value
+                fcb 0x8e                        ; opcode of LDX immediate (skips two bytes)
+LB2C7           bsr LB262                       ; force a (
+LB2C9           puls b                          ; get offset
+                ldx COMVEC+8                    ; get jump table pointer
+                abx                             ; add offset into table
+                jsr [,x]                        ; go process function
+                jmp LB143                       ; make sure result is numeric
+; operator OR
+LB2D4           skip1lda                        ; set flag to nonzero to signal OR
+; operator AND
+LB2D5           clra                            ; set flag to zero to signal AND
+                sta TMPLOC                      ; save AND/OR flag
+                jsr INTCNV                      ; convert second argument to intenger
+                std CHARAC                      ; save it
+                jsr LBC4A                       ; move first argument to FPA0
+                jsr INTCNV                      ; convert first argument to integer
+                tst TMPLOC                      ; is it AND or OR?
+                bne LB2ED                       ; brif OR
+                anda CHARAC                     ; do the bitwise AND
+                andb ENDCHR
+                bra LB2F1                       ; finish up
+LB2ED           ora CHARAC                      ; do the bitwise OR
+                orb ENDCHR
+LB2F1           jmp GIVABF                      ; return integer result
+; relational comparision operators
+LB2F4           jsr LB148                       ; TM error if type mismatch
+                BNE LB309                       ; brif we have a string comparison
+                lda FP1SGN                      ; pack FPA1
+                ora #0x7f
+                anda FPA1
+                sta FPA1
+                ldx #FP1EXP                     ; point to packed FPA1
+                jsr LBC96                       ; compare FPA0 to FPA1
+                bra LB33F                       ; handle truth comparison
+LB309           clr VALTYP                      ; the result of a comparison is always a number
+                dec TRELFL                      ; remove the string flag from the comparison data
+                jsr LB657                       ; get string details for second argument
+                stb STRDES                      ; save them in the temporary string descriptor
+                stx STRDES+2
+                ldx FPA1+2                      ; get pointer to first argument descriptor
+                jsr LB659                       ; get string details for second argument
+                lda STRDES                      ; get length of second argument
+                pshs b                          ; save length of first argument
+                suba ,s+                        ; now A is the difference in string lengths
+                beq LB328                       ; brif string lengths are equal
+                lda #1                          ; flag for second argument is longer than first
+                bcc LB328                       ; brif second string is longer than first
+                ldb STRDES                      ; get length of second string (shorter)
+                nega                            ; invert default comparison result
+LB328           sta FP0SGN                      ; save default truth flag
+                ldu STRDES+2                    ; get pointer to start of second string
+                incb                            ; compensate for DECB
+LB32D           decb                            ; have we compared everything?
+                bne LB334                       ; brif not
+                ldb FP0SGN                      ; get default truth value
+                bra LB33F                       ; decide comparison truth
+LB334           lda ,x+                         ; get byte from first argument
+                cmpa ,u+                        ; compare with second argument
+                beq LB32D                       ; brif equal - keep comparing
+                ldb #0xff                       ; negative if first string is > second
+                bcc LB33F                       ; brif string A > string B
+                negb                            ; invert result
+LB33F           addb #1                         ; convert to 0,1,2
+                rolb                            ; shift left - now it's 4,2,1 for <, =, >
+                andb RELFLG                     ; keep only the truth we care about
+                beq LB348                       ; brif no matching bits - it's false
+                ldb #0xff                       ; set true
+LB348           jmp LBC7C                       ; convert result to FP and return it
+; DIM command
+LB34B           jsr LB26D                       ; make sure there's a comma between variables
+DIM             ldb #1                          ; flag that we're dimensioning
+                bsr LB35A                       ; go allocate the variable
+                jsr GETCCH                      ; are we done?
+                bne LB34B                       ; brif not
+                rts
+; This routine parses a variable. For scalars, it will return a NULL string or 0 value number
+; if it is called from "evaluate term". Otherwise, it allocates the variable. For arrays, it will
+; allocate a default sized array if dimensioning is not underway and then attempt to look up
+; the requested coordinates in that array. Otherwise, it will allocate an array based on the
+; specified dimension values.
+LB357           clrb                            ; flag that we're not setting up an array
+                jsr GETCCH
+LB35A           stb DIMFLG                      ; save dimensioning flag
+                sta VARNAM                      ; save first character of variable name
+                jsr GETCCH                      ; get input character (why? we already have it)
+                bsr LB3A2                       ; set carry if not alpha
+                lbcs LB277                      ; brif our variable doesn't start with a letter
+                clrb                            ; default second variable character to NUL
+                stb VALTYP                      ; set value type to numeric
+                jsr GETNCH                      ; get second character
+                bcs LB371                       ; brif numeric - numbers are allowed
+                bsr LB3A2                       ; set carry if not alpha
+                bcs LB37B                       ; brif not alpha
+LB371           tfr a,b                         ; save set second character of variable name
+LB373           jsr GETNCH                      ; get an input character
+                bcs LB373                       ; brif numeric - still in variable name
+                bsr LB3A2                       ; set carry if not alpha
+                bcc LB373                       ; brif alpha - still in variable name
+LB37B           cmpa #'$                        ; do we have the string sigil?
+                bne LB385                       ; brif not
+                com VALTYP                      ; set value type to string
+                addb #0x80                      ; set bit 7 of second variable character to indicate string
+                jsr GETNCH                      ; eat the sigil
+LB385           stb VARNAM+1                    ; save second variable name character
+                ora ARYDIS                      ; merge array disable flag (will set bit 7 of input character if no arrays)
+                suba #'(                        ; do we have a subscript?
+                lbeq LB404                      ; brif so
+                clr ARYDIS                      ; disable the array disable flag - it's single use
+                ldx VARTAB                      ; point to the start of the variable table
+                ldd VARNAM                      ; get variable name
+LB395           cmpx ARYTAB                     ; are we at the top of the variable table?
+                beq LB3AB                       ; brif so
+                cmpd ,x++                       ; does the variable name match (and move pointer to variable data)
+                beq LB3DC                       ; brif so
+                leax 5,x                        ; move to next table entry
+                bra LB395                       ; see if we have a match
+; Set carry if not upper case alpha
+LB3A2           cmpa #'A                        ; set C if less than A
+                bcs LB3AA                       ; brif less than A
+                suba #'Z+1                      ; set C if greater than Z
+                suba #-('Z+1)
+LB3AA           rts
+LB3AB           ldx #ZERO                       ; point to empty location (NULL/0 value)
+                ldu ,s                          ; get caller address
+                cmpu #LB287                     ; coming from "evaluate term"?
+                beq LB3DE                       ; brif so - don't allocate
+                ldd ARYEND                      ; get end of arrays
+                std V43                         ; save as top of source block
+                addd #7                         ; 7 bytes per scalar entry
+                std V41                         ; save as top of destination block
+                ldx ARYTAB                      ; get bottom of arrays
+                stx V47                         ; save as bottom of source block
+                jsr LAC1E                       ; move the arrays up to make a hole
+                ldx V41                         ; get new top of arrays
+                stx ARYEND                      ; set new end of arrays
+                ldx V45                         ; get bottom of destination block
+                stx ARYTAB                      ; set as new start of arrays
+                ldx V47                         ; get old end of variables
+                ldd VARNAM                      ; get name of variable
+                std ,x++                        ; set variable name and advance X to the value
+                clra                            ; zero out the variable value
+                clrb
+                std ,x
+                std 2,x
+                sta 4,x
+LB3DC           stx VARPTR                      ; save descriptor address of return value
+LB3DE           rts
+; Various integer conversion routines
+LB3DF           fcb 0x90,0x80,0x00,0x00,0x00    ; FP constant -32768
+LB3E4           jsr GETNCH                      ; fetch input character
+LB3E6           jsr LB141                       ; evaluate numeric expression
+LB3E9           lda FP0SGN                      ; get sign of value
+                bmi LB44A                       ; brif negative (raise FC error)
+INTCNV          lda FP0EXP                      ; get exponent
+                cmpa #0x90                      ; is it within the range for a 16 bit integer?
+                blo LB3FE                       ; brif smaller than 32768
+                ldx #LB3DF                      ; point to -32678 constant
+                jsr LBC96                       ; is FPA0 equal to -32768?
+                bne LB44A                       ; brif not - magnitude is too far negative
+LB3FE           jsr LBCC8                       ; move binary point to the right of FPA0 and correct sign
+                ldd FPA0+2                      ; get the resulting integer
+                rts
+LB404           ldb DIMFLG                      ; get dimensioning flag
+                lda VALTYP                      ; get type of variable
+                pshs b,a                        ; save them (to avoid issues while evaluating dimension values)
+                clrb                            ; reset dimension counter
+LB40A           ldx VARNAM                      ; get variable name
+                pshs x,b                        ; save dimension counter and variable name
+                bsr LB3E4                       ; evaluate a dimension value (and skip either ( or ,)
+                puls b,x,y                      ; get variable name, dimension counter, and dimensioning/type flag
+                stx VARNAM                      ; restore variable name
+                ldu FPA0+2                      ; get dimension size/index
+                pshs u,y                        ; save dimension size and dimensioning/type flag
+                incb                            ; bump dimension counter
+                jsr GETCCH                      ; get what's after the dimension count
+                cmpa #',                        ; do we have another dimension?
+                beq LB40A                       ; brif so - parse it
+                stb TMPLOC                      ; save dimension counter
+                jsr LB267                       ; make sure we have a )
+                puls a,b                        ; get back variable type and dimensioning flag
+                sta VALTYP                      ; restore variable type
+                stb DIMFLG                      ; restore dimensioning flag
+                ldx ARYTAB                      ; get start of arrays
+LB42A           cmpx ARYEND                     ; are we at the end of the array table
+                beq LB44F                       ; brif so
+                ldd VARNAM                      ; get variable name
+                cmpd ,x                         ; does it match?
+                beq LB43B                       ; brif so
+                ldd 2,x                         ; get length of this array
+                leax d,x                        ; move to next array
+                bra LB42A                       ; go check another entry
+LB43B           ldb #2*9                        ; code for redimensioned array error
+                lda DIMFLG                      ; are we dimensioning?
+                bne LB44C                       ; brif so - raise error
+                ldb TMPLOC                      ; get number of dimensions given
+                cmpb 4,x                        ; does it match?
+                beq LB4A0                       ; brif so
+LB447           ldb #8*2                        ; raise "bad subscript"
+                skip2
+LB44A           ldb #4*2                        ; raise "illegal function call"
+LB44C           jmp LAC46                       ; raise error
+LB44F           ldd #5                          ; 5 bytes per array entry
+                std COEFPT                      ; initialize array size to entry size
+                ldd VARNAM                      ; get variable name
+                std ,x                          ; set array name
+                ldb TMPLOC                      ; get dimension count
+                stb 4,x                         ; set dimension count
+                jsr LAC33                       ; make sure we haven't overflowed memory
+                stx V41                         ; save array descriptor address
+LB461           ldb #11                         ; default dimension value (zero-based, gives max index of 10)
+                clra                            ; zero extend (??? why not LDD above?)
+                tst DIMFLG                      ; are we dimensioning?
+                beq LB46D                       ; brif not
+                puls a,b                        ; get dimension size
+                addd #1                         ; account for zero based indexing
+LB46D           std 5,x                         ; save dimension size
+                bsr LB4CE                       ; multiply by accumulated array size
+                std COEFPT                      ; save new array size
+                leax 2,x                        ; move to next dimension
+                dec TMPLOC                      ; have we done all dimensions?
+                bne LB461                       ; brif not
+                stx TEMPTR                      ; save end of array descriptor (minus 5)
+                addd TEMPTR                     ; add total size of array to address of descriptor
+                lbcs LAC44                      ; brif it overflows memory
+                tfr d,x                         ; save end of array for later
+                jsr LAC37                       ; does array fit in memory?
+                subd #STKBUF-5                  ; subtract out the "stack fudge factor" but add 5 to the result
+                std ARYEND                      ; save new end of arrays
+                clra                            ; set up for clearing
+LB48C           leax -1,x                       ; move back one
+                sta 5,x                         ; blank out a byte in the array data
+                cmpx TEMPTR                     ; have we reached the array header?
+                bne LB48C                       ; brif not
+                ldx V41                         ; get address of start of descriptor
+                lda ARYEND                      ; get MSB of end of array back (B still has LSB)
+                subd V41                        ; subtract start of descriptor
+                std 2,x                         ; save length of array in array header
+                lda DIMFLG                      ; are we dimensioning?
+                bne LB4CD                       ; brif so - we're done
+LB4A0           ldb 4,x                         ; get number of dimensions
+                stb TMPLOC                      ; initialize counter
+                clra                            ; initialize accumulated offset
+                clrb
+LB4A6           std COEFPT                      ; save accumulated offset
+                puls a,b                        ; get desired index
+                std FPA0+2                      ; save it
+                cmpd 5,x                        ; is it in range for this dimension?
+                bhs LB4EB                       ; brif not
+                ldu COEFPT                      ; get accumulated offset
+                beq LB4B9                       ; brif first dimension
+                bsr LB4CE                       ; multiply accumulated offset by dimension length
+                addd FPA0+2                     ; add in offset into this dimension
+LB4B9           leax 2,x                        ; move to next dimension in header
+                dec TMPLOC                      ; done all dimensions?
+                bne LB4A6                       ; brif not
+                std ,--s                        ; save D for multiply by 5 (should be pshs d)
+                aslb                            ; times 2
+                rola
+                aslb                            ; times 4
+                rola
+                addd ,s++                       ; times 5
+                leax d,x                        ; add in offset from start of array data
+                leax 5,x                        ; offset to end of header
+                stx VARPTR                      ; save pointer to element data
+LB4CD           rts
+; multiply 16 bit number at 5,x by the 16 bit number in COEFPT; return result in D; BS error if carry
+LB4CE           lda #16                         ; 16 shifts to do a multiply
+                sta V45                         ; save shift counter
+                ldd 5,x                         ; get multiplier
+                std BOTSTK                      ; save it
+                clra                            ; zero out product
+                clrb
+LB4D8           aslb                            ; shift product left
+                rola
+                bcs LB4EB                       ; brif we have a carry
+                asl COEFPT+1                    ; shift other factor left
+                rol COEFPT
+                bcc LB4E6                       ; brif no carry - this bit position is 0
+                addd BOTSTK                     ; add in multiplier at this bit position
+                bcs LB4EB                       ; brif carry - do an error
+LB4E6           dec V45                         ; have we done all 16 bits?
+                bne LB4D8                       ; brif not
+                rts
+LB4EB           jmp LB447                       ; raise a BS error
+; MEM function
+; BUG: this doesn't account for the STKBUF fudge factor used for memory availability checks
+MEM             tfr s,d                         ; get stack pointer where we can do math
+                subd ARYEND                     ; calculate number of bytes between the stack and the top of arrays
+                skip1                           ; return result
+; Convert unsigned value in B to FP
+LB4F3           clra                            ; zero extend
+; Convert signed value in D to FP
+GIVABF          clr VALTYP                      ; set value type to numeric
+                std FPA0                        ; save value in FPA0
+                ldb #0x90                       ; exponent for top two bytes to be an integer
+                jmp LBC82                       ; finish conversion to integer
+; STR$ function
+STR             jsr LB143                       ; make sure we have a number
+                ldu #STRBUF+2                   ; convert FP number to string in temporary string buffer
+                jsr LBDDC
+                leas 2,s                        ; don't return to the function evaluator (which will do a numeric type check)
+                ldx #STRBUF+1                   ; point to number string
+                bra LB518                       ; to stash the string in string space and return to the "evaluate term" caller
+; Reserve B bytes of string space. Return start in X and FRESPC
+LB50D           stx V4D                         ; save X somewhere in case the caller needs it
+LB50F           bsr LB56D                       ; allocate string space
+LB511           stx STRDES+2                    ; save pointer to allocated space in the temporary descriptor
+                stb STRDES                      ; save length in the temporary descriptor
+                rts
+LB516           leax -1,x                       ; move pointer back one (to compensate for the increment below)
+; Scan from X until either NUL or one of the string terminators is found
+LB518           lda #'"                         ; set terminator to be string delimiter
+LB51A           sta CHARAC                      ; set both delimiters
+                sta ENDCHR
+LB51E           leax 1,x                        ; move to next character        
+                stx RESSGN                      ; save start of string
+                stx STRDES+2                    ; save start of string in the temporary string descriptor
+                ldb #-1                         ; initialize length counter to -1 (compensate for initial INCB)
+LB526           incb                            ; bump string length
+                lda ,x+                         ; get character from string
+                beq LB537                       ; brif end of line
+                cmpa CHARAC                     ; is it delimiter #1?
+                beq LB533                       ; brif so
+                cmpa ENDCHR                     ; is it delimiter #2?
+                bne LB526                       ; brif not - keep scanning
+LB533           cmpa #'"                        ; string delimiter?
+                beq LB539                       ; brif so - don't move pointer back
+LB537           leax -1,x                       ; move pointer back (so we don't consume the delimiter)
+LB539           stx COEFPT                      ; save end of string address
+                stb STRDES                      ; save string length
+                ldu RESSGN                      ; get start of string
+                cmpu #STRBUF+2                  ; is it at the start of the string buffer?
+                bhi LB54C                       ; brif so - don't copy it to string space
+                bsr LB50D                       ; allocate string space
+                ldx RESSGN                      ; point to beginning of the string
+                jsr LB645                       ; copy string data (B bytes) from (X) to (FRESPC)
+; Put temporary string descriptor on the string stack
+LB54C           ldx TEMPPT                      ; get top of string stack
+                cmpx #CFNBUF                    ; is the string stack full?
+                bne LB558                       ; brif not
+                ldb #15*2                       ; code for "string formula too complex"
+LB555           jmp LAC46                       ; raise error
+LB558           lda STRDES                      ; get string length
+                sta 0,x                         ; save it in the string stack descriptor
+                ldd STRDES+2                    ; get string data pointer
+                std 2,x                         ; save in string stack descriptor
+                lda #0xff                       ; set value type to string
+                sta VALTYP
+                stx LASTPT                      ; set pointer to last used entry on the string stack
+                stx FPA0+2                      ; set pointer to descriptor in the current evaluation value
+                leax 5,x                        ; advance string stack pointer
+                stx TEMPPT
+                rts
+; Reserve B bytes in string space. If there isn't enough space, try compacting string space and
+; then try the allocation again. If it still fails, raise OS error.
+LB56D           clr GARBFL                      ; flag that compaction not yet done
+LB56F           clra                            ; zero extend the length
+                pshs d                          ; save requested string length
+                ldd STRTAB                      ; get current bottom of strings
+                subd ,s+                        ; calculate new bottom of strings and remove zero extension
+                cmpd FRETOP                     ; does the string fit?
+                blo LB585                       ; brif not - try compaction
+                std STRTAB                      ; save new bottom of strings
+                ldx STRTAB                      ; get bottom of strings
+                leax 1,x                        ; now X points to the real start of the allocated space
+                stx FRESPC                      ; save the string pointer
+                puls b,pc                       ; restore length and return
+LB585           ldb #2*13                       ; code for out of string space
+                com GARBFL                      ; have we compacted string space yet?
+                beq LB555                       ; brif so - raise error
+                bsr LB591                       ; compact string space
+                puls b                          ; get back string length
+                bra LB56F                       ; go try allocation again
+; Compact string space
+; This is an O(n^2) algorithm. It first searches all extant strings for the highest address data pointer
+; that hasn't already been moved into the freshly compacted string space. If then moves that string data
+; up to the highest address it can go to. It repeats this process over and over until it finds no string
+; that isn't already in the compacted space. While doing this, it has to search all strings on the string
+; stack (this is why the string stack is needed - so we can track anonymous strings), all scalar string
+; variables, and *every* entry in every string array.
+LB591           ldx MEMSIZ                      ; get to of string space
+LB593           stx STRTAB                      ; save top of uncompacted stringspace
+                clra                            ; zero out D and reset pointer to discovered variable to NULL
+                clrb
+                std V4B
+                ldx FRETOP                      ; point to bottom of string space
+                stx V47                         ; save as lowest match address (match will be higher)
+                ldx #STRSTK                     ; point to start of string stack
+LB5A0           cmpx TEMPPT                     ; are we at the top of the string stack?
+                beq LB5A8                       ; brif so - done with the string stack
+                bsr LB5D8                       ; check for string in uncompacted space (and advance pointer)
+                bra LB5A0                       ; check another on the string stack
+LB5A8           ldx VARTAB                      ; point to start of scalar variables
+LB5AA           cmpx ARYTAB                     ; end of scalars?
+                beq LB5B2                       ; brif so
+                bsr LB5D2                       ; check for string in uncompacted space and advance pointer
+                bra LB5AA                       ; check another variable
+LB5B2           stx V41                         ; save address of end of variables (address of first array)
+LB5B4           ldx V41                         ; get start of the next array
+LB5B6           cmpx ARYEND                     ; end of arrays?
+                beq LB5EF                       ; brif so
+                ldd 2,x                         ; get length of array
+                addd V41                        ; add to start of array
+                std V41                         ; save address of next array
+                lda 1,x                         ; get second character of variable name
+                bpl LB5B4                       ; brif numeric
+                ldb 4,x                         ; get number of dimensions
+                aslb                            ; two bytes per dimension size
+                addb #5                         ; add in fixed overhead for array descriptor
+                abx                             ; now X points to first array element
+LB5CA           cmpx V41                        ; at the start of the next array?
+                beq LB5B6                       ; brif so - go handle another array
+                bsr LB5D8                       ; check for string in uncompacted space (and advance pointer)
+                bra LB5CA                       ; process next array element
+LB5D2           lda 1,x                         ; get second character of variable name
+                leax 2,x                        ; move to variable data
+                bpl LB5EC                       ; brif numeric
+LB5D8           ldb ,x                          ; get length of string
+                beq LB5EC                       ; brif NULL - don't need to check data pointer
+                ldd 2,x                         ; get data pointer
+                cmpd STRTAB                     ; is it in compacted string space?
+                bhi LB5EC                       ; brif so
+                cmpd V47                        ; is it better match than previous best?
+                bls LB5EC                       ; brif not
+                stx V4B                         ; save descriptor address of best match
+                std V47                         ; save new best data pointer match
+LB5EC           leax 5,x                        ; move to next descriptor
+LB5EE           rts
+LB5EF           ldx V4B                         ; get descriptor address of the matched string
+                beq LB5EE                       ; brif we didn't find one - we're done
+                clra                            ; zero extend length
+                ldb ,x                          ; get string length
+                decb                            ; subtract one (we won't have a NULL string here)
+                addd V47                        ; now D points to the address of the end of the string data
+                std V43                         ; save as top address of move
+                ldx STRTAB                      ; set top of uncompacted space as destination
+                stx V41
+                jsr LAC20                       ; move string to top of uncompactedspace
+                ldx V4B                         ; point to string descriptor
+                ldd V45                         ; get new data pointer address
+                std 2,x                         ; update descriptor
+                ldx V45                         ; get bottom of copy destination
+                leax -1,x                       ; move back below it
+                jmp LB593                       ; go search for another string to move (and set new bottom of string space)
+; Concatenate two strings. We come here directly from the operator handler rather than via a JSR.
+LB60F           ldd FPA0+2                      ; get string descriptor for the first string
+                pshs d                          ; save it
+                jsr LB223                       ; evaluate a second string (concatenation is left associative)
+                jsr LB146                       ; make sure we have a string
+                puls x                          ; get back first string descriptor
+                stx RESSGN                      ; save it
+                ldb ,x                          ; get length of first string
+                ldx FPA0+2                      ; get pointer to second string
+                addb ,x                         ; add length of second string
+                bcc LB62A                       ; brif combined length is OK
+                ldb #2*14                       ; raise string too long error
+                jmp LAC46
+LB62A           jsr LB50D                       ; reserve room for new string
+                ldx RESSGN                      ; get descriptor address of the first string
+                ldb ,x                          ; get length of first string
+                bsr LB643                       ; copy it to string space
+                ldx V4D                         ; get descriptor address of second string
+                bsr LB659                       ; get string details for second string
+                bsr LB645                       ; copy second string into new string space
+                ldx RESSGN                      ; get pointer to first string
+                bsr LB659                       ; remove it from the string stack if possible
+                jsr LB54C                       ; put new string on the string stack
+                jmp LB168                       ; return to expression evaluator
+; Copy B bytes to space pointed to by FRESPC
+LB643           ldx 2,x                         ; get source address from string descriptor
+LB645           ldu FRESPC                      ; get destination address
+                incb                            ; compensate for decb
+                bra LB64E                       ; do the copy
+LB64A           lda ,x+                         ; copy a byte
+                sta ,u+
+LB64E           decb                            ; done yet?
+                bne LB64A                       ; brif not
+                stu FRESPC                      ; save destination pointer
+                rts
+; Fetch details of string in FPA0+2 and remove from the string stack if possible
+LB654           jsr LB146                       ; make sure we have a string
+LB657           ldx FPA0+2                      ; get descriptor pointer
+LB659           ldb ,x                          ; get length of string
+                bsr LB675                       ; see if it's at the top of the string stack and remove it if so
+                bne LB672                       ; brif not removed
+                ldx 5+2,x                       ; get start address of string just removed
+                leax -1,x                       ; move pointer down 1
+                cmpx STRTAB                     ; is it at the bottom of string space?
+                bne LB66F                       ; brif not
+                pshs b                          ; save length
+                addd STRTAB                     ; add length to start of strings (A was cleared previously)
+                std STRTAB                      ; save new string space start (deallocated space for this string)
+                puls b                          ; get back string length
+LB66F           leax 1,x                        ; restore pointer to pointing at the actual string data
+                rts
+LB672           ldx 2,x                         ; get data pointer for the string
+                rts
+; Remove string pointed to by X from the string stack if it is at the top of the stack; return with
+; A clear and Z set if string removed
+LB675           cmpx LASTPT                     ; is it at the top of the string stack?
+                bne LB680                       ; brif not - do nothing
+                stx TEMPPT                      ; save new top of stack
+                leax -5,x                       ; move the "last" pointer back as well
+                stx LASTPT
+                clra                            ; flag string removed
+LB680           rts
+; LEN function
+LEN             bsr LB686                       ; get string details
+LB683           jmp LB4F3                       ; return unsigned length in B
+LB686           bsr LB654                       ; get string details and remove from string stack
+                clr VALTYP                      ; set value type to numeric
+                tstb                            ; set flags according to length
+                rts
+; CHR$ function
+CHR             jsr LB70E                       ; get 8 bit unsigned integer to B
+LB68F           ldb #1                          ; allocate a one byte string
+                jsr LB56D
+                lda FPA0+3                      ; get character code
+                jsr LB511                       ; save reserved string details in temp descriptor
+                sta ,x                          ; put character in string
+LB69B           leas 2,s                        ; don't go back to function handler - avoid numeric type check
+LB69D           jmp LB54C                       ; return temporary string on string stack
+; ASC function
+ASC             bsr LB6A4                       ; get first character of argument
+                bra LB683                       ; return unsigned code in B
+LB6A4           bsr LB686                       ; fetch string details
+                beq LB706                       ; brif NULL string
+                ldb ,x                          ; get character at start of string
+                rts
+; LEFT$ function
+LEFT            bsr LB6F5                       ; get arguments from the stack
+LB6AD           clra                            ; clear pointer offset (set to start of string)
+LB6AE           cmpb ,x                         ; are we asking for more characters than there are in the string?
+                bls LB6B5                       ; brif not
+                ldb ,x                          ; only return the number that are in the string
+                clra                            ; force starting offset to be the start of the string
+LB6B5           pshs b,a                        ; save offset and length
+                jsr LB50F                       ; reserve space in string space
+                ldx V4D                         ; point to original string descriptor
+                bsr LB659                       ; get string details
+                puls b                          ; get string offset
+                abx                             ; now X points to the start of the data to copy
+                puls b                          ; get length of copy
+                jsr LB645                       ; copy the data to the allocated space
+                bra LB69D                       ; return temp string on string stack
+; RIGHT$ function
+RIGHT           bsr LB6F5                       ; get arguments from stack
+                suba ,x                         ; subtract length of original string from desired length
+                nega                            ; now A is offset into old string where we start copying
+                bra LB6AE                       ; go handle everything else
+; MID$ function
+MID             ldb #255                        ; default length is the whole string
+                stb FPA0+3                      ; save it
+                jsr GETCCH                      ; see what we have after offset
+                cmpa #')                        ; end of function?
+                beq LB6DE                       ; brif so - no length
+                jsr LB26D                       ; force a comma
+                bsr LB70B                       ; get length parameter
+LB6DE           bsr LB6F5                       ; get string and offset parameters from the stack
+                beq LB706                       ; brif we have a 0 offset requested (string offsets are 1-based)
+                clrb                            ; clear length counter
+                deca                            ; subtract one from position parameter (we work on 0-based, param is 1-based)
+                cmpa ,x                         ; is start greater than length of string?
+                bhs LB6B5                       ; brif so - return NULL string
+                tfr a,b                         ; save absolute position parameter
+                subb ,x                         ; now B is postition less length
+                negb                            ; now B is amount of string to copy
+                cmpb FPA0+3                     ; is it less than the length requested?
+                bls LB6B5                       ; brif so
+                ldb FPA0+3                      ; set length to the requested length
+                bra LB6B5                       ; go finish up copying the substring
+; Common routine for LEFT$, RIGHT$, MID$ - check for ) and fetch string data and first parameter
+; from the stack. These were evaluated in the function evaluation handler. (It's not clear that doing
+; it that way is actually beneficial. However, this is what the ROM designers did, so here we are.)
+LB6F5           jsr LB267                       ; make sure we have )
+                ldu ,s                          ; get return address - we're going to mess with the stack
+                ldx 5,s                         ; get address of string descriptor
+                stx V4D                         ; save descriptor adddress
+                lda 4,s                         ; get first numeric parameter in both A and B
+                ldb 4,s
+                leas 7,s                        ; clean up stack
+                tfr u,pc                        ; return to original caller
+LB706           jmp LB44A                       ; raise FC error
+; Evaluate an unsigned 8 bit expression to B
+LB709           jsr GETNCH                      ; move to next character
+LB70B           jsr LB141                       ; evaluate a numeric expression
+LB70E           jsr LB3E9                       ; convert to integer in D
+                tsta                            ; are we negative or > 255?
+                bne LB706                       ; brif so - FC error
+                jmp GETCCH                      ; fetch current input character and return
+; VAL function
+VAL             jsr LB686                       ; get string details
+                lbeq LBA39                      ; brif NULL string - return 0
+                ldu CHARAD                      ; get input pointer so we can replace it later
+                stx CHARAD                      ; point interpreter at string data
+                abx                             ; calculate end address of the string
+                lda ,x                          ; get byte after the end of the string
+                pshs u,x,a                      ; save end of string address, input pointer, and character after end of string
+                clr ,x                          ; put a NUL after the string (stops the number interpreter)
+                jsr GETCCH                      ; get input character at start of string
+                jsr LBD12                       ; evaluate numeric expression in string
+                puls a,x,u                      ; get back saved character and pointers
+                sta ,x                          ; restore byte after string
+                stu CHARAD                      ; restore interpeter's input pointer
+                rts
+; Evaluate unsigned expression to BINVAL, then evaluate an unsigned expression to B
+LB734           bsr LB73D                       ; evaluate expression
+                stx BINVAL                      ; save result
+LB738           jsr LB26D                       ; make sure there's a comma
+                bra LB70B                       ; evaluate unsigned expression to B
+; Evaluate unsigned expression in X
+LB73D           jsr LB141                       ; evaluate numeric expression
+LB740           lda FP0SGN                      ; is it negative?
+                bmi LB706                       ; brif so
+                lda FP0EXP                      ; get exponent
+                cmpa #0x90                      ; largest possible exponent for 16 bits
+                bhi LB706                       ; brif too large
+                jsr LBCC8                       ; move binary point to right of FPA0
+                ldx FPA0+2                      ; get resulting unsigned value
+                rts
+; PEEK function
+PEEK            bsr LB740                       ; get address to X
+                ldb ,x                          ; get the value at that address
+                jmp LB4F3                       ; return B as unsigned value
+; POKE function
+POKE            bsr LB734                       ; evaluate address and byte value
+                ldx BINVAL                      ; get address
+                stb ,x                          ; put value there
+                rts
+; LLIST command
+LLIST           ldb #-2                         ; set output device to printer
+                stb DEVNUM
+                jsr GETCCH                      ; reset flags for input character and fall through to LIST
+; LIST command
+LIST            pshs cc                         ; save zero flag (end of statement)
+                jsr LAF67                       ; parse line number
+                jsr LAD01                       ; find address of that line
+                stx LSTTXT                      ; save that address as the start of the list
+                puls cc                         ; get back ent of statement flag
+                beq LB784                       ; brif end of line - list whole program
+                jsr GETCCH                      ; are we at the end of the line (one number)?
+                beq LB789                       ; brif end of line
+                cmpa #0xac                      ; is it "-"?
+                bne LB783                       ; brif not
+                jsr GETNCH                      ; eat the "-"
+                beq LB784                       ; brif no second number - list to end of program
+                jsr LAF67                       ; evaluate the second number
+                beq LB789                       ; brif illegal number
+LB783           rts
+LB784           ldu #0xffff                     ; this will cause listing to do the entire program
+                stu BINVAL
+LB789           leas 2,s                        ; don't return to the caller - we'll jump back to the main loop
+                ldx LSTTXT                      ; get address of line to list
+LB78D           jsr LB95C                       ; do a newline if needed
+                jsr LA549                       ; do a break check
+                ldd ,x                          ; get address of next line
+                bne LB79F                       ; brif not end of program
+LB797           jsr LA42D                       ; close output file
+                clr DEVNUM                      ; reset device to screen
+                jmp LAC73                       ; go back to immediate mode
+LB79F           stx LSTTXT                      ; save new line address
+                ldd 2,x                         ; get line number of this line
+                cmpd BINVAL                     ; is it above the end line?
+                bhi LB797                       ; brif so - return
+                jsr LBDCC                       ; display line number
+                jsr LB9AC                       ; put a space after it
+                ldx LSTTXT                      ; get line address
+                bsr LB7C2                       ; detokenize the line
+                ldx [LSTTXT]                    ; get pointer to next line
+                ldu #LINBUF+1                   ; point to start of detokenized line
+LB7B9           lda ,u+                         ; get byte from detokenized line
+                beq LB78D                       ; brif end of line
+                jsr LB9B1                       ; output character
+                bra LB7B9                       ; handle next character
+; Detokenize a line from (X) to the line input buffer
+LB7C2           jsr RVEC24                      ; do the RAM hook dance
+                leax 4,x                        ; move past next line pointer and line number
+                ldy #LINBUF+1                   ; point to line input buffer (destination)
+LB7CB           lda ,x+                         ; get character from tokenized line
+                beq LB820                       ; brif end of input
+                bmi LB7E6                       ; brif it's a token
+                cmpa #':                        ; colon?
+                bne LB7E2                       ; brif not
+                ldb ,x                          ; get what's after the colon
+                cmpb #0x84                      ; ELSE?
+                beq LB7CB                       ; brif so - suppress the colon
+                cmpb #0x83                      ; '?
+                beq LB7CB                       ; brif so - suppress the colon
+                skip2
+LB7E0           lda #'!                         ; placeholder for unknown token
+LB7E2           bsr LB814                       ; stow output character
+                bra LB7CB                       ; go process another input character
+LB7E6           ldu #COMVEC-10                  ; point to command interptation table
+                cmpa #0xff                      ; is it a function?
+                bne LB7F1                       ; brif not
+                lda ,x+                         ; get function token
+                leau 5,u                        ; shift to the function half of the interpretation tables
+LB7F1           anda #0x7f                      ; remove token bias
+LB7F3           leau 10,u                       ; move to next command/function table
+                tst ,u                          ; is this table active?
+                beq LB7E0                       ; brif not - use place holder
+                suba ,u                         ; subtract number of tokens handled by this table entry
+                bpl LB7F3                       ; brif this token isn't handled here
+                adda ,u                         ; undo extra subtraction
+                ldu 1,u                         ; get reserved word list for this table
+LB801           deca                            ; are we at the right entry?
+                bmi LB80A                       ; brif so
+LB804           tst ,u+                         ; end of entry?
+                bpl LB804                       ; brif not
+                bra LB801                       ; see if we're there yet
+LB80A           lda ,u                          ; get character from wordlist
+                bsr LB814                       ; put character in the buffer
+                tst ,u+                         ; end of word?
+                bpl LB80A                       ; brif not
+                bra LB7CB                       ; go handle another input character
+LB814           cmpy #LINBUF+LBUFMX             ; is there room?
+                bhs LB820                       ; brif not
+                anda #0x7f                      ; lose bit 7
+                sta ,y+                         ; save character in output
+                clr ,y                          ; make sure there's always a NUL terminator
+LB820           rts
+; Tokenize the line that the input pointer is pointing to; put result in the line input buffer; return
+; length in D
+LB821           jsr RVEC23                      ; do the RAM hook dance
+                ldx CHARAD                      ; get input pointer
+                ldu #LINBUF                     ; set destination pointer
+LB829           clr V43                         ; clear alpha string flag
+                clr V44                         ; clear DATA flag
+LB82D           lda ,x+                         ; get input character
+                beq LB852                       ; brif end of input
+                tst V43                         ; are we handling an alphanumeric string?
+                beq LB844                       ; brif not
+                jsr LB3A2                       ; set carry if not alpha
+                bcc LB852                       ; brif alpha
+                cmpa #'0                        ; is it below the digits?
+                blo LB842                       ; brif so
+                cmpa #'9                        ; is it within the digits?
+                bls LB852                       ; brif so
+LB842           clr V43                         ; flag that we're past the alphanumeric string
+LB844           cmpa #0x20                      ; space?
+                beq LB852                       ; brif so - keep it
+                sta V42                         ; save scan delimiter
+                cmpa #'"                        ; string delimiter?
+                beq LB886                       ; brif so - copy until another "
+                tst V44                         ; doing "DATA"?
+                beq LB86B                       ; brif not
+LB852           sta ,u+                         ; put character in output
+                beq LB85C                       ; brif end of input
+                cmpa #':                        ; colon?
+                beq LB829                       ; brif so - reset DATA and alpha string flags
+LB85A           bra LB82D                       ; go process another input character
+LB85C           clr ,u+                         ; put a double NUL at the end
+                clr ,u+
+                tfr u,d                         ; calculate length of result (includes double NUL and an extra two bytes)
+                subd #LINHDR
+                ldx #LINBUF-1                   ; point to one before the output
+                stx CHARAD                      ; set input pointer there
+                rts
+LB86B           cmpa #'?                        ; print abbreviation?
+                bne LB873                       ; brif not
+                lda #0x87                       ; token for PRINT
+                bra LB852                       ; go stash it
+LB873           cmpa #''                        ; REM abbreviation?
+                bne LB88A                       ; brif not
+                ldd #0x3a83                     ; colon plus ' token
+                std ,u++                        ; put it in the output
+LB87C           clr V42                         ; set delimiter to NUL
+LB87E           lda ,x+                         ; get input
+                beq LB852                       ; brif end of line
+                cmpa V42                        ; at the delimiter?
+                beq LB852                       ; brif so
+LB886           sta ,u+                         ; save in output
+                bra LB87E                       ; keep scanning for delimiter
+LB88A           cmpa #'0                        ; is it below digits?
+                blo LB892                       ; brif so
+                cmpa #';+1                      ; is it digit, colon, or semicolon?
+                blo LB852                       ; brif so
+LB892           leax -1,x                       ; move input pointer back one (to point at this input character)
+                pshs u,x                        ; save input and output pointers
+                clr V41                         ; set token type to 0 (command)
+                ldu #COMVEC-10                  ; point to command interpretation table
+LB89B           clr V42                         ; set token counter to 0 (0x80)
+LB89D           leau 10,u                       ; 
+                lda ,u                          ; get number of reserved words
+                beq LB8D4                       ; brif this table isn't active
+                ldy 1,u                         ; point to reserved words list
+LB8A6           ldx ,s                          ; get input pointer
+LB8A8           ldb ,y+                         ; get character from reserved word table
+                subb ,x+                        ; compare with input character
+                beq LB8A8                       ; brif exact match
+                cmpb #0x80                      ; brif it was the last character in word and exact match
+                bne LB8EA                       ; brif not
+                leas 2,s                        ; remove original input pointer from stack
+                puls u                          ; get back output pointer
+                orb V42                         ; create token value (B has 0x80 from above)
+                lda V41                         ; get token type
+                bne LB8C2                       ; brif function
+                cmpb #0x84                      ; is it ELSE?
+                bne LB8C6                       ; brif not
+                lda #':                         ; silently add a colon before ELSE
+LB8C2           std ,u++                        ; put two byte token into output
+                bra LB85A                       ; go handle more input
+LB8C6           stb ,u+                         ; save single byte token
+                cmpb #0x86                      ; DATA?
+                bne LB8CE                       ; brif not
+                inc V44                         ; set DATA flag
+LB8CE           cmpb #0x82                      ; REM?
+                beq LB87C                       ; brif so - skip over rest of line
+LB8D2           bra LB85A                       ; go handle more input
+LB8D4           ldu #COMVEC-5                   ; point to interpretation table, function style
+LB8D7           com V41                         ; invert token flag
+                bne LB89B                       ; brif we haven't already done functions
+                puls x,u                        ; restore input and output pointers
+                lda ,x+                         ; copy first character
+                sta ,u+
+                jsr LB3A2                       ; set C if not alpha
+                bcs LB8D2                       ; brif not alpha - it isn't a variable
+                com V43                         ; set alphanumeric string flag
+                bra LB8D2                       ; process more input
+LB8EA           inc V42                         ; bump token number
+                deca                            ; checked all in this table?
+                beq LB89D                       ; brif so
+                leay -1,y                       ; unconsume last compared character
+LB8F1           ldb ,y+                         ; end of entry?
+                bpl LB8F1                       ; brif not
+                bra LB8A6                       ; check next reserved word
+; PRINT command
+PRINT           beq LB958                       ; brif no argument - do a newline
+                bsr LB8FE                       ; process print options
+                clr DEVNUM                      ; reset output to screen
+                rts
+LB8FE           cmpa #'@                        ; is it PRINT @?
+                bne LB907                       ; brif not
+                jsr LA554                       ; move cursor to correct location
+                bra LB911                       ; handle some more
+LB907           cmpa #'#                        ; device number specified?
+                bne LB918                       ; brif not
+                jsr LA5A5                       ; parse device number
+                jsr LA406                       ; check for valid output file
+LB911           jsr GETCCH                      ; get input character
+                beq LB958                       ; brif nothing - do newline
+                jsr LB26D                       ; need comma after @ or #
+LB918           jsr RVEC9                       ; do the RAM hook boogaloo
+LB91B           beq LB965                       ; brif end of input
+LB91D           cmpa #0xa4                      ; TAB(?
+                beq LB97E                       ; brif so
+                cmpa #',                        ; comma (next tab field)?
+                beq LB966                       ; brif so
+                cmpa #';                        ; semicolon (do not advance print position)
+                beq LB997                       ; brif so
+                jsr LB156                       ; evaluate expression
+                lda VALTYP                      ; get type of value
+                pshs a                          ; save it
+                bne LB938                       ; brif string
+                jsr LBDD9                       ; convert FP number to string
+                jsr LB516                       ; parse a string and put on string stack
+LB938           bsr LB99F                       ; print string
+                puls b                          ; get back variable type
+                jsr LA35F                       ; set up print parameters
+                tst PRTDEV                      ; is it a display device?
+                beq LB949                       ; brif so
+                bsr LB958                       ; do a newline
+                jsr GETCCH                      ; get input
+                bra LB91B                       ; process more print stuff
+LB949           tstb                            ; set flags on print position
+                bne LB954                       ; brif not at start of line
+                jsr GETCCH                      ; get current input
+                cmpa #',                        ; comma?
+                beq LB966                       ; skip to next tab field if so
+                bsr LB9AC                       ; send a space
+LB954           jsr GETCCH                      ; get input character
+                bne LB91D                       ; brif not end of statement
+LB958           lda #0x0d                       ; carriage return
+                bra LB9B1                       ; send it to output
+LB95C           jsr LA35F                       ; set up print parameters
+LB95F           beq LB958                       ; brif width is 0
+                lda DEVPOS                      ; get line position
+                bne LB958                       ; brif not at start of line
+LB965           rts
+LB966           jsr LA35F                       ; set up print parameters
+                beq LB975                       ; brif line width is 0
+                ldb DEVPOS                      ; get line position
+                cmpb DEVLCF                     ; at or past last comma field?
+                blo LB977                       ; brif so
+                bsr LB958                       ; move to next line
+                bra LB997                       ; handle more stuff
+LB975           ldb DEVPOS                      ; get line position
+LB977           subb DEVCFW                     ; subtract a comma field width
+                bhs LB977                       ; brif we don't have a remainder yet
+                negb                            ; now B is number of of spaces needed
+                bra LB98E                       ; go advance
+LB97E           jsr LB709                       ; evaluate TAB distance
+                cmpa #')                        ; closing )?
+                lbne LB277                      ; brif not
+                jsr LA35F                       ; set up print parameters
+                subb DEVPOS                     ; subtract print position from desired position
+                bls LB997                       ; brif we're already past it
+LB98E           tst PRTDEV                      ; is it a display device?
+                bne LB997                       ; brif not
+LB992           bsr LB9AC                       ; output a space
+                decb                            ; done enough?
+                bne LB992                       ; brif not
+LB997           jsr GETNCH                      ; get input character
+                jmp LB91B                       ; process more items
+; cpoy string from (X-1) to output
+LB99C           jsr LB518                       ; parse the string
+LB99F           jsr LB657                       ; get string details
+LB9A2           incb                            ; compensate for decb
+LB9A3           decb                            ; done all of the string?
+                beq LB965                       ; brif so
+                lda ,x+                         ; get character from string
+                bsr LB9B1                       ; send to output
+                bra LB9A3                       ; go do another character
+LB9AC           lda #0x20                       ; space character
+                skip2
+LB9AF           lda #'?                         ; question mark character
+LB9B1           jmp PUTCHR                      ; output character
+; The floating point math package and related functions and operations follow from here
+; to the end of the Color Basic ROM area
+LB9B4           ldx #LBEC0                      ; point to FP constant 0.5
+                bra LB9C2                       ; add 0.5 to FPA0
+LB9B9           jsr LBB2F                       ; unpack FP data from (X) to FPA1
+; subtraction operator
+LB9BC           com FP0SGN                      ; invert sign of FPA0 (subtracting is adding the negative)
+                com RESSGN                      ; that also inverts the sign differential
+                bra LB9C5                       ; go add the negative of FPA0 to FPA1
+LB9C2           jsr LBB2F                       ; unpack FP data from (X) to FPA1
+; addition operator
+LB9C5           tstb                            ; check exponent of FPA0
+                lbeq LBC4A                      ; copy FPA1 to FPA0 if FPA0 is 0
+                ldx #FP1EXP                     ; point X to FPA1 (first operand) as the operand to denormalize
+LB9CD           tfr a,b                         ; put exponent of FPA1 into B
+                tstb                            ; is FPA1 0?
+                beq LBA3E                       ; brif exponent is 0 - no-op; adding 0 to FPA0
+                subb FP0EXP                     ; get difference in exponents - number of bits to shift the smaller mantissa
+                beq LBA3F                       ; brif exponents are equal - no need to denormalize
+                bmi LB9E2                       ; brif FPA0 > FPA1
+                sta FP0EXP                      ; replace result exponent with FPA1's (FPA1 is bigger)
+                lda FP1SGN                      ; also copy sign over
+                sta FP0SGN
+                ldx #FP0EXP                     ; point to FPA0 (we need to denormalize the smaller number)
+                negb                            ; invert the difference - this is the number of bits to shift the mantissa
+LB9E2           cmpb #-8                        ; do we have to shift by a whole byte?
+                ble LBA3F                       ; brif so start by shifting whole bytes to the right
+                clra                            ; clear overflow byte
+                lsr 1,x                         ; shift high bit of mantissa right (LSR will force a zero into the high bit)
+                jsr LBABA                       ; shift remainder of mantissa right -B times
+LB9EC           ldb RESSGN                      ; get the sign flag
+                bpl LB9FB                       ; brif signs are the same (we add the mantissas then)
+                com 1,x                         ; complement the mantissa and extra precision bytes
+                com 2,x
+                com 3,x
+                com 4,x
+                coma
+                adca #0                         ; add one to A (COM sets C); this may cause a carry to enter the ADD below
+LB9FB           sta FPSBYT                      ; save extra precision byte
+                lda FPA0+3                      ; add the main mantissa bytes (and propage carry from above)
+                adca FPA1+3
+                sta FPA0+3
+                lda FPA0+2
+                adca FPA1+2
+                sta FPA0+2
+                lda FPA0+1
+                adca FPA1+1
+                sta FPA0+1
+                lda FPA0
+                adca FPA1
+                sta FPA0
+                tstb                            ; were signs the same?
+                bpl LBA5C                       ; brif so - number may have gotten bigger so normalize if needed
+LBA18           bcs LBA1C                       ; brif we had a carry - result is positive?)
+                bsr LBA79                       ; do a proper negation of FPA0 mantissa
+LBA1C           clrb                            ; clear temporary exponent accumulator
+LBA1D           lda FPA0                        ; test high byte of mantissa
+                bne LBA4F                       ; brif not 0 - we need to do bit shifting
+                lda FPA0+1                      ; shift left 8 bits
+                sta FPA0
+                lda FPA0+2
+                sta FPA0+1
+                lda FPA0+3
+                sta FPA0+2
+                lda FPSBYT
+                sta FPA0+3
+                clr FPSBYT
+                addb #8                         ; account for 8 bits shifted
+                cmpb #5*8                       ; shifted 5 bytes worth?
+                blt LBA1D                       ; brif not
+LBA39           clra                            ; zero out exponent and sign - result is 0
+LBA3A           sta FP0EXP                      ; set exponent and sign
+                sta FP0SGN
+LBA3E           rts
+LBA3F           bsr LBAAE                       ; shift FPA0 mantissa to the right
+                clrb                            ; clear carry
+                bra LB9EC                       ; get on with adding
+LBA44           incb                            ; account for one bit shift
+                asl FPSBYT                      ; shift mantissa and extra precision left
+                rol FPA0+3
+                rol FPA0+2
+                rol FPA0+1
+                rol FPA0
+LBA4F           bpl LBA44                       ; brif we haven't got a 1 in bit 7
+                lda FP0EXP                      ; get exponent of result
+                pshs b                          ; subtract shift count from exponent
+                suba ,s+
+                sta FP0EXP                      ; save adjusted exponent
+                bls LBA39                       ; brif we underflowed - set result to 0
+	skip2
+LBA5C           bcs LBA66                       ; brif mantissa overflowed
+                asl FPSBYT                      ; get bit 7 of expra precision to C (used for round off)
+                lda #0                          ; set to 0 without affecting C
+                sta FPSBYT                      ; clear out extra precision bits
+                bra LBA72                       ; go round off result
+LBA66           inc FP0EXP                      ; bump exponent (for a right shift to bring carry in)
+                beq LBA92                       ; brif we overflowed
+                ror FPA0                        ; shift carry into mantissa, shift right
+                ror FPA0+1
+                ror FPA0+2
+                ror FPA0+3
+LBA72           bcc LBA78                       ; brif no round-off needed
+                bsr LBA83                       ; add one to mantissa
+                beq LBA66                       ; brif carry - need to shift right again
+LBA78           rts
+LBA79           com FP0SGN                      ; invert sign of value
+LBA7B           com FPA0                        ; first do a one's copmlement
+                com FPA0+1
+                com FPA0+2
+                com FPA0+3
+LBA83           ldx FPA0+2                      ; add one to mantissa (after one's complement gives two's complement)
+                leax 1,x                        ; bump low word
+                stx FPA0+2
+                bne LBA91                       ; brif no carry from low word
+                ldx FPA0                        ; bump high word
+                leax 1,x
+                stx FPA0
+LBA91           rts
+LBA92           ldb #2*5                        ; code for overflow
+                jmp LAC46                       ; raise error
+LBA97           ldx #FPA2-1                     ; point to FPA2
+LBA9A           lda 4,x                         ; shift mantissa right by 8 bits
+                sta FPSBYT
+                lda 3,x
+                sta 4,x
+                lda 2,x
+                sta 3,x
+                lda 1,x
+                sta 2,x
+                lda FPCARY                      ; and handle extra precision on the left
+                sta 1,x
+LBAAE           addb #8                         ; account for 8 bits shifted
+                ble LBA9A                       ; brif more shifts needed
+                lda FPSBYT                      ; get sub byte (extra precision)
+                subb #8                         ; undo the 8 added above
+                beq LBAC4                       ; brif difference is 0
+LBAB8           asr 1,x                         ; shift mantissa and sub byte one bit (keep mantissa high bit set)
+LBABA           ror 2,x
+                ror 3,x
+                ror 4,x
+                rora
+                incb                            ; account for one shift
+                bne LBAB8                       ; brif not enought shifts yet
+LBAC4           rts
+LBAC5           fcb 0x81,0x00,0x00,0x00,0x00    ; packed FP 1.0
+LBACA           bsr LBB2F                       ; unpack FP value from (X) to FPA1
+; multiplication operator
+LBACC           beq LBB2E                       ; brif exponent of FPA0 is 0 (result is 0)
+                bsr LBB48                       ; calculate exponent of product
+LBAD0           lda #0                          ; zero out mantissa of FPA2
+                sta FPA2
+                sta FPA2+1
+                sta FPA2+2
+                sta FPA2+3
+                ldb FPA0+3                      ; multiply FPA1 by LSB of FPA0
+                bsr LBB00
+                ldb FPSBYT                      ; save extra precision byte
+                stb VAE
+                ldb FPA0+2
+                bsr LBB00                       ; again for next byte of FPA0
+                ldb FPSBYT
+                stb VAD
+                ldb FPA0+1                      ; again for next byte of FPA0
+                bsr LBB00
+                ldb FPSBYT
+                stb VAC
+                ldb FPA0                        ; and finally for the high byte
+                bsr LBB02
+                ldb FPSBYT
+                stb VAB
+                jsr LBC0B                       ; copy mantissa from FPA2 to FPA0 (result)
+                jmp LBA1C                       ; normalize
+LBB00           beq LBA97                       ; brif multiplier is 0 - just shift, don't multiply
+LBB02           coma                            ; set carry
+LBB03           lda FPA2                        ; get FPA2 MS byte
+                rorb                            ; data bit to carry; will be 0 when all shifts done
+                beq LBB2E                       ; brif 8 shifts done
+                bcc LBB20                       ; brif data bit is 0 - no addition
+                lda FPA2+3                      ; add mantissa of FPA1 and FPA2
+                adda FPA1+3
+                sta FPA2+3
+                lda FPA2+2
+                adca FPA1+2
+                sta FPA2+2
+                lda FPA2+1
+                adca FPA1+1
+                sta FPA2+1
+                lda FPA2
+                adca FPA1
+LBB20           rora                            ; shift carry into FPA2
+                sta FPA2
+                ror FPA2+1
+                ror FPA2+2
+                ror FPA2+3
+                ror FPSBYT
+                clra                            ; clear carry
+                bra LBB03
+LBB2E           rts
+; Unpack FP value from (X) to FPA1
+LBB2F           ldd 1,x                         ; copy mantissa (and sign)
+                sta FP1SGN                      ; save sign bit
+                ora #0x80                       ; make sure mantissa has bit 7 set
+                std FPA1
+                ldb FP1SGN                      ; get sign
+                eorb FP0SGN                     ; set if FPA0 sign differs
+                stb RESSGN
+                ldd 3,x                         ; copy remainder of mantissa
+                std FPA1+2
+                lda ,x                          ; and exponent
+                sta FP1EXP
+                ldb FP0EXP                      ; fetch FPA0 exponent and set flags
+                rts
+; Calculate eponent for product of FPA0 and FPA1
+LBB48           tsta                            ; is FPA1 zero?
+                beq LBB61                       ; brif so
+                adda FP0EXP                     ; add to exponent of FPA0 (this is how scientific notation works)
+                rora                            ; set V if we *don't* have an overflow
+                rola
+                bvc LBB61                       ; brif exponent too larger or small
+                adda #0x80                      ; restore the bias
+                sta FP0EXP                      ; set result exponent
+                beq LBB63                       ; brif 0 - clear FPA0
+                lda RESSGN                      ; the result sign (negative if signs differ) is the result sign
+                sta FP0SGN                      ; so set it as such
+                rts
+LBB5C           lda FP0SGN                      ; get sign of FPA0
+                coma                            ; invert sign
+                bra LBB63                       ; zero sign and exponent
+LBB61           leas 2,s                        ; don't go back to caller (mul/div) - return to previous caller
+LBB63           lbpl LBA39                      ; brif we underflowed - go zero things out
+LBB67           jmp LBA92                       ; raise overflow error
+; fast multiply by 10 - leave result in FPA0
+LBB6A           jsr LBC5F                       ; copy FPA0 to FPA1 (for addition later)
+                beq LBB7C                       ; brif exponent is 0 - it's a no-op then
+                adda #2                         ; this gives "times 4"
+                bcs LBB67                       ; raise overflow if required
+                clr RESSGN                      ; set result sign to "signs the same"
+                jsr LB9CD                       ; add FPA1 to FPA0 "times 5"
+                inc FP0EXP                      ; times 10
+                beq LBB67                       ; brif overflow
+LBB7C           rts
+LBB7D           fcb 0x84,0x20,0x00,0x00,0x00    ; packed FP constant 10.0
+; Divide by 10
+LBB82           jsr LBC5F                       ; move FPA0 to FPA1
+                ldx #LBB7D                      ; point to constant 10
+                clrb                            ; zero sign
+LBB89           stb RESSGN                      ; result will be positive or zero
+                jsr LBC14                       ; unpack constant 10 to FPA0
+                skip2                           ; fall through to division (divide FPA1 by 10)
+LBB8F           bsr LBB2F                       ; unpack FP number from (X) to FPA1
+; division operator
+LBB91           beq LBC06                       ; brif FPA0 is 0 - division by zero
+                neg FP0EXP                      ; get exponent of reciprocal of the divisor
+                bsr LBB48                       ; calculate exponent of quotient
+                inc FP0EXP                      ; bump exponent (due to division algorithm below)
+                beq LBB67                       ; brif overflow
+                ldx #FPA2                       ; point to temporary storage location
+                ldb #4                          ; do 5 bytes
+                stb TMPLOC                      ; save counter
+                ldb #1                          ; shift counter and quotient byte
+LBBA4           lda FPA0                        ; compare mantissa of FPA0 to FPA1, set C if FPA1 less
+                cmpa FPA1
+                bne LBBBD
+                lda FPA0+1
+                cmpa FPA1+1
+                bne LBBBD
+                lda FPA0+2
+                cmpa FPA1+2
+                bne LBBBD
+                lda FPA0+3
+                cmpa FPA1+3
+                bne LBBBD
+                coma                            ; set C if FPA0 = FPA1 (it "goes")
+LBBBD           tfr cc,a                        ; save "it goes" status
+                rolb                            ; rotate carry into quotient
+                bcc LBBCC                       ; brif carry clear - haven't done 8 shifts yet
+                stb ,x+                         ; save quotient byte
+                dec TMPLOC                      ; done enough bytes?
+                bmi LBBFC                       ; brif done all 5
+                beq LBBF8                       ; brif last byte
+                ldb #1                          ; reset shift counter and quotient byte
+LBBCC           tfr a,cc                        ; get back carry status
+                bcs LBBDE                       ; brif it "went"
+LBBD0           asl FPA1+3                      ; shift mantissa (dividend) left
+                rol FPA1+2
+                rol FPA1+1
+                rol FPA1
+                bcs LBBBD                       ; brif carry - it "goes" so we have to bump quotient
+                bmi LBBA4                       ; brif high order bit is set - compare mantissas
+                bra LBBBD                       ; otherwise, count a 0 bit and try next bit
+LBBDE           lda FPA1+3                      ; subtract mantissa of FPA0 from mantissa of FPA1
+                suba FPA0+3
+                sta FPA1+3
+                lda FPA1+2
+                sbca FPA0+2
+                sta FPA1+2
+                lda FPA1+1
+                sbca FPA0+1
+                sta FPA1+1
+                lda FPA1
+                sbca FPA0
+                sta FPA1
+                bra LBBD0                       ; go check for another go
+LBBF8           ldb #0x40                       ; only two bits in last byte (for rounding)
+                bra LBBCC                       ; go do the last byte
+LBBFC           rorb                            ; get low bits to bits 7,6 and C to bit 5
+                rorb
+                rorb
+                stb FPSBYT                      ; save result extra precision
+                bsr LBC0B                       ; move FPA2 mantissa to FPA0 (result)
+                jmp LBA1C                       ; go normalize the result
+LBC06           ldb #2*10                       ; division by zero
+                jmp LAC46                       ; raise error
+; Copy mantissa of FPA2 to FPA0
+LBC0B           ldx FPA2                        ; copy high word
+                stx FPA0
+                ldx FPA2+2                      ; copy low word
+                stx FPA0+2
+                rts
+; unpack FP number at (X) to FPA0
+LBC14           pshs a                          ; save register
+                ldd 1,x                         ; get mantissa high word and sign
+                sta FP0SGN                      ; set sign
+                ora #0x80                       ; make sure mantissa always has bit 7 set
+                std FPA0
+                clr FPSBYT                      ; clear extra precision
+                ldb ,x                          ; get exponent
+                ldx 3,x                         ; copy mantissa low word
+                stx FPA0+2
+                stb FP0EXP                      ; save exponent (and set flags)
+                puls a,pc                       ; restore register and return
+LBC2A           ldx #V45                        ; point to FPA4
+                bra LBC35                       ; pack FPA0 there
+LBC2F           ldx #V40                        ; point to FPA3
+                skip2                           ; fall through to pack FPA0 there
+LBC33           ldx VARDES                      ; get variable descriptor pointer
+; Pack FPA0 to (X)
+LBC35           lda FP0EXP                      ; get exponent
+                sta ,x                          ; save it
+                lda FP0SGN                      ; get sign
+                ora #0x7f                       ; force set low bits - only keep sign in high bit
+                anda FPA0                       ; merge in bits 6-0 of high byte of mantissa
+                sta 1,x                         ; save it
+                lda FPA0+1                      ; copy next highest byte
+                sta 2,x
+                ldu FPA0+2                      ; and the low word of the mantissa
+                stu 3,x
+                rts
+; Copy FPA1 to FPA0; return with sign in A
+LBC4A           lda FP1SGN                      ; copy sign
+LBC4C           sta FP0SGN
+                ldx FP1EXP                      ; copy exponent, mantissa high byte
+                stx FP0EXP
+                clr FPSBYT                      ; clear extra precision
+                lda FPA1+1                      ; copy mantissa second highest byte
+                sta FPA0+1
+                lda FP0SGN                      ; set sign for return
+                ldx FPA1+2                      ; copy low word of mantissa
+                stx FPA0+2
+                rts
+; Copy FPA0 to FPA1
+LBC5F           ldd FP0EXP                      ; copy exponent and high byte of mantissa
+                std FP1EXP
+                ldx FPA0+1                      ; copy middle bytes of mantissa
+                stx FPA1+1
+                ldx FPA0+3                      ; copy low byte of mantissa and sign
+                stx FPA1+3
+                tsta                            ; set flags on exponent
+                rts
+; check FPA0: return B = 0, if FPA0 is 0, 0xff if negative, and 0x01 if positive
+LBC6D           ldb FP0EXP                      ; get exponent
+                beq LBC79                       ; brif 0
+LBC71           ldb FP0SGN                      ; get sign
+LBC73           rolb                            ; get sign to C
+                ldb #0xff                       ; set for negative result
+                bcs LBC79                       ; brif negative
+                negb                            ; set to 1 for positive
+LBC79           rts
+; SGN function
+SGN             bsr LBC6D                       ; get sign of FPA0
+LBC7C           stb FPA0                        ; save result
+                clr FPA0+1                      ; clear next lower 8 bits
+                ldb #0x88                       ; exponent if mantissa is 8 bit integer
+LBC82           lda FPA0                        ; get high bits of mantissa
+                suba #0x80                      ; set C if mantissa was positive (will cause a negation if it was negative)
+LBC86           stb FP0EXP                      ; set exponent
+                ldd ZERO                        ; clear out low word
+                std FPA0+2
+                sta FPSBYT                      ; clear extra precision
+                sta FP0SGN                      ; set sign to positive
+                jmp LBA18                       ; normalize the result
+; ABS function
+ABS             clr FP0SGN                      ; force FPA0 to be positive (yes, it's that simple)
+                rts
+; Compare packed FP number at (X) to FPA0
+; Return with B = -1, 0, 1 for FPA0 <, =, > (X) and flags set based on that
+LBC96           ldb ,x                          ; get exponent of (X)
+                beq LBC6D                       ; brif (X) is 0
+                ldb 1,x                         ; get MS byte of mantissa of (X)
+                eorb FP0SGN                     ; set bit 7 if signs of (X) and FPA0 differ
+                bmi LBC71                       ; brif signs differ - no need to compare the magnitude
+LBCA0           ldb FP0EXP                      ; compare exponents and brif different
+                cmpb ,x
+                bne LBCC3
+                ldb 1,x                         ; compare mantissa (but we have to pack the FPA0 bits first
+                orb #0x7f                       ; keep only sign bit (note: signs are the same)
+                andb FPA0                       ; merge in the mantissa bits from FPA0
+                cmpb 1,x                        ; do the packed versions match?
+                bne LBCC3                       ; brif not
+                ldb FPA0+1                      ; compare second byte of mantissas
+                cmpb 2,x
+                bne LBCC3
+                ldb FPA0+2                      ; compare third byte of mantissas
+                cmpb 3,x
+                bne LBCC3
+                ldb FPA0+3                      ; compare low byte of mantissas, but use subtraction so B = 0 on match
+                subb 4,x
+                bne LBCC3
+                rts                             ; return B = 0 if (X) = FPA0
+LBCC3           rorb                            ; shift carry to bit 7 (C set if FPA0 < (X))
+                eorb FP0SGN                     ; invert the comparision sense if the signs are negative
+                bra LBC73                       ; interpret comparison result
+; Shift mantissa of FPA0 until the binary point is immediately to the right of the mantissa and set up the
+; result as a two's complement value.
+LBCC8           ldb FP0EXP                      ; get exponent of FPA0
+                beq LBD09                       ; brif FPA0 is zero - we don't have to do anything, just blank it
+                subb #0xa0                      ; calculate number of shifts to get to the correct exponent (binary point to the right)
+                lda FP0SGN                      ; do we have a positive number?
+                bpl LBCD7                       ; brif so
+                com FPCARY                      ; negate the mantissa and set extra inbound precision to the correct sign
+                jsr LBA7B
+LBCD7           ldx #FP0EXP                     ; point to FPA0
+                cmpb #-8                        ; moving by whole bytes?
+                bgt LBCE4                       ; brif not
+                jsr LBAAE                       ; do bit shifting
+                clr FPCARY                      ; clear carry in byte
+                rts
+LBCE4           clr FPCARY                      ; clear the extra carry in precision
+                lda FP0SGN                      ; get sign of value
+                rola                            ; get sign to carry (so rotate repeats the sign)
+                ror FPA0                        ; shift the first bit
+                jmp LBABA                       ; do the shifting dance
+; INT function
+INT             ldb FP0EXP                      ; get exponent
+                cmpb #0xa0                      ; is the number big enough that there can be no fractional part?
+                bhs LBD11                       ; brif so - we don't have to do anything
+                bsr LBCC8                       ; go shift binary point to the right of the mantissa
+                stb FPSBYT                      ; save extra precision bits
+                lda FP0SGN                      ; get original sign
+                stb FP0SGN                      ; force result to be positive
+                suba #0x80                      ; set C if we had a positive result
+                lda #0xa0                       ; set exponent to match denormalized result
+                sta FP0EXP
+                lda FPA0+3                      ; save low byte
+                sta CHARAC
+                jmp LBA18                       ; go normalize (this will correct for the two's complement representation of negatives)
+LBD09           stb FPA0                        ; replace mantissa of FPA0 with contents of B
+                stb FPA0+1
+                stb FPA0+2
+                stb FPA0+3
+LBD11           rts
+; Convert ASCII string to FP
+; BUG: no overflow is checked on the decimal exponent in exponential notation.
+LBD12           ldx ZERO                        ; zero out FPA0 and temporaries
+                stx FP0SGN
+                stx FP0EXP
+                stx FPA0+1
+                stx FPA0+2
+                stx V47
+                stx V45
+                bcs LBD86                       ; brif input character is numeric
+                jsr RVEC19                      ; do the RAM hook dance
+                cmpa #'-                        ; regular negative sign
+                bne LBD2D                       ; brif not
+                com COEFCT                      ; invert sign
+                bra LBD31                       ; process stuff after the sign
+LBD2D           cmpa #'+                        ; regular plus?
+                bne LBD35                       ; brif not
+LBD31           jsr GETNCH                      ; get character after sign
+                bcs LBD86                       ; brif numeric
+LBD35           cmpa #'.                        ; decimal point?
+                beq LBD61                       ; brif so
+                cmpa #'E                        ; scientific notation
+                bne LBD65                       ; brif not
+                jsr GETNCH                      ; eat the "E"
+                bcs LBDA5                       ; brif numeric
+                cmpa #0xac                      ; negative sign (token)?
+                beq LBD53                       ; brif so
+                cmpa #'-                        ; regular negative?
+                beq LBD53                       ; brif so
+                cmpa #0xab                      ; plus sign (token)?
+                beq LBD55                       ; brif so
+                cmpa #'+                        ; regular plus?
+                beq LBD55
+                bra LBD59                       ; brif no sign found
+LBD53           com V48                         ; set exponent sign to negative
+LBD55           jsr GETNCH                      ; eat the sign
+                bcs LBDA5                       ; brif numeric
+LBD59           tst V48                         ; is the exponent sign negatvie?
+                beq LBD65                       ; brif not
+                neg V47                         ; negate base 10 exponent
+                bra LBD65
+LBD61           com V46                         ; toggle decimal point flag
+                bne LBD31                       ; brif we haven't seen two decimal points
+LBD65           lda V47                         ; get base 10 exponent
+                suba V45                        ; subtract number of places to the right
+                sta V47                         ; we now have a complete decimal exponent
+                beq LBD7F                       ; brif we have no base 10 shifting required
+                bpl LBD78                       ; brif positive exponent
+LBD6F           jsr LBB82                       ; divide FPA0 by 10 (shift decimal point left)
+                inc V47                         ; bump exponent
+                bne LBD6F                       ; brif we haven't reached 0 yet
+                bra LBD7F                       ; return result
+LBD78           jsr LBB6A                       ; multiply by 10
+                dec V47                         ; downshift the exponent
+                bne LBD78                       ; brif not at 0 yet
+LBD7F           lda COEFCT                      ; get desired sign
+                bpl LBD11                       ; brif it will be positive - no need to do anything
+                jmp LBEE9                       ; flip the sign of FPA0
+LBD86           ldb V45                         ; get the decimal count
+                subb V46                        ; (if decimal seen, will add one; otherwise it does nothing)
+                stb V45
+                pshs a                          ; save new digit
+                jsr LBB6A                       ; multiply partial result by 10
+                puls b                          ; get back digit
+                subb #'0                        ; remove ASCII bias
+                bsr LBD99                       ; add B to FPA0
+                bra LBD31                       ; go process another digit
+LBD99           jsr LBC2F                       ; save FPA0 to FPA3
+                jsr LBC7C                       ; convert B to FP number
+                ldx #V40                        ; point to FPA3
+                jmp LB9C2                       ; add FPA3 and FPA0
+LBDA5           ldb V47                         ; get exponent value
+                aslb                            ; times 2
+                aslb                            ; times 4
+                addb V47                        ; times 5
+                aslb                            ; times 10
+                suba #'0                        ; remove ASCII bias
+                pshs b                          ; save acculated result
+                adda ,s+                        ; add new digit to accumulated result
+                sta V47                         ; save new accumulated decimal exponent
+                bra LBD55                       ; interpret another exponent character
+LBDB6           fcb 0x9b,0x3e,0xbc,0x1f,0xfd    ; packed FP: 99999999.9
+LBDBB           fcb 0x9e,0x6e,0x6b,0x27,0xfd    ; packed FP: 999999999
+LBDC0           fcb 0x9e,0x6e,0x6b,0x28,0x00    ; pakced FP: 1E9
+LBDC5           ldx #LABE8-1                    ; point to "IN" message
+                bsr LBDD6                       ; output the string
+                ldd CURLIN                      ; get basic line number
+LBDCC           std FPA0                        ; save 16 bit unsigned integer
+                ldb #0x90                       ; exponent for upper 16 bits of FPA0 to be an integer
+                coma                            ; set C (force normalization to treat as positive)
+                jsr LBC86                       ; zero bottom half, save exponent, and normalize
+                bsr LBDD9                       ; convert FP number to ASCII string
+LBDD6           jmp LB99C                       ; output string
+; Convert FP number to ASCII string
+LBDD9           ldu #STRBUF+3                   ; point to buffer address that will not cause string to go to string space
+LBDDC           lda #0x20                       ; default sign is a space character
+                ldb FP0SGN                      ; get sign of value
+                bpl LBDE4                       ; brif positive
+                lda #'-                         ; use negative sign
+LBDE4           sta ,u+                         ; save sign
+                stu COEFPT                      ; save output buffer pointer
+                sta FP0SGN                      ; save sign character
+                lda #'0                         ; result is 0 if exponent is 0
+                ldb FP0EXP                      ; get exponent
+                lbeq LBEB8                      ; brif FPA0 is 0
+                clra                            ; base 10 exponent is 0 for > 1
+                cmpb #0x80                      ; is number > 1?
+                bhi LBDFF                       ; brif so
+                ldx #LBDC0                      ; point to 1E+09
+                jsr LBACA                       ; shift decimal to the right by 9 spaces
+                lda #-9                         ; account for shift
+LBDFF           sta V45                         ; save base 10 exponent
+LBE01           ldx #LBDBB                      ; point to 999999999
+                jsr LBCA0                       ; are we above that?
+                bgt LBE18                       ; brif so
+LBE09           ldx #LBDB6                      ; point to 99999999.9
+                jsr LBCA0                       ; are we above that?
+                bgt LBE1F                       ; brif in range
+                jsr LBB6A                       ; multiply by 10 (we were small)
+                dec V45                         ; account for shift
+                bra LBE09                       ; see if we've come into range
+LBE18           jsr LBB82                       ; divide by 10
+                inc V45                         ; account for shift
+                bra LBE01                       ; see if we've come into range
+LBE1F           jsr LB9B4                       ; add 0.5 to FPA0 (rounding)
+                jsr LBCC8                       ; do the integer dance
+                ldb #1                          ; default decimal flag (force immediate decimal)
+                lda V45                         ; get base 10 exponent
+                adda #10                        ; account for "unormalized" number
+                bmi LBE36                       ; brif number < 1.0
+                cmpa #11                        ; do we have more than 9 places?
+                bhs LBE36                       ; brif so - do scientific notation
+                deca
+                tfr a,b
+                lda #2                          ; force no scientific notation
+LBE36           deca                            ; subtract wo without affecting carry
+                deca
+                sta V47                         ; save exponent - 0 is do not display in scientific notation
+                stb V45                         ; save number of places to left of decimal
+                bgt LBE4B                       ; brif >= 1
+                ldu COEFPT                      ; point to string buffer
+                lda #'.                         ; put decimal
+                sta ,u+
+                tstb                            ; is there anything to left of decimal?
+                beq LBE4B                       ; brif not
+                lda #'0                         ; store a zero
+                sta ,u+
+LBE4B           ldx #LBEC5                      ; point to powers of 10
+                ldb #0x80                       ; set digit counter to 0x80
+LBE50           lda FPA0+3                      ; add mantissa to power of 10
+                adda 3,x
+                sta FPA0+3
+                lda FPA0+2
+                adca 2,x
+                sta FPA0+2
+                lda FPA0+1
+                adca 1,x
+                sta FPA0+1
+                lda FPA0
+                adca ,x
+                sta FPA0
+                incb                            ; add one to digit counter
+                rorb                            ; put carry into bit 7
+                rolb                            ; set V if carry and sign differ
+                bvc LBE50                       ; brif positive mantissa or carry is 0 and negative mantissa
+                bcc LBE72                       ; brif negative mantissa
+                subb #10+1                      ; take 9's complement if adding mantissa
+                negb
+LBE72           addb #'0-1                      ; add ASCII bias
+                leax 4,x                        ; move to next power of 10
+                tfr b,a                         ; save digit
+                anda #0x7f                      ; remove add/subtract flag
+                sta ,u+                         ; put in output
+                dec V45                         ; do we need a decimal yet?
+                bne LBE84                       ; brif not
+                lda #'.                         ; put decimal
+                sta ,u+
+LBE84           comb                            ; toggle bit 7 (add/sub flag)
+                andb #0x80                      ; only keep bit 7
+                cmpx #LBEC5+9*4                 ; done all places?
+                bne LBE50                       ; brif not
+LBE8C           lda ,-u                         ; get last character
+                cmpa #'0                        ; was it 0?
+                beq LBE8C                       ; brif so
+                cmpa #'.                        ; decimal?
+                bne LBE98                       ; brif not
+                leau -1,u                       ; move past decimal if it isn't needed
+LBE98           lda #'+                         ; plus sign
+                ldb V47                         ; get scientific notation exponent
+                beq LBEBA                       ; brif not scientific notation
+                bpl LBEA3                       ; brif positive exponent
+                lda #'-                         ; negative sign for base 10 exponent
+                negb                            ; switch to positive exponent
+LBEA3           sta 2,u                         ; put sign
+                lda #'E                         ; put "E"
+                sta 1,u
+                lda #'0-1                       ; init to ASCII 0 (compensate for INC)
+LBEAB           inca                            ; bump digit
+                subb #10                        ; have we hit the correct one yet?
+                bcc LBEAB                       ; brif not
+                addb #'9+1                      ; convert units digit to ASCII
+                std 3,u                         ; put exponent in output
+                clr 5,u                         ; put trailing NUL
+                bra LBEBC                       ; go reset pointer
+LBEB8           sta ,u                          ; store last character
+LBEBA           clr 1,u                         ; put NUL at the end
+LBEBC           ldx #STRBUF+3                   ; point to start of string
+                rts
+LBEC0           fcb 0x80,0x00,0x00,0x00,0x00    ; packed FP 0.5
+LBEC5           fqb -100000000
+                fqb 10000000
+                fqb -1000000
+                fqb 100000
+                fqb -10000
+                fqb 1000
+                fqb -100
+                fqb 10
+                fqb -1
+LBEE9           lda FP0EXP                      ; get exponent of FPA0
+                beq LBEEF                       ; brif 0 - don't flip sign
+                com FP0SGN                      ; flip sign
+LBEEF           rts
+; Expand a polynomial of the form
+; AQ+BQ^3+CQ^5+DQ^7..... where Q is FPA0 and X points to a table
+LBEF0           stx COEFPT                      ; save coefficient table pointer
+                jsr LBC2F                       ; copy FPA0 to FPA3
+                bsr LBEFC                       ; multiply FPA3 by FPA0
+                bsr LBF01                       ; expand polynomial
+                ldx #V40                        ; point to FPA3
+LBEFC           jmp LBACA                       ; multiply FPA0 by FPA3
+LBEFF           stx COEFPT                      ; save coefficient table counter
+LBF01           jsr LBC2A                       ; move FPA0 to FPA4
+                ldx COEFPT                      ; get the current coefficient
+                ldb ,x+                         ; get the number of entries
+                stb COEFCT                      ; save as counter
+                stx COEFPT                      ; save new pointer
+LBF0C           bsr LBEFC                       ; multiply (X) and FPA0
+                ldx COEFPT                      ; get this coefficient
+                leax 5,x                        ; move to next one
+                stx COEFPT                      ; save new pointer
+                jsr LB9C2                       ; add (X) to FPA0
+                ldx #V45                        ; point X to FPA4
+                dec COEFCT                      ; done all coefficients?
+                bne LBF0C                       ; brif more left
+                rts
+; RND function
+RND             jsr LBC6D                       ; set flags on FPA0
+                bmi LBF45                       ; brif negative - set seed
+                beq LBF3B                       ; brif 0 - do random between 0 and 1
+                bsr LBF38                       ; convert to integer
+                jsr LBC2F                       ; save range value
+                bsr LBF3B                       ; get random number
+                ldx #V40                        ; point to FPA3
+                bsr LBEFC                       ; multply (X) by FPA0
+                ldx #LBAC5                      ; point to FP 1.0
+                jsr LB9C2                       ; add 1 to FPA0
+LBF38           jmp INT                         ; return integer value
+LBF3B           ldx RVSEED+1                    ; move variable random number seed to FPA0
+                stx FPA0
+                ldx RVSEED+3
+                stx FPA0+2
+LBF45           ldx RSEED                       ; move fixed seed to FPA1
+                stx FPA1
+                ldx RSEED+2
+                stx FPA1+2
+                jsr LBAD0                       ; multiply them
+                ldd VAD                         ; get lowest order  product bytes
+                addd #0x658b                    ; add a constant
+                std RVSEED+3                    ; save it as new seed
+                std FPA0+2                      ; save in result
+                ldd VAB                         ; get high order extra product bytes
+                adcb #0xb0                      ; add upper bytes of constant
+                adca #5
+                std RVSEED+1                    ; save as new seed
+                std FPA0                        ; save as result
+                clr FP0SGN                      ; set result to positive
+                lda #0x80                       ; set exponent to 0 < FPA0 < 1
+                sta FP0EXP
+                lda FPA2+2                      ; get a byte from FPA2
+                sta FPSBYT                      ; save as extra precision
+                jmp LBA1C                       ; go normalize FPA0
+RSEED           fqb 0x40e64dab                  ; constant random number generator seed
+; SIN function
+SIN             jsr LBC5F                       ; copy FPA0 to FPA1
+                ldx #LBFBD                      ; point to 2*pi
+                ldb FP1SGN                      ; get sign of FPA1
+                jsr LBB89                       ; divide FPA0 by 2*pi
+                jsr LBC5F                       ; copy FPA0 to FPA1
+                bsr LBF38                       ; convert FPA0 to an integer
+                clr RESSGN                      ; set result to positive
+                lda FP1EXP                      ; get exponent of FPA1
+                ldb FP0EXP                      ; get exponent of FPA0
+                jsr LB9BC                       ; subtract FPA0 from FPA1
+                ldx #LBFC2                      ; point to FP 0.25
+                jsr LB9B9                       ; subtract FPA0 from 0.25 (pi/2)
+                lda FP0SGN                      ; get result sign
+                pshs a                          ; save it
+                bpl LBFA6                       ; brif positive
+                jsr LB9B4                       ; add 0.5 (pi) to FPA0
+                lda FP0SGN                      ; get sign of result
+                bmi LBFA9                       ; brif negative
+                com RELFLG                      ; if 3pi/2 >= arg >= pi/2
+LBFA6           jsr LBEE9                       ; flip sign of FPA0
+LBFA9           ldx #LBFC2                      ; point to 0.25
+                jsr LB9C2                       ; add 0.25 (pi/2) to FPA0
+                puls a                          ; get original sign
+                tsta                            ; was it positive
+                bpl LBFB7                       ; brif so
+                jsr LBEE9                       ; flip result sign
+LBFB7           ldx #LBFC7                      ; point to series coefficients
+                jmp LBEF0                       ; go calculate value
+LBFBD           fcb 0x83,0x49,0x0f,0xda,0xa2    ; 2*pi
+LBFC2           fcb 0x7f,0x00,0x00,0x00,0x00    ; 0.25
+; modified taylor series SIN coefficients
+LBFC7           fcb 6-1                         ; six coefficients
+                fcb 0x84,0xe6,0x1a,0x2d,0x1b    ; -((2pi)^11)/11!
+                fcb 0x86,0x28,0x07,0xfb,0xf8    ; ((2pi)^9)/9!
+                fcb 0x87,0x99,0x68,0x89,0x01    ; -((2pi)^7)/7!
+                fcb 0x87,0x23,0x35,0xdf,0xe1    ; ((2pi)^5)/5!
+                fcb 0x86,0xa5,0x5d,0xe7,0x28    ; -(2pi)^3)/3!
+                fcb 0x83,0x49,0x0f,0xda,0xa2    ; 2*pi
+; these 12 bytes are unused
+                fcb 0xa1,0x54,0x46,0x8f,0x13,0x8f,0x52,0x43
+                fcb 0x89,0xcd,0xa6,0x81
+; these are the hardware interrupt vectors (coco1/2 only)
+                fdb SW3VEC
+                fdb SW2VEC
+                fdb FRQVEC
+                fdb IRQVEC
+                fdb SWIVEC
+                fdb NMIVEC
+                fdb RESVEC
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bas11.s	Sat Dec 08 19:57:01 2018 -0700
@@ -0,0 +1,4068 @@
+                *pragma nolist
+                include defs.s
+                *pragma list
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; COLOR BASIC ROM
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+                org BASIC
+; This is the official set of ROM entry points. It is unfortunate that the generic input ("console in") routine is not exposed
+; here. It is also unfortunate that no open and close file routines are exposed. This and other oversignts led to a lot of
+; software either having to re-invent the wheel or calling directly into the ROM instead of via these official entry points.
+POLCAT          fdb KEYIN                       ; indirect jump, get a keystroke
+CHROUT          fdb PUTCHR                      ; indirect jump, output character
+CSRDON          fdb CASON                       ; indirect jump, turn cassette on and start reading
+BLKIN           fdb GETBLK                      ; indirect jump, read a block from tape
+BLKOUT          fdb SNDBLK                      ; indirect jump, write a block to tape
+JOYIN           fdb GETJOY                      ; indirect jump, read joystick axes
+WRTLDR          fdb WRLDR                       ; indirect jump, turn cassette on and write a leader
+; Initialization code.
+LA00E           lds #LINBUF+LBUFMX+1            ; put the stack in the line input buffer which is a safe place for now
+                lda #0x37                       ; enable the cartidge interrupt (to detect autostarting cartridges)
+                sta PIA1+3
+                lda RSTFLG                      ; get warm start flag
+                cmpa #0x55                      ; is it valid?
+                bne BACDST                      ; brif not - cold start
+                ldx RSTVEC                      ; get warm start routine pointer
+                lda ,x                          ; get first byte of the routine
+                cmpa #0x12                      ; is it NOP?
+                bne BACDST                      ; brif not - the routine is invalid so do a cold start
+                jmp ,x                          ; transfer control to the warm start routine
+; RESET/power on comes here
+RESVEC          leay LA00E,pcr                  ; point to warm start check code
+LA02A           ldx #PIA1                       ; point to PIA1 - we're going to rely on the mirroring to reach PIA0
+                clr -3,x                        ; set PIA0 DA to direction mode
+                clr -1,x                        ; set PIA0 DB to direction mode
+                clr -4,x                        ; set PIA0 DA to inputs
+                ldd #0xff34
+                sta -2,x                        ; set PIA0 DB to outputs
+                stb -3,x                        ; set PIA0 DA to data mode
+                stb -1,x                        ; set PIA0 DB to data mode
+                clr 1,x                         ; set PIA1 DA to direction mode
+                clr 3,x                         ; set PIA1 DB to direction mode
+                deca
+                sta ,x                          ; set PIA1 DA bits 7-1 as output, 0 as input
+                lda #0xf8                       ; set PIA1 DB bits 7-3 as output, 2-0 as input
+                sta 2,x
+                stb 1,x                         ; set PIA1 DA to data mode
+                stb 3,x                         ; set PIA1 DB to data mode
+                clr 2,x                         ; set VDG to alpha-numeric
+                ldb #2                          ; make RS232 marking ("stop" bit)
+                stb ,x
+                ldu #SAMREG                     ; point to SAM register
+                ldb #16                         ; 16 bits to clear
+LA056           sta ,u++                        ; clear a bit
+                decb                            ; done all?
+                bne LA056                       ; brif not
+                sta SAMREG+9                    ; put display at 0x400
+                tfr b,dp                        ; set direct page to 0
+                ldb #4                          ; use as a mask to check RAMSZ input
+	sta -2,x                        ; set RAMSZ strobe high
+	bitb 2,x                        ; check RAMSZ input
+	beq LA072                       ; brif set for 4K RAMs
+	clr -2,x                        ; set strobe low
+	bitb 2,x                        ; check input
+	beq LA070                       ; brif set for 64K rams
+	leau -2,u                       ; adjust pointer to set SAM for 16K RAMs
+LA070           sta -3,u                        ; program SAM for either 16K or 64K RAMs
+LA072           jmp ,y                          ; transfer control to startup routine
+; Cold start jumps here
+BACDST          ldx #VIDRAM+1                   ; point past the top of the first 1K of memory (for double predec below)
+LA077           clr ,--x                        ; clear a byte (last will actually try clearing LSB of RESET vector in ROM)
+                leax 1,x                        ; move forward one byte (will set Z if we're done)
+                bne LA077                       ; brif not donw yet
+                jsr LA928                       ; clear the screen
+                clr ,x+                         ; put the constant zero that lives before the program
+                stx TXTTAB                      ; set beginning of program storage
+LA084           lda 2,x                         ; get value from memory
+                coma                            ; make it different
+                sta 2,x                         ; try putting different into memory
+                cmpa 2,x                        ; did it matcH?
+                bne LA093                       ; brif not - we found the end of memory
+                leax 1,x                        ; move pointer forward
+                com 1,x                         ; restore the original memory contents
+                bra LA084                       ; try another byte
+LA093           stx TOPRAM                      ; save top of memory (one below actual top because we need a byte for VAL() to work)
+                stx MEMSIZ                      ; save top of string space
+                stx STRTAB                      ; set bottom of allocated string space
+                leax -200,x                     ; allocate 200 bytes of string space
+                stx FRETOP                      ; set top of actually free memory
+                tfr x,s                         ; put the stack there
+                ldx #LA10D                      ; point to variable initializer
+                ldu #CMPMID                     ; point to variables to initialize (first batch)
+                ldb #28                         ; 28 bytes in first batch
+                jsr LA59A                       ; copy bytes to variables
+                ldu #IRQVEC                     ; point to variables to initialize (second batch)
+                ldb #30                         ; 30 bytes this time
+                jsr LA59A                       ; copy bytes to variables
+                ldx -12,x                       ; get SN error address
+                stx 3,u                         ; set ECB's command handlers to error
+                stx 8,u
+                ldx #RVEC0                      ; point to RAM vectors
+                ldd #0x394b                     ; write 75 RTS opcodes (25 RAM vectors)
+LA0C0           sta ,x+                         ; put an RTS
+                decb                            ; done?
+                bne LA0C0                       ; brif not
+                sta LINHDR-1                    ; make temporary line header data for line encoding have a nonzero next line pointer
+                jsr LAD19                       ; do a "NEW"
+                ldx #'E*256+'X                  ; magic number to detect ECB ROM
+                cmpx EXBAS                      ; is there an ECB ROM?
+                lbeq EXBAS+2                    ; brif so - launch it
+                andcc #0xaf                     ; start interrupts
+                ldx #LA147-1                    ; point to sign on message
+                jsr LB99C                       ; print it out
+                ldx #BAWMST                     ; warm start routine address
+                stx RSTVEC                      ; set vector there
+                lda #0x55                       ; warm start valid flag
+                sta RSTFLG                      ; mark warm start valid
+                bra LA0F3                       ; go to direct mode
+; Warm start entry point
+BAWMST          nop                             ; valid routine marker
+                clr DEVNUM                      ; reset output/input to screen
+                jsr LAD33                       ; do a partial NEW
+                andcc #0xaf                     ; start interrupts
+                jsr LA928                       ; clear the screen
+LA0F3           jmp LAC73                       ; go to direct mode
+; FIRQ service routine - this handles starting autostart cartridges
+BFRQSV          tst PIA1+3                      ; is it the cartridge interrupt?
+                bmi LA0FC                       ; brif so
+                rti
+LA0FC           jsr LA7D1                       ; delay for a while
+                jsr LA7D1                       ; delay for another while
+                leay <LA108,pcr                 ; point to cartridge starter
+                jmp LA02A                       ; go initialize everything clean for the cartridge
+LA108           clr RSTFLG                      ; force a cold start a cartridge reset
+                jmp ROMPAK                      ; transfer control to the cartridge
+; Variable initializers (first batch)
+LA10D           fcb 18                          ; mid band partition of the 1200/2400 Hz period
+                fcb 24                          ; upper limit of 1200 Hz period
+                fcb 10                          ; upper limit of 2400 Hz period
+                fdb 128                         ; number of 0x55s for cassette leader
+                fcb 11                          ; cursor blink delay
+                fdb 87                          ; 600 baud delay constant
+                fdb 1                           ; printer carriage return delay constant
+                fcb 16                          ; printer tab field width
+                fcb 112                         ; last printer tab zone
+                fcb 132                         ; printer carriage width
+                fcb 0                           ; printer carriage position
+                fdb LB44A                       ; default execution address for EXEC
+                inc CHARAD+1                    ;* character fetching routines (DP portion) - we first do a two
+                bne LA123                       ;* two stage increment of CHARAD then load the value into A
+                inc CHARAD                      ;* before transferring control to the bottom half routine in ROM
+LA123           lda >0                          ; NOTE: the 0 is a placeholder, extended addressing is required
+                jmp BROMHK
+; Variable initializers (second batch)
+                jmp BIRQSV                      ; IRQ handler
+                jmp BFRQSV                      ; FIRQ handler
+                jmp LB44A                       ; default USR() address
+                fcb 0x80,0x4f,0xc7,0x52,0x59    ; random seed
+                fcb 0xff                        ; capslock flag - default to upper case
+                fdb DEBDEL                      ; keyboard debounce delay (why is it a variable?)
+                jmp LB277                       ; exponentiation handler vector
+                fcb 53                          ; (command interpretation table) 53 commands
+                fdb LAA66                       ; (command interpretation table) reserved words list (commands)
+                fdb LAB67                       ; (command interpretation table) jump table (commands)
+                fcb 20                          ; (command interpretation table) 20 functions
+                fdb LAB1A                       ; (command interpretation table) reserved words list (functions)
+                fdb LAA29                       ; (command interpretation table) jump table (functions)
+; This is the signon message.
+LA147           fcc 'COLOR BASIC 1.1'
+                fcb 0x0d
+                fcc '(C) 1980 TANDY'
+                fcb 0
+; This is the "invalid colour" CLS easter egg text. Basically 11 wasted bytes
+LA166           fcc 'MICROSOFT'
+                fcb 0x0d,0
+; Read a character from current device and mask off bit 7 (keep it as 7 bit ASCII)
+LA171           bsr LA176                       ; get character
+                anda #0x7f                      ; mask off high bit
+                rts
+; Generic read routine. Reads a character from the device specified by DEVNUM. If no input was available,
+; CINBFL will bet nonzero (on EOF). If input was available, CINBFL will be zero. Note that this routine
+; has undefined results when called on an output only device. All registers except CC and A are preserved.
+LA176           jsr RVEC4                       ; do RAM hook
+                clr CINBFL                      ; flag data available
+                tst DEVNUM                      ; is it keyboard?
+                beq LA1B1                       ; brif so - blink cursor and wait for key press
+                tst CINCTR                      ; is there anything in cassette input buffer?
+                bne LA186                       ; brif so
+                com CINBFL                      ; flag EOF
+                rts
+; Read character from cassette file
+LA186           pshs u,y,x,b                    ; preserve registers
+                ldx CINPTR                      ; get input buffer pointer
+                lda ,x+                         ; get character from buffer
+                pshs a                          ; save it for return
+                stx CINPTR                      ; save new input buffer pointer
+                dec CINCTR                      ; count character just consumed
+                bne LA197                       ; brif buffer is not empty yet
+                jsr LA635                       ; go read another block, if any, to refill the buffer
+LA197           puls a,b,x,y,u,pc               ; restore registers and return the character
+; Blink the cursor. This might be better timed via an interrupt or something.
+LA199           dec BLKCNT                      ; is it time to blink the cursor?
+                bne LA1AB                       ; brif not
+                ldb #11                         ; reset blink timer
+                stb BLKCNT
+                ldx CURPOS                      ; get cursor position
+                lda ,x                          ; get character at the cursor
+                adda #0x10                      ; move to next color
+                ora #0x8f                       ; make sure it's a grahpics block with all elements lit
+                sta ,x                          ; put new cursor block on screen
+LA1AB           ldx #DEBDEL                     ; we'll use the debounce delay for the cursor blink timer (10ms)
+LA1AE           jmp LA7D3                       ; go count X down
+; Blink cursor while waiting for a key press
+LA1B1           pshs x,b                        ; save registers
+LA1B3           bsr LA199                       ; go do a cursor iteration
+                bsr KEYIN                       ; go read a key
+                beq LA1B3                       ; brif no key pressed
+                ldb #0x60                       ; VDG screen space character
+                stb [CURPOS]                    ; blank cursor out
+LA1BF           puls b,x,pc                     ; restore registers and return
+; This is the actual keyboard polling routine. Returns 0 if no new key is down. Updated compared to 1.0 to reject
+; joystick buttons.
+KEYIN           pshs u,x,b                      ; save registers
+                bsr LA1C8                       ; get keystroke
+                tsta                            ; set flags
+                puls b,x,u,pc                   ; restore registers and return
+LA1C8           ldu #PIA0                       ; point to keyboard PIA
+                ldx #KEYBUF                     ; point to state table
+                clra                            ; clear carry and set column strobe and counter to 0xff
+                deca
+                pshs x,a                        ; save colomn counter and a couple of holes for temporaries
+                sta 2,u                         ; initialize the column strobe to no columns active
+                skip1
+LA1D5           comb                            ; set carry flag
+                rol 2,u                         ; move to nextcolumn
+                bcc LA1BF                       ; brif we've done the last one
+                inc 0,s                         ; bump column count
+                bsr LA239                       ; read keyboard row data
+                sta 1,s                         ; save key data
+                eora ,x                         ; set any bit where a key state changed
+                anda ,x                         ; ignore any where a key was released
+                ldb 1,s                         ; get new key data
+                stb ,x+                         ; save in state table
+                tsta                            ; was a key down?
+                beq LA1D5                       ; brif not - check another
+                ldb 2,u                         ; get column strobe data
+                stb 2,s                         ; save it for later
+                ldb #0xf8                       ; make sure B is 0 after first ADDB
+LA1F1           addb #8                         ; adjust to next row
+                lsra                            ; are we at the right row base?
+                bcc LA1F1                       ; brif not
+                addb 0,s                        ; add in column number
+                beq LA244                       ; brif it was @
+                cmpb #26                        ; letter?
+                bhi LA246                       ; brif not
+                orb #0x40                       ; add in upper case ASCII bias
+                bsr LA22E                       ; check for shift key
+                beq LA20B                       ; brif shift down
+                lda CASFLG                      ; check casplock
+                bne LA20B                       ; brif not caps mode
+                orb #0x20                       ; convert to lower case
+LA20B           stb 0,s                         ; temp store ASCII value
+                ldx DEBVAL                      ; get debounce dely counter
+                jsr LA7D3                       ; wait while we count X down
+                ldb #0xff                       ; set column strobe to no columns
+                bsr LA237                       ; read keyboard data
+                inca                            ; do we have anything reading?
+                bne LA220                       ; brif so - reject keyboard read
+LA21A           ldb 2,s                         ; get saved column strobe
+                bsr LA237                       ; read the keyboard data
+                cmpa 1,s                        ; does it match the result before the delay?
+LA220           puls a                          ; get back return value
+                bne LA22B                       ; brif we have a non-match or joystick button
+                cmpa #0x12                      ; SHIFT-0?
+                bne LA22C                       ; brif not
+                com CASFLG                      ; swap capslock state
+LA22B           clra                            ; set Z and return zero for no key down
+LA22C           puls x,pc                       ; restore registers and return
+LA22E           lda #0x7f                       ; column strobe for SHIFT
+                sta 2,u                         ; strobe keyboard
+                lda ,u                          ; get row data
+                anda #0x40                      ; only keep shift state
+                rts
+LA237           stb 2,u                         ; save requested column strobe
+LA239           lda ,u                          ; read row data
+                ora #0x80                       ; mask joystick comparator input
+                tst 2,u                         ; are we reading column 7?
+                bmi LA243                       ; brif not
+                ora #0xc0                       ; also mask off the SHIFT key
+LA243           rts
+LA244           ldb #51                         ; scan code for @
+LA246           ldx #CONTAB-0x36                ; point to first batch in control code list
+                cmpb #33                        ; arrows, space, zero?
+                blo LA263                       ; brif so
+                ldx #CONTAB-0x54                ; point to second batch in control code list
+                cmpb #48                        ; ENTER, CLEAR, BREAK, @?
+                bhs LA263                       ; brif so
+                bsr LA22E                       ; get shift status
+                cmpb #43                        ; number, colon, semicolon?
+                bls LA25C                       ; brif so
+                eora #0x40                      ; invert shift sense if so
+LA25C           tsta                            ; test shift status
+                beq LA20B                       ; brif shift down - we have the code so check for debounce
+                addb #0x10                      ; add in ASCII offset
+                bra LA20B                       ; check for debounce
+LA263           aslb                            ; two entries for table entry
+                bsr LA22E                       ; get shift status
+                bne LA269                       ; brif not down
+                incb                            ; move to shifted code entry
+LA269           ldb b,x                         ; get ASCII code
+                bra LA20B                       ; go check for debounce
+                fcb 0                           ; unused in Color Basic 1.0
+CONTAB          fcb 0x5e,0x5f                   ; <UP> (^, _)
+                fcb 0x0a,0x5b                   ; <DOWN> (LF, [)
+                fcb 0x08,0x15                   ; <LEFT> (BS, ^U)
+                fcb 0x09,0x5d                   ; <RIGHT> (TAB, ])
+                fcb 0x20,0x20                   ; <SPACE>
+                fcb 0x30,0x12                   ; <0> (0, ^R)
+                fcb 0x0d,0x0d                   ; <ENTER> (CR, CR)
+                fcb 0x0c,0x5c                   ; <CLEAR> (FF, \)
+                fcb 0x03,0x03                   ; <BREAK> (^C, ^C)
+                fcb 0x40,0x13                   ; <@> (@, ^S)
+; Generic output routine.
+; Output character in A to the device specified by DEVNUM. All registers are preserved except CC.
+; Sending output to a device that does not support output is undefined.
+PUTCHR          jsr RVEC3                       ; call RAM hook
+                pshs b                          ; save B
+                ldb DEVNUM                      ; get desired device number
+                incb                            ; set flags (Z for -1, etc.)
+                puls b                          ; restore B
+                bmi LA2BF                       ; brif < -1 (line printer)
+                bne LA30A                       ; brif > -1 (screen)
+; Write character to tape file
+                pshs x,b,a                      ; save registers
+                ldb FILSTA                      ; get file status
+                decb                            ; input file?
+                beq LA2A6                       ; brif so
+                ldb CINCTR                      ; get character count
+                incb                            ; account for this character
+                bne LA29E                       ; brif buffer not full
+                bsr LA2A8                       ; write previously full block to tape
+LA29E           ldx CINPTR                      ; get output buffer pointer
+                sta ,x+                         ; put character in output
+                stx CINPTR                      ; save new buffer pointer
+                inc CINCTR                      ; account for this character
+LA2A6           puls a,b,x,pc                   ; restore registers and return
+; Write a block of data to tape.
+LA2A8           ldb #1                          ; data block type
+LA2AA           stb BLKTYP                      ; set block type
+                ldx #CASBUF                     ; point to output buffer
+                stx CBUFAD                      ; set buffer pointer
+                ldb CINCTR                      ; get number of bytes in the block
+                stb BLKLEN                      ; set length to write
+                pshs u,y,a                      ; save registers
+                jsr LA7E5                       ; write a block to tape
+                puls a,y,u                      ; restore registers
+                jmp LA650                       ; reset buffer pointers
+LA2BF           pshs x,b,a,cc                   ; save registers and interrupt status
+                orcc #0x50                      ; disable interrupts
+                bsr LA2FB                       ; set output to marking
+                clrb                            ; transmit a start bit
+                bsr LA2FD
+                ldb #8                          ; send 8 bits
+LA2CA           pshs b                          ; save bit counter
+                clrb                            ; set output to 
+                lsra                            ; get output bit to C
+                rolb                            ; get it to the correct bit position for output
+                aslb
+                bsr LA2FD                       ; send the bit
+                puls b                          ; get back bit counter
+                decb                            ; sent all 8 bits?
+                bne LA2CA                       ; brif not
+                bsr LA2FB                       ; send stop bit (B is 0)
+                puls cc,a                       ; restore interrupts and output character
+                cmpa #0x0d                      ; carriage return?
+                beq LA2E7                       ; brif so
+                inc LPTPOS                      ; bump printer position
+                ldb LPTPOS                      ; get current printer position
+                cmpb LPTWID                     ; end of line?
+                blo LA2ED                       ; brif not
+LA2E7           clr LPTPOS                      ; reset to start of line
+                bsr LA305                       ; delay for carriage return
+                bsr LA305
+LA2ED           ldb PIA1+2                      ; get rs232 status
+                lsrb                            ; is it "read"?
+                bcs LA2ED                       ; brif not
+                puls b,x,pc                     ; restore registers and return
+                fdb 0,0,0                       ; unused space
+LA2FB           ldb #2                          ; set output to high (marking)
+LA2FD           stb PIA1                        ; set RS232 output
+                bsr LA302                       ; do baud delay (first iteration) then fall through for second
+LA302           ldx LPTBTD                      ; get buard rate delay constant
+                skip2
+LA305           ldx LPTLND                      ; get carriage return delay constant
+                jmp LA7D3                       ; count X down
+; Output character to screen
+LA30A           pshs x,b,a                      ; save registers
+                ldx CURPOS                      ; get cursor pointer
+                cmpa #0x08                      ; backspace?
+                bne LA31D                       ; brif not
+                cmpx #VIDRAM                    ; at top of screen?
+                beq LA35D                       ; brif so - it's a no-op
+                lda #0x60                       ; VDG space character
+                sta ,-x                         ; put a space at previous location and move pointer back
+                bra LA344                       ; save new cursor position and return
+LA31D           cmpa #0x0d                      ; carriage return?
+                bne LA32F                       ; brif not
+                ldx CURPOS                      ; get cursor pointer (why? we already have it)
+LA323           lda #0x60                       ; VDG space character
+                sta ,x+                         ; put output space
+                tfr x,d                         ; see if we at a multiple of 32 now
+                bitb #0x1f
+                bne LA323                       ; brif not
+                bra LA344                       ; go check for scrolling
+LA32F           cmpa #0x20                      ; control character?
+                blo LA35D                       ; brif so
+                tsta                            ; is it graphics block?
+                bmi LA342                       ; brif so
+                cmpa #0x40                      ; number or special?
+                blo LA340                       ; brif so (flip "case" bit)
+                cmpa #0x60                      ; upper case alpha?
+                blo LA342                       ; brif so - keep it unmodified
+                anda #0xdf                      ; clear bit 5 (inverse video)
+LA340           eora #0x40                      ; flip inverse video bit
+LA342           sta ,x+                         ; output character
+LA344           stx CURPOS                      ; save new cursor position
+                cmpx #VIDRAM+511                ; end of screen?
+                bls LA35D                       ; brif not
+                ldx #VIDRAM                     ; point to start of screen
+LA34E           ldd 32,x                        ; get two characters from next row
+                std ,x++                        ; put them on this row
+                cmpx #VIDRAM+0x1e0              ; at start of last row on screen?
+                blo LA34E                       ; brif not
+                ldb #0x60                       ; VDG space
+                jsr LA92D                       ; blank out last line (borrow CLS's loop)
+LA35D           puls a,b,x,pc                   ; restore registers and return
+; Set up device parameters for output
+LA35F           jsr RVEC2                       ; do the RAM hook dance
+                pshs x,b,a                      ; save registers
+                clr PRTDEV                      ; flag device as a screen
+                lda DEVNUM                      ; get devicenumber
+                beq LA373                       ; brif screen
+                inca                            ; is it tape?
+                beq LA384                       ; brif so
+                ldx LPTCFW                      ; get tab width and last tab stop for printer
+                ldd LPTWID                      ; get line width and current position for printer
+                bra LA37C                       ; set parameters
+LA373           ldb CURPOS+1                    ; get LSB of cursor position
+                andb #0x1f                      ; now we have the offset into the line
+                ldx #0x1010                     ; 16 character tab, position 16 is last tab stop
+                lda #32                         ; screen is 32 characters wide
+LA37C           stx DEVCFW                      ; save tab width and last tab stop for active device
+                stb DEVPOS                      ; save line position for current device
+                sta DEVWID                      ; save line width for current device
+                puls a,b,x,pc                   ; restore registers and return
+LA384           com PRTDEV                      ; flag device as non-display
+                ldx #0x0100                     ; tab width is 1, last tab field is 0
+                clra                            ; line width is 0
+                clrb                            ; character position on line is 0
+                bra LA37C                       ; go set parameters
+; This is the line input routine used for reading lines for Basic, both in immediate mode and for
+; INPUT and LINE INPUT. Exit with C set if terminated by BREAK and C clear if terminated by ENTER.
+; The actualy entry point is LA390. Note that this routine echoes to *all* devices.
+LA38D           jsr LA928                       ; clear screen (CLEAR key handling)
+LA390           jsr RVEC12                      ; do the RAM hook dance
+                clr IKEYIM                      ; reset cached input character from BREAK check
+                ldx #LINBUF+1                   ; point to line input buffer (input pointer)
+                ldb #1                          ; Number of characters in line (we start at 1 so BS handling is easier)
+LA39A           jsr LA171                       ; get an input character, only keep low 7 bits
+                tst CINBFL                      ; is it EOF?
+                bne LA3CC                       ; brif EOF
+                tst DEVNUM                      ; is it keyboard input?
+                bne LA3C8                       ; brif not - don't do line editing
+                cmpa #0x0c                      ; form feed (CLEAR)?
+                beq LA38D                       ; brif so - clear screen and reset
+                cmpa #0x08                      ; backspace?
+                bne LA3B4                       ; brif not
+                decb                            ; move back one character
+                beq LA390                       ; brif we were at the start of the line - reset and start again
+                leax -1,x                       ; move input pointer back
+                bra LA3E8                       ; echo the backspace and continue
+LA3B4           cmpa #0x15                      ; SHIFT-LEFT (kill line)?
+                bne LA3C2                       ; brif not
+LA3B8           decb                            ; at start of line?
+                beq LA390                       ; brif so - reset and restart
+                lda #0x08                       ; echo a backspace
+                jsr PUTCHR
+                bra LA3B8                       ; see if we've erased everything yet
+LA3C2           cmpa #0x03                      ; BREAK?
+                orcc #1                         ; set C if it is (only need Z for the next test
+                beq LA3CD                       ; brif BREAK - exit
+LA3C8           cmpa #0x0d                      ; ENTER (CR)
+                bne LA3D9                       ; brif not
+LA3CC           clra                            ; clear carry (it might not be clear on EOF)
+LA3CD           pshs cc                         ; save ENTER/BREAK flag
+                jsr LB958                       ; echo a carriage return
+                clr ,x                          ; make sure we have a NUL at the end of the buffer
+                ldx #LINBUF                     ; point to input buffer
+                puls cc,pc                      ; restore ENTER/BREAK flag and return
+LA3D9           cmpa #0x20                      ; control character?
+                blo LA39A                       ; brif so - skip it
+                cmpa #'z+1                      ; above z?
+                bhs LA39A                       ; brif so - ignore it
+                cmpb #LBUFMX                    ; is the buffer full?
+                bhs LA39A                       ; brif so - ignore extra characters
+                sta ,x+                         ; put character in the buffer
+                incb                            ; bump character count
+LA3E8           jsr PUTCHR                      ; echo character
+                bra LA39A                       ; go handle next input character
+; Check if DEVNUM Is valid for reading. Raise FM error if open but not for reading. NO error if not open.
+LA3ED           jsr RVEC5                       ; do the RAM hook dance
+                lda DEVNUM                      ; get device number
+                beq LA415                       ; brif keyboard - always valid
+                inca                            ; is it tape?
+                bne LA403                       ; brif not
+                lda FILSTA                      ; get tape file status
+                bne LA400                       ; brif file is open
+LA3FB           ldb #22*2                       ; raise NO error
+                jmp LAC46
+LA400           deca                            ; is it in input mode?
+                beq LA415                       ; brif so
+LA403           jmp LA616                       ; raise FM error
+; Check if DEVNUM is valid for writing. Raise FM error if open but not for writing. NO error if not open.
+LA406           jsr RVEC6                       ; do the RAM hook dance
+                lda DEVNUM                      ; get device number
+                inca                            ; is it tape?
+                bne LA415                       ; brif not
+                lda FILSTA                      ; get file status
+                beq LA3FB                       ; brif not open
+                deca                            ; is it open for reading?
+                beq LA403                       ; brif so - bad mode
+LA415           rts
+; CLOSE command
+CLOSE           beq LA426                       ; brif no file specified - close all files
+                jsr LA5A5                       ; parse device number
+LA41B           bsr LA42D                       ; close specified file
+                jsr GETCCH                      ; is there more?
+                beq LA44B                       ; brif not
+                jsr LA5A2                       ; check for comma and parse another device number
+                bra LA41B                       ; go close this one
+; Close all files handler.
+LA426           jsr RVEC7                       ; Yup. The RAM hook dance.
+                lda #-1                         ; start with tape file
+                sta DEVNUM
+; Close file specified in DEVNUM. Note that this never fails.
+LA42D           jsr RVEC8                       ; You know it. RAM hook.
+                lda DEVNUM                      ; get device we're closing
+                clr DEVNUM                      ; reset to screen/keyboard
+                inca                            ; is it tape?
+                bne LA44B                       ; brif not
+                lda FILSTA                      ; get file status
+                cmpa #2                         ; is it output?
+                bne LA449                       ; brif not
+                lda CINCTR                      ; is there anything waiting to be written?
+                beq LA444                       ; brif not
+                jsr LA2A8                       ; write final block of data
+LA444           ldb #0xff                       ; write EOF block
+                jsr LA2AA
+LA449           clr FILSTA                      ; mark tape file closed
+LA44B           rts
+; CSAVE command
+CSAVE           jsr LA578                       ; parse filename
+                jsr GETCCH                      ; see what we have after the file name
+                beq LA469                       ; brif none
+                jsr LB26D                       ; make sure there's a comma
+                ldb #'A                         ; make sure there's an A after
+                jsr LB26F
+                bne LA44B                       ; brif not end of line
+                clra                            ; file type 0 (basic program)
+                jsr LA65C                       ; write out header block
+                lda #-1                         ; set output to tape
+                sta DEVNUM
+                clra                            ; set Z so we list the whole program
+                jmp LIST                        ; go list the program to tape
+LA469           clra                            ; file type 0 (basic program)
+                ldx ZERO                        ; set to binary file mode
+                jsr LA65F                       ; write header block
+                clr FILSTA                      ; close files
+                inc BLKTYP                      ; set block type to data
+                jsr WRLDR                       ; write out a leader
+                ldx TXTTAB                      ; point to start of program
+LA478           stx CBUFAD                      ; set buffer location
+                lda #255                        ; block size to 255 bytes (max size)
+                sta BLKLEN
+                ldd VARTAB                      ; get end of program
+                subd CBUFAD                     ; how much is left?
+                beq LA491                       ; brif we have nothing left
+                cmpd #255                       ; do we have a full block worth?
+                bhs LA48C                       ; brif so
+                stb BLKLEN                      ; save actual remainder as block length
+LA48C           jsr SNDBLK                      ; write a block out
+                bra LA478                       ; go do another block
+LA491           neg BLKTYP                      ; set block type to 0xff (EOF)
+                clr BLKLEN                      ; no data in EOF block
+                jmp LA7E7                       ; write EOF, stop tape, and return
+; CLOAD and CLOADM commands
+CLOAD           clr FILSTA                      ; close tape file
+                cmpa #'M                        ; is it ClOADM?
+                beq LA4FE                       ; brif so
+                leas 2,s                        ; clean up stack
+                jsr LA5C5                       ; parse file name
+                jsr LA648                       ; go find the file
+                tst CASBUF+10                   ; is it binary?
+                beq LA4C8                       ; brif so
+                lda CASBUF+9                    ; is it ASCII?
+                beq LA4CD                       ; brif not
+                jsr LAD19                       ; clear out existing program
+                lda #-1                         ; set up for reading from tape
+                sta DEVNUM
+                inc FILSTA                      ; set tape file to input
+                jsr LA635                       ; go read first block
+                jmp LAC7C                       ; go to immediate mode to read in the program
+; This is the EOF handler for immediate mode. It's rather assinine for this to be located here. It is
+; probably an artifact of a substantially different code layout prior to compacting the ROM to fit in
+; 8K.
+LA4BF           jsr RVEC13                      ; do the RAM hook dance
+                jsr LA42D                       ; close file
+                jmp LAC73                       ; go back to immediate mode
+LA4C8           lda CASBUF+8                    ; get file type
+                beq LA4D0                       ; brif basic program
+LA4CD           jmp LA616                       ; raise FM error
+LA4D0           jsr LAD19                       ; erase existing program
+                jsr CASON                       ; start reading tape
+                ldx TXTTAB                      ; get start of program storage
+LA4D8           stx CBUFAD                      ; set load address for block
+                ldd CBUFAD                      ; get start of block
+                inca                            ; bump by 256
+                jsr LAC37                       ; check if there's room for a maximum sized block of 255
+                jsr GETBLK                      ; go read a block
+                bne LA4F8                       ; brif there was an error during reading
+                lda BLKTYP                      ; get type of block read
+                beq LA4F8                       ; brif header block - IO error
+                bpl LA4D8                       ; brif data block - read another
+                stx VARTAB                      ; save new end of program
+                bsr LA53B                       ; stop tape
+                ldx #LABED-1                    ; point to "OK" prompt
+                jsr LB99C                       ; show prompt
+                jmp LACE9                       ; reset various things and return
+LA4F8           jsr LAD19                       ; clear out partial program load
+LA4FB           jmp LA619                       ; raise IO error
+; This is the CLOADM command
+LA4FE           jsr GETNCH                      ; eat the "M"
+                bsr LA578                       ; parse file name
+                jsr LA648                       ; go find the file
+LA505           ldx ZERO                        ; default offset is 0
+                jsr GETCCH                      ; see if there's something after the file name
+                beq LA511                       ; brif no offset
+                jsr LB26D                       ; make sure there's a comma
+                jsr LB73D                       ; evaluate offset to X
+LA511           lda CASBUF+8                    ; get file mode
+                cmpa #2                         ; M/L program?
+                bne LA4CD                       ; brif not - FM error
+                ldd CASBUF+11                   ; get load address
+                leau D,x                        ; add in offset
+                stu EXECJP                      ; set EXEC default address
+                tst CASBUF+10                   ; is it binary?
+                bne LA4CD                       ; brif not
+                ldd CASBUF+13                   ; get load address
+                leax d,x                        ; add in offset
+                stx CBUFAD                      ; set buffer address for loading
+                jsr CASON                       ; start up tape
+LA52E           jsr GETBLK                      ; read a block
+                bne LA4FB                       ; brif error reading
+                stx CBUFAD                      ; save new load address
+                tst BLKTYP                      ; set flags on block type
+                beq LA4FB                       ; brif another header - IO error
+                bpl LA52E                       ; brif it was data - read more
+LA53B           jmp LA7E9                       ; turn off tape and return
+; The EXEC command
+EXEC            beq LA545                       ; brif no argument - use default address
+                jsr LB73D                       ; evaluate EXEC address to X
+                stx EXECJP                      ; set new default EXEC address
+LA545           jmp [EXECJP]                    ; transfer control to execution address
+; Break check for LIST so it doesn't interrupt ASCII saves. Why is this here instead of with the rest of the break
+; check logic or packaged up with LIST?
+LA549           jsr RVEC11                      ; do the RAM hook dance
+                lda DEVNUM                      ; get device number
+                inca                            ; is it tape?
+                beq LA5A1                       ; brif so - don't do break check
+                jmp LADEB                       ; do the actual break check
+; Evaluate an expression and make sure it is within the limits of the screen and sets the cursor position.
+; This really should be located with the PRINT command.
+LA554           jsr LB3E4                       ; evaluate a positive expression to D
+                subd #511                       ; is it within bounds?
+                lbhi LB44A                      ; brif not - error out
+                addd #VIDRAM+511                ; adjust to be within the screen (and undo the SUBD above)
+                std CURPOS                      ; set cursor position
+                rts
+; INKEY$ function
+INKEY           lda IKEYIM                      ; was a key down during break check?
+                bne LA56B                       ; brif so
+                jsr KEYIN                       ; poll the keyboard
+LA56B           clr IKEYIM                      ; reset the break check cache
+                sta FPA0+3                      ; store result for later return
+                lbne LB68F                      ; brif a key was down - return it as a string
+                sta STRDES                      ; set string length to 0 (no key down)
+                jmp LB69B                       ; return the NULL string
+; Parse a filename
+LA578           ldx #CFNBUF                     ; point to file name buffer
+                clr ,x+                         ; zero out file name length
+                lda #0x20                       ; space character to initialize file name
+LA57F           sta ,x+                         ; put a space in the buffer
+                cmpx #CASBUF                    ; at end of file name?
+                bne LA57F                       ; brif not
+                jsr GETCCH                      ; get input character
+                beq LA5A1                       ; brif no name present
+                jsr LB156                       ; evaluate the file name expression
+                jsr LB654                       ; point to start of the file name
+                ldu #CFNBUF                     ; point to file name buffer
+                stb ,u+                         ; save string length
+                beq LA5A1                       ; brif empty - we're done
+                skip2
+LA598           ldb #8                          ; copy 8 bytes
+; Move B bytes from (X) to (U)
+LA59A           lda ,x+                         ; copy a byte
+                sta ,u+
+                decb                            ; done yet?
+                bne LA59A                       ; brif not
+LA5A1           rts
+; Parse a device number and check validity
+LA5A2           jsr LB26D                       ; check for comma and SN error if not
+LA5A5           cmpa #'#                        ; do we have a #?
+                bne LA5AB                       ; brif not (it's optional)
+                jsr GETNCH                      ; munch the #
+LA5AB           jsr LB141                       ; evaluate the expression
+LA5AE           jsr INTCNV                      ; convert it to an integer in D
+                rolb                            ; move sign of B into C
+                adca #0                         ; add sign of B to A
+                bne LA61F                       ; brif A doesn't match the sign of B
+                rorb                            ; restore B (ADCA will have set C if B was negative)
+                stb DEVNUM                      ; set device number
+                jsr RVEC1                       ; do the RAM hook dance
+                beq LA5C4                       ; brif device number set to screen/keyboard (valid)
+                bpl LA61F                       ; brif not negative (not valid)
+                cmpb #-2                        ; is it printer or tape?
+                blt LA61F                       ; brif not (not valid)
+LA5C4           rts
+; Read file name from the line and do an error if anything follows it
+LA5C5           bsr LA578                       ; parse file name
+                jsr GETCCH                      ; set flags on current character
+LA5C9           beq LA5C4                       ; brif nothing there - it's good
+                jmp LB277                       ; raise SN error
+; EOF functoin
+EOF             jsr RVEC14                      ; do the RAM hook dance
+                lda DEVNUM                      ; get device number
+                pshs a                          ; save it (so we can restore it later)
+                bsr LA5AE                       ; check the device number (which is in FPA0)
+                jsr LA3ED                       ; check validity for reading
+LA5DA           clrb                            ; not EOF = 0 (FALSE)
+                lda DEVNUM                      ; get device number
+                beq LA5E4                       ; brif keyboard - never EOF
+                tst CINCTR                      ; is there anything in the input buffer?
+                bne LA5E4                       ; brif so - not EOF
+                comb                            ; set EOF flag to -1 (true)
+LA5E4           puls a                          ; get back original device
+                sta DEVNUM                      ; restore it
+LA5E8           sex                             ; sign extend result to 16 bits
+                jmp GIVABF                      ; go return the result
+; SKIPF command
+SKIPF           bsr LA5C5                       ; parse file name
+                bsr LA648                       ; look for the file
+                jsr LA6D1                       ; read the file
+                bne LA619                       ; brif error reading file
+                rts
+; OPEN command
+OPEN            jsr RVEC0                       ; do the RAM hook dance
+                jsr LB156                       ; get file status (input/output)
+                jsr LB6A4                       ; get first character of status string
+                pshs b                          ; save status
+                bsr LA5A2                       ; parse a comma then the device number
+                jsr LB26D                       ; make sure there's a comma
+                bsr LA5C5                       ; parse the file name
+                lda DEVNUM                      ; get device number of the file
+                clr DEVNUM                      ; reset actual device to the screen
+                puls b                          ; get back status
+                cmpb #'I                        ; INPUT?
+                beq LA624                       ; brif so - open a file for INPUT
+                cmpb #'O                        ; OUTPUT?
+                beq LA658                       ; brif so - open a file for OUTPUT
+LA616           ldb #21*2                       ; raise FM error
+                skip2
+LA619           ldb #20*2                       ; raise I/O error
+                skip2
+LA61C           ldb #18*2                       ; raise AO error
+                skip2
+LA61F           ldb #19*2                       ; raise DN error
+                jmp LAC46
+LA624           inca                            ; are we opening the tape?
+                bmi LA616                       ; brif printer - FM error; printer can't be opened for READ
+                bne LA657                       ; brif screen - screen is always open
+                bsr LA648                       ; read header block
+                lda CASBUF+9                    ; clear A if binary or machine language file
+                anda CASBUF+10
+                beq LA616                       ; bad file mode if not data file
+                inc FILSTA                      ; open file for input
+LA635           jsr LA701                       ; start tape, read block           
+                bne LA619                       ; brif error during read
+                tst BLKTYP                      ; check block type
+                beq LA619                       ; brif header block - something's wrong
+                bmi LA657                       ; brif EOF
+                lda BLKLEN                      ; get length of block
+                beq LA635                       ; brif empty block - read another
+LA644           sta CINCTR                      ; set buffer count
+                bra LA652                       ; reset buffer pointer
+LA648           tst FILSTA                      ; is the file open?
+                bne LA61C                       ; brif so - AO error
+                bsr LA681                       ; search for file
+                bne LA619                       ; brif error on read
+LA650           clr CINCTR                      ; mark buffer empty
+LA652           ldx #CASBUF                     ; set buffer pointer to start of buffer
+                stx CINPTR
+LA657           rts
+LA658           inca                            ; check for tape device
+                bne LA657                       ; brif not tape (nothing doing - it's always open)
+                inca                            ; make file type 1
+LA65C           ldx #0xffff                     ; ASCII and data mode
+LA65F           tst FILSTA                      ; is file open?
+                bne LA61C                       ; brif so - raise error
+                ldu #CASBUF                     ; point to tape buffer
+                stu CBUFAD                      ; set address of block to write
+                sta 8,u                         ; set file type
+                stx 9,u                         ; set ASCII flag and mode
+                ldx #CFNBUF+1                   ; point to file name
+                jsr LA598                       ; move file name to the tape buffer
+                clr BLKTYP                      ; set for header block
+                lda #15                         ; 15 bytes in a header block
+                sta BLKLEN                      ; set block length
+                jsr LA7E5                       ; write the block
+                lda #2                          ; set file type to output
+                sta FILSTA
+                bra LA650                       ; reset file pointers
+; Search for correct cassette file name
+LA681           ldx #CASBUF                     ; point to cassette buffer
+                stx CBUFAD                      ; set location to read blocks to
+LA686           lda CURLIN                      ; are we in immediate mode?
+                inca
+                bne LA696                       ; brif not
+                jsr LA928                       ; clear screen
+                ldx CURPOS                      ; get start of screen (set after clear)
+                ldb #'S                         ; for "searching"
+                stb ,x++                        ; put it on the screen
+                stx CURPOS                      ; save cursor position to be one past the search indicator
+LA696           bsr LA701                       ; read a block
+                orb BLKTYP                      ; merge error flag with block type
+                bne LA6D0                       ; brif error or not header
+                ldx #CASBUF                     ; point to block just read
+                ldu #CFNBUF+1                   ; point to the desired name
+                ldb #8                          ; compare 8 characters
+                clr ,-s                         ; set flag to "match"
+LA6A6           lda ,x+                         ; get character from just read block
+                ldy CURLIN                      ; immediate mode?
+                leay 1,y
+                bne LA6B4                       ; brif not
+                clr DEVNUM                      ; set output to screen
+                jsr PUTCHR                      ; display character
+LA6B4           suba ,u+                        ; subtract from desired file name (nonzero if no match)
+                ora ,s                          ; merge with match flag
+                sta ,s                          ; save new match flag (will be nonzero if any character differs)
+                decb                            ; done all characters?
+                bne LA6A6                       ; brif not - do another
+                lda ,s+                         ; get match flag (and set flags)
+                beq LA6CB                       ; brif we have a match
+                tst -9,u                        ; did we actually have a file name or will any file do?
+                beq LA6CB                       ; brif any file will do
+                bsr LA6D1                       ; go read past the file
+                bne LA6D0                       ; return on error
+                bra LA686                       ; keep looking
+LA6CB           lda #'F                         ; for "found"
+                bsr LA6F8                       ; put "F" on screen
+                clra                            ; set Z to indicat eno errors
+LA6D0           rts
+LA6D1           tst CASBUF+10                   ; check type of file
+                bne LA6DF                       ; brif "blocked" file
+                jsr CASON                       ; turn on tape
+LA6D9           bsr GETBLK                      ; read a block
+                bsr LA6E5                       ; error or EOF?
+                bra LA6D9                       ; read another block
+LA6DF           bsr LA701                       ; read a single block
+                bsr LA6E5                       ; error or EOF?
+                bra LA6DF                       ; read another block
+LA6E5           bne LA6ED                       ; got error reading block
+                lda BLKTYP                      ; check block type
+                nega                            ; A is 0 now if EOF
+                bmi LA700                       ; brif not end of file
+                deca                            ; clear error indicator
+LA6ED           sta CSRERR                      ; set error flag
+                leas 2,s                        ; don't return to original caller
+                bra LA705                       ; turn off motor and return
+LA6F3           lda VIDRAM                      ; get first char on screen
+                eora #0x40                      ; flip case
+LA6F8           ldb CURLIN                      ; immediate mode?
+                incb
+                bne LA700                       ; brif not
+                sta VIDRAM                      ; save flipped case character
+LA700           rts
+; Read a single block from tape (for a "blocked" file)
+LA701           bsr CASON                       ; start tape going
+                bsr GETBLK                      ; read block
+LA705           jsr LA7E9                       ; stop tape
+                ldb CSRERR                      ; get error status
+                rts
+; Read a block from tape - this does the heavy lifting
+GETBLK          orcc #0x50                      ; disable interrupts (timing is important)
+                bsr LA6F3                       ; reverse video of upper left character in direct mode
+                ldx CBUFAD                      ; point to destination buffer
+                clra                            ; reset read byte
+LA712           bsr LA755                       ; read a bit
+                rora                            ; move bit into accumulator
+                cmpa #0x3c                      ; have we synched on the start of the block data yet?
+                bne LA712                       ; brif not
+                bsr LA749                       ; read block type
+                sta BLKTYP
+                bsr LA749                       ; get block size
+                sta BLKLEN
+                adda BLKTYP                     ; accumulate checksum
+                sta CCKSUM                      ; save current checksum
+                lda BLKLEN                      ; get back count
+                sta CSRERR                      ; initialize counter; we use this since it will be ovewritten later anyway
+                beq LA73B                       ; brif empty block
+LA72B           bsr LA749                       ; read a byte
+                sta ,x                          ; save in buffer
+                cmpa ,x+                        ; make sure it wrote
+                bne LA744                       ; brif error if it didn't match
+                adda CCKSUM                     ; accumulate checksum
+                sta CCKSUM
+                dec CSRERR                      ; read all bytes?
+                bne LA72B                       ; brif not
+LA73B           bsr LA749                       ; read checksum from tape
+                suba CCKSUM                     ; does it match?
+                beq LA746                       ; brif so
+                lda #1                          ; checksum error flag
+                skip2
+LA744           lda #2                          ; non-RAM error flag
+LA746           sta CSRERR                      ; save error status
+                rts
+LA749           lda #8                          ; read 8 bits
+                sta CPULWD                      ; initialize counter
+LA74D           bsr LA755                       ; read a bit
+                rora                            ; put it into accumulator
+                dec CPULWD                      ; got all 8 bits?
+                bne LA74D                       ; brif not
+                rts
+LA755           bsr LA75D                       ; get time between transitions
+                ldb CPERTM                      ; get timer
+                decb
+                cmpb CMPMID                     ; set C if timer is below the transition point - high or 1; clear otherwise
+                rts
+LA75D           clr CPERTM                      ; reset timer
+                tst CBTPHA                      ; check which phase we synched on
+                bne LA773                       ; brif HI-LO synch
+LA763           bsr LA76C                       ; read input
+                bcs LA763                       ; brif still high
+LA767           bsr LA76C                       ; read input
+                bcc LA767                       ; brif still low
+                rts
+LA76C           inc CPERTM                      ; bump timer
+                ldb PIA1                        ; get input bit to C
+                rorb
+                rts
+LA773           bsr LA76C                       ; read input
+                bcc LA773                       ; brif still low
+LA777           bsr LA76C                       ; read output
+                bcs LA777                       ; brif still high
+                rts
+; Start tape and look for sync bytes
+CASON           orcc #0x50                      ; disable interrupts
+                bsr LA7CA                       ; turn on tape
+                clr CPULWD                      ; reset timer
+LA782           bsr LA763                       ; wait for low-high transition
+LA784           bsr LA7AD                       ; wait for it to go low again
+                bhi LA797                       ; brif in range for 1200 Hz
+LA788           bsr LA7A7                       ; wait for it to go high again
+                blo LA79B                       ; brif in range for 2400 Hz
+                dec CPULWD                      ; decrement counter (synched on low-high)
+                lda CPULWD                      ; get counter
+                cmpa #-96                       ; have we seen 96 1-0-1-0 patterns (48 0x55s)?
+LA792           bne LA782                       ; brif not - wait some more
+                sta CBTPHA                      ; save phase we synched on
+                rts
+LA797           bsr LA7A7                       ; wait for it to go high again
+                bhi LA784                       ; brif another 1200 Hz, 2 in a row, try again
+LA79B           bsr LA7AD                       ; wait for it to go low again
+                blo LA788                       ; brif another 2400 Hz; go try again for high
+                inc CPULWD                      ; bump counter
+                lda CPULWD                      ; get counter
+                suba #96                        ; set 0 if we've seen enought 0-1-0-1 patterns (0xaa)
+                bra LA792                       ; set phase and return or keep waiting
+LA7A7           clr CPERTM                      ; reset period timer
+                bsr LA767                       ; wait for high
+                bra LA7B1                       ; set flags on result
+LA7AD           clr CPERTM                      ; reset period timer
+                bsr LA777                       ; wait for low
+LA7B1           ldb CPERTM                      ; get period count
+                cmpb CMP0                       ; is it too long for 1200Hz?
+                bhi LA7BA                       ; brif so - reset counts
+                cmpb CMP1                       ; set C if 2400Hz, clear C if 1200 Hz
+                rts
+LA7BA           clr CPULWD                      ; reset sync counter (too slow or drop out)
+                rts
+; MOTOR command
+MOTOR           tfr a,b                         ; save ON/OFF
+                jsr GETNCH                      ; eat the ON/OFF token
+                cmpb #0xaa                      ; OFF?
+                beq LA7E9                       ; brif so - turn off tape
+                cmpb #0x88                      ; ON?
+                jsr LA5C9                       ; SN error if no match
+; Turn on tape
+LA7CA           lda PIA1+1                      ; get motor control value
+                ora #8                          ; turn on bit 3 (starts motor)
+                bsr LA7F0                       ; put it back (dumb but it saves a byte)
+LA7D1           ldx ZERO                        ; maximum delay timer
+LA7D3           leax -1,x                       ; count down
+                bne LA7D3                       ; brif not at 0 yet
+                rts
+; Write a synch leader to tape
+WRLDR           orcc #0x50                      ; disable interrupts
+                bsr LA7CA                       ; turn on tape
+                ldx SYNCLN                      ; get count of 0x55s to write
+LA7DE           bsr LA828                       ; write a 0x55
+                leax -1,x                       ; done?
+                bne LA7DE                       ; brif not
+                rts
+; Write sync bytes and a block, then stop tape
+LA7E5           bsr WRLDR                       ; write sync
+LA7E7           bsr SNDBLK                      ; write block
+; Turn off tape
+LA7E9           andcc #0xaf                     ; enable interrupts
+                lda PIA1+1                      ; get control register
+                anda #0xf7                      ; disable motor bit
+LA7F0           sta PIA1+1                      ; set motor enable bit
+                rts
+; Write a block to tape.
+SNDBLK          orcc #0x50                      ; disable interrupts
+                ldb BLKLEN                      ; get block size
+                stb CSRERR                      ; initialize character counter
+                lda BLKLEN                      ; initialize checksum
+                beq LA805                       ; brif empty block
+                ldx CBUFAD                      ; point to tape buffer
+LA800           adda ,x+                        ; accumulate checksum
+                decb                            ; end of block data?
+                bne LA800                       ; brif not
+LA805           adda BLKTYP                     ; accumulate block type into checksum
+                sta CCKSUM                      ; save calculated checksum
+                ldx CBUFAD                      ; point to buffer
+                bsr LA828                       ; send a 0x55
+                lda #0x3c                       ; and then a 0x3c
+                bsr LA82A
+                lda BLKTYP                      ; send block type
+                bsr LA82A
+                lda BLKLEN                      ; send block size
+                bsr LA82A
+                tsta                            ; empty block?
+                beq LA824                       ; brif so
+LA81C           lda ,x+                         ; send character from block data
+                bsr LA82A
+                dec CSRERR                      ; are we done yet?
+                bne LA81C                       ; brif not
+LA824           lda CCKSUM                      ; send checksum
+                bsr LA82A
+LA828           lda #0x55                       ; send a 0x55
+LA82A           pshs a                          ; save output byte
+                ldb #1                          ; initialize bit probe
+LA82E           lda CLSTSN                      ; get ending value of last cycle
+                sta PIA1                        ; set DA
+                ldy #LA85C                      ; point to sine wave table
+                bitb ,s                         ; is bit set?
+                bne LA848                       ; brif so - do high frequency
+LA83B           lda ,y+                         ; get next sample (use all for low frequency)
+                cmpy #LA85C+36                  ; end of table?
+                beq LA855                       ; brif so
+                sta PIA1                        ; set output sample
+                bra LA83B                       ; do another sample
+LA848           lda ,y++                        ; get next sample (use every other for high frequency)
+                cmpy #LA85C+36                  ; end of table?
+                beq LA855                       ; brif so
+                sta PIA1                        ; send output sample
+                bra LA848                       ; do another sample
+LA855           sta CLSTSN                      ; save last sample that *would* have been sent
+                lslb                            ; shift mask to next bit
+                bcc LA82E                       ; brif not done all 8 bits
+                puls a,pc                       ; get back original character and return
+; This is the sample table for the tape sine wave
+LA85C           fcb 0x82,0x92,0xaa,0xba,0xca,0xda
+                fcb 0xea,0xf2,0xfa,0xfa,0xfa,0xf2
+                fcb 0xea,0xda,0xca,0xba,0xaa,0x92
+                fcb 0x7a,0x6a,0x52,0x42,0x32,0x22
+                fcb 0x12,0x0a,0x02,0x02,0x02,0x0a
+                fcb 0x12,0x22,0x32,0x42,0x52,0x6a
+; SET command
+SET             bsr LA8C1                       ; get absolute screen position of graphics block
+                pshs x                          ; save character location
+                jsr LB738                       ; evaluate comma then expression in B
+                puls x                          ; get back character pointer
+                cmpb #8                         ; valid colour?
+                bhi LA8D5                       ; brif not
+                decb                            ; normalize colours
+                bmi LA895                       ; brif colour 0 (use current colour)
+                lda #0x10                       ; 16 patterns per colour
+                mul
+                bra LA89D                       ; go save the colour
+LA895           ldb ,x                          ; get current value
+                bpl LA89C                       ; brif not grahpic
+                andb #0x70                      ; keep only the colour
+                skip1
+LA89C           clrb                            ; reset block to all black
+LA89D           pshs b                          ; save colour
+                bsr LA90D                       ; force a )
+                lda ,x                          ; get current screen value
+                bmi LA8A6                       ; brif graphic block already
+                clra                            ; force all pixels off
+LA8A6           anda #0x0f                      ; keep only pixel data
+                ora GRBLOK                      ; set the desired pixel
+                ora ,s+                         ; merge with desired colour
+LA8AC           ora #0x80                       ; force it to be a graphic block
+                sta ,x                          ; put new block on screen
+                rts
+; RESET command
+RESET           bsr LA8C1                       ; get address of desired block
+                bsr LA90D                       ; force a )
+                clra                            ; zero block (no pixels)
+                ldb ,x                          ; is it graphics?
+                bpl LA8AC                       ; brif not - just blank the block
+                com GRBLOK                      ; invert pixel data
+                andb GRBLOK                     ; turn off the desired pixel
+                stb ,x                          ; put new pixel data on screen
+                rts
+; Parse SET/RESET/POINT coordinates except for closing )
+LA8C1           jsr LB26A                       ; make sure it starts with (
+LA8C4           jsr RVEC21                      ; do the RAM hook dance
+                jsr LB70B                       ; get first coordinate
+                cmpb #63                        ; valid horizontal coordinate
+                bhi LA8D5                       ; brif out of range
+                pshs b                          ; save horizontal coordinate
+                jsr LB738                       ; look for , followed by vertical coordinate
+                cmpb #31                        ; in range for vertical?
+LA8D5           bhi LA948                       ; brif not
+                pshs b                          ; save vertical coordinate
+                lsrb                            ; divide by two (two blocks per row)
+                lda #32                         ; 32 bytes per row
+                mul                             ; now we have the offset into video RAM
+                ldx #VIDRAM                     ; point to start of screen
+                leax d,x                        ; now X points to the correct character row
+                ldb 1,s                         ; get horizontal coordinate
+                lsrb                            ; divide by two (two per character cell)
+                abx                             ; now we're pointing to the correct character cell
+                puls a,b                        ; get back coordinates (vertical in A)
+                anda #1                         ; keep only row offset of vertical
+                rorb                            ; get column offset of horizontal to C
+                rola                            ; now we have "row * 2 + col" in A
+                ldb #0x10                       ; make a bit mask (one bit left of first pixel)
+LA8EE           lsrb                            ; move mask right
+                deca                            ; at the right pixel?
+                bpl LA8EE                       ; brif not
+                stb GRBLOK                      ; save graphics block mask
+                rts
+; POINT function
+POINT           bsr LA8C4                       ; evaluate coordinates
+                ldb #0xff                       ; default colour value is -1 (not graphics)
+                lda ,x                          ; get character
+                bpl LA90A                       ; brif not graphics
+                anda GRBLOK                     ; is desired pixel set?
+                beq LA909                       ; brif not - return 0 for "black"
+                ldb ,x                          ; get graphics data
+                lsrb                            ; shift right 4 to get colour in low bits
+                lsrb
+                lsrb
+                lsrb
+                andb #7                         ; lose the graphics block bias
+LA909           incb                            ; shift colours into 1 to 8 range
+LA90A           jsr LA5E8                       ; convert B to floating point
+LA90D           jmp LB267                       ; make sure we have a ) and return
+; CLS command
+CLS             jsr RVEC22                      ; do the RAM hook dance
+LA913           beq LA928                       ; brif no colour - just do a basic screen clear
+                jsr LB70B                       ; evaluate colour number
+                cmpb #8                         ; valid colour?
+                bhi LA937                       ; brif not - do the easter egg
+                tstb                            ; color 0?
+                beq LA925                       ; brif so
+                decb                            ; normalize to 0 based colour numbers
+                lda #0x10                       ; 16 blocks per colour
+                mul                             ; now we have the base code for that colour
+                orb #0x0f                       ; set all pixels
+LA925           orb #0x80                       ; make it a graphics block
+                skip2
+LA928           ldb #0x60                       ; VDG screen space character
+                ldx #VIDRAM                     ; point to start of screen
+LA92D           stx CURPOS                      ; set cursor position
+LA92F           stb ,x+                         ; blank a character
+                cmpx #VIDRAM+511                ; end of screen?
+                bls LA92F                       ; brif not
+                rts
+LA937           bsr LA928                       ; clear te screen
+                ldx #LA166-1                    ; point to the easter egg
+                jmp LB99C                       ; go display it
+; Evaluate an expression to B, prefixed by a comma, and do FC error if 0
+LA93F           jsr LB26D                       ; force a comma
+LA942           jsr LB70B                       ; evaluate expression to B
+                tstb                            ; is it 0?
+                bne LA984                       ; brif not - return
+LA948           jmp LB44A                       ; raise FC error
+; SOUND command
+SOUND           bsr LA942                       ; evaluate frequency
+                stb SNDTON                      ; save it
+                bsr LA93F                       ; evaluate duration (after a comma)
+LA951           lda #4                          ; constant factor for duration (each increment is 1/15 of a second)
+                mul
+                std SNDDUR                      ; save length of sound (IRQ will count it down)
+                lda PIA0+3                      ; enable 60 Hz interrupt
+                ora #1
+                sta PIA0+3
+                clr ARYDIS                      ; clear array disable flag for some reason
+                bsr LA9A2                       ; connect DAC to MUX output
+                bsr LA976                       ; turn on sound
+LA964           bsr LA985                       ; store mid range output value and delay
+                lda #0xfe                       ; store high value and delay
+                bsr LA987
+                bsr LA985                       ; store mid range value and delay
+                lda #2                          ; store low value and delay
+                bsr LA987
+                ldx SNDDUR                      ; has timer expired?
+                bne LA964                       ; brif not, do another wave
+; Disable sound output
+LA974           clra                            ; bit 3 to 0 will disable output
+                skip2
+; Enable sound output
+LA976           lda #8                          ; bit 3 set to enable output
+                sta ,-s                         ; save desired value
+                lda PIA1+3                      ; get control register value
+                anda #0xf7                      ; reset value
+                ora ,s+                         ; set to desired value
+                sta PIA1+3                      ; set new sound output status
+LA984           rts
+LA985           lda #0x7e                       ; mid range value for DAC
+LA987           sta PIA1                        ; set DAC output value
+                lda SNDTON                      ; get frequency
+LA98C           inca                            ; increment it (gives shorter count with higher values, so higher frequencies work)
+                bne LA98C                       ; brif not done yet
+                rts
+; AUDIO command
+AUDIO           tfr a,b                         ; save ON/OFF token
+                jsr GETNCH                      ; munch the ON/OFF token
+                cmpb #0xaa                      ; OFF?
+                beq LA974                       ; brif so
+                subb #0x88                      ; ON?
+                jsr LA5C9                       ; do SN error if not
+                incb                            ; now B is 1 - cassette sound source
+                bsr LA9A2                       ; set MUX input to tape
+                bra LA976                       ; enable sound
+; Set MUX source to value in B
+LA9A2           ldu #PIA0+1                     ; point to PIA0 control register A
+                bsr LA9A7                       ; program bit 0 then fall through for bit 1
+LA9A7           lda ,u                          ; get control register value
+                anda #0xf7                      ; reset mux control bit
+                asrb                            ; shift desired value to C
+                bcc LA9B0                       ; brif this bit is clear
+                ora #8                          ; set the bit
+LA9B0           sta ,u++                        ; set register value and move to next register
+                rts
+; IRQ service routine
+BIRQSV          lda PIA0+3                      ; check for VSYNC interrupt
+                bpl LA9C5                       ; brif not - return. BUG: should clear HSYNC interrupt status first
+                lda PIA0+2                      ; clear VSYNC interrupt status
+                ldx >SNDDUR                     ; are we counting down for SOUND? (force extended in case DP is modified)
+                beq LA9C5                       ; brif not
+                leax -1,x                       ; count down one tick
+                stx >SNDDUR                     ; save new count (forced extended in case DP is modified)
+LA9C5           rti
+; JOYSTK function
+JOYSTK          jsr LB70E                       ; evaluate which joystick axis is desired
+                cmpb #3                         ; valid axis?
+                lbhi LB44A                      ; brif not
+                tstb                            ; want axis 0?
+                bne LA9D4                       ; brif not
+                bsr GETJOY                      ; read axis data if axis 0
+LA9D4           ldx #POTVAL                     ; point to axis values
+                ldb FPA0+3                      ; get desired axis
+                ldb b,x                         ; get axis value
+                jmp LB4F3                       ; return value
+; Read all four joystick axes. Note that this routine will try 10 times to get a value that matches
+; the value obtained during the *previous call to this routine*. Thus, if the axis value has changed,
+; this routine will do the read *ten times* before just returning the last value. This is assininely
+; slow and probably a bug since it seems more logical to look for two matching reads in a row. Note
+; also that this routine should be using PSHS and PULS but it doesn't.
+GETJOY          bsr LA974                       ; turn off sound
+                ldx #POTVAL+4                   ; point to the end of the axis data (we'll work backwards)
+                ldb #3                          ; start with axis 3
+LA9E5           lda #10                         ; 10 tries to see if we match *the last call* to this routine
+                std ,--s                        ; save retry counter and axis number
+                bsr LA9A2                       ; set MUX for the correct axis
+LA9EB           ldd #0x4080                     ; set initial trial value to mid range and the next difference to add/subtract to half
+LA9EE           sta ,-s                         ; store the add/subtract value
+                orb #2                          ; keep rs232 output marking
+                stb PIA1                        ; set DAC output to the trial value
+                eorb #2                         ; remove RS232 output value
+                lda PIA0                        ; read the comparator
+                bmi LA9FF                       ; brif comparator output is high (DAC is lower than the axis value)
+                subb ,s                         ; subtract next bit value (split the difference toward 0)
+                skip2
+LA9FF           addb ,s                         ; add next bit value (split the different toward infinity)
+                lda ,s+                         ; get bit value back
+                lsra                            ; cut in half
+                cmpa #1                         ; have we done that last value for the DAC?
+                bne LA9EE                       ; brif not
+                lsrb                            ; normalize the axis value
+                lsrb
+                cmpb -1,x                       ; does it match the read from the last call to this routine?
+                beq LAA12                       ; brif so
+                dec ,s                          ; are we out of retries?
+                bne LA9EB                       ; brif not - try again
+LAA12           stb ,-x                         ; save new value and move pointer back
+                ldd ,s++                        ; get axis counter and clean up retry counter
+                decb                            ; move to next axis
+                bpl LA9E5                       ; brif still more axes to do
+                rts
+; This is the "bottom half" of the character fetching routines.
+BROMHK          cmpa #'9+1                      ; is it >= colon?
+                bhs LAA28                       ; brif so Z set if colon, C clear.
+                cmpa #0x20                      ; space?
+                bne LAA24                       ; brif not
+                jmp GETNCH                      ; move on to another character if space
+LAA24           suba #'0                        ; normalize ascii digit to 0-9; we already handled above digit 9
+                suba #-'0                       ; this will cause a carry for any value that was already positive
+LAA28           rts
+; Jump table for functions
+LAA29           fdb SGN                         ; SGN 0x80
+                fdb INT                         ; INT 0x81
+                fdb ABS                         ; ABS 0x82
+                fdb USRJMP                      ; USR 0x83
+                fdb RND                         ; RND 0x84
+                fdb SIN                         ; SIN 0x85
+                fdb PEEK                        ; PEEK 0x86
+                fdb LEN                         ; LEN 0x87
+                fdb STR                         ; STR$ 0x88
+                fdb VAL                         ; VAL 0x89
+                fdb ASC                         ; ASC 0x8a
+                fdb CHR                         ; CHR$ 0x8b
+                fdb EOF                         ; EOF 0x8c
+                fdb JOYSTK                      ; JOYSTK 0x8d
+                fdb LEFT                        ; LEFT$ 0x8e
+                fdb RIGHT                       ; RIGHT$ 0x8f
+                fdb MID                         ; MID$ 0x90
+                fdb POINT                       ; POINT 0x91
+                fdb INKEY                       ; INKEY$ 0x92
+                fdb MEM                         ; MEM 0x93
+; Operator precedence and jump table (binary ops except relational)
+LAA51           fcb 0x79                        ; +
+                fdb LB9C5
+                fcb 0x79                        ; -
+                fdb LB9BC
+                fcb 0x7b                        ; *
+                fdb LBACC
+                fcb 0x7b                        ; /
+                fdb LBB91
+                fcb 0x7f                        ; ^ (exponentiation)
+                fdb EXPJMP
+                fcb 0x50                        ; AND
+                fdb LB2D5
+                fcb 0x46                        ; OR
+                fdb LB2D4
+; Reserved words table for commands
+LAA66           fcs 'FOR'                       ; 0x80
+                fcs 'GO'                        ; 0x81
+                fcs 'REM'                       ; 0x82
+                fcs "'"                         ; 0x83
+                fcs 'ELSE'                      ; 0x84
+                fcs 'IF'                        ; 0x85
+                fcs 'DATA'                      ; 0x86
+                fcs 'PRINT'                     ; 0x87
+                fcs 'ON'                        ; 0x88
+                fcs 'INPUT'                     ; 0x89
+                fcs 'END'                       ; 0x8a
+                fcs 'NEXT'                      ; 0x8b
+                fcs 'DIM'                       ; 0x8c
+                fcs 'READ'                      ; 0x8d
+                fcs 'RUN'                       ; 0x8e
+                fcs 'RESTORE'                   ; 0x8f
+                fcs 'RETURN'                    ; 0x90
+                fcs 'STOP'                      ; 0x91
+                fcs 'POKE'                      ; 0x92
+                fcs 'CONT'                      ; 0x93
+                fcs 'LIST'                      ; 0x94
+                fcs 'CLEAR'                     ; 0x95
+                fcs 'NEW'                       ; 0x96
+                fcs 'CLOAD'                     ; 0x97
+                fcs 'CSAVE'                     ; 0x98
+                fcs 'OPEN'                      ; 0x99
+                fcs 'CLOSE'                     ; 0x9a
+                fcs 'LLIST'                     ; 0x9b
+                fcs 'SET'                       ; 0x9c
+                fcs 'RESET'                     ; 0x9d
+                fcs 'CLS'                       ; 0x9e
+                fcs 'MOTOR'                     ; 0x9f
+                fcs 'SOUND'                     ; 0xa0
+                fcs 'AUDIO'                     ; 0xa1
+                fcs 'EXEC'                      ; 0xa2
+                fcs 'SKIPF'                     ; 0xa3
+                fcs 'TAB('                      ; 0xa4
+                fcs 'TO'                        ; 0xa5
+                fcs 'SUB'                       ; 0xa6
+                fcs 'THEN'                      ; 0xa7
+                fcs 'NOT'                       ; 0xa8
+                fcs 'STEP'                      ; 0xa9
+                fcs 'OFF'                       ; 0xaa
+                fcs '+'                         ; 0xab
+                fcs '-'                         ; 0xac
+                fcs '*'                         ; 0xad
+                fcs '/'                         ; 0xae
+                fcs '^'                         ; 0xaf
+                fcs 'AND'                       ; 0xb0
+                fcs 'OR'                        ; 0xb1
+                fcs '>'                         ; 0xb2
+                fcs '='                         ; 0xb3
+                fcs '<'                         ; 0xb4
+; Reserved word list for functions
+LAB1A           fcs 'SGN'                       ; 0x80
+                fcs 'INT'                       ; 0x81
+                fcs 'ABS'                       ; 0x82
+                fcs 'USR'                       ; 0x83
+                fcs 'RND'                       ; 0x84
+                fcs 'SIN'                       ; 0x85
+                fcs 'PEEK'                      ; 0x86
+                fcs 'LEN'                       ; 0x87
+                fcs 'STR$'                      ; 0x88
+                fcs 'VAL'                       ; 0x89
+                fcs 'ASC'                       ; 0x8a
+                fcs 'CHR$'                      ; 0x8b
+                fcs 'EOF'                       ; 0x8c
+                fcs 'JOYSTK'                    ; 0x8d
+                fcs 'LEFT$'                     ; 0x8e
+                fcs 'RIGHT$'                    ; 0x8f
+                fcs 'MID$'                      ; 0x90
+                fcs 'POINT'                     ; 0x91
+                fcs 'INKEY$'                    ; 0x92
+                fcs 'MEM'                       ; 0x93
+; Jump table for commands
+LAB67           fdb FOR                         ; 0x80 FOR
+                fdb GO                          ; 0x81 GO
+                fdb REM                         ; 0x82 REM
+                fdb REM                         ; 0x83 '
+                fdb REM                         ; 0x84 ELSE
+                fdb IFTOK                       ; 0x85 IF
+                fdb DATA                        ; 0x86 DATA
+                fdb PRINT                       ; 0x87 PRINT
+                fdb ON                          ; 0x88 ON
+                fdb INPUT                       ; 0x89 INPUT
+                fdb ENDTOK                      ; 0x8a END
+                fdb NEXT                        ; 0x8b NEXT
+                fdb DIM                         ; 0x8c DIM
+                fdb READ                        ; 0x8d READ
+                fdb RUN                         ; 0x8e RUN
+                fdb RESTOR                      ; 0x8f RESTORE
+                fdb RETURN                      ; 0x90 RETURN
+                fdb STOP                        ; 0x91 STOP
+                fdb POKE                        ; 0x92 POKE
+                fdb CONT                        ; 0x93 CONT
+                fdb LIST                        ; 0x94 LIST
+                fdb CLEAR                       ; 0x95 CLEAR
+                fdb NEW                         ; 0x96 NEW
+                fdb CLOAD                       ; 0x97 CLOAD
+                fdb CSAVE                       ; 0x98 CSAVE
+                fdb OPEN                        ; 0x99 OPEN
+                fdb CLOSE                       ; 0x9a CLOSE
+                fdb LLIST                       ; 0x9b LLIST
+                fdb SET                         ; 0x9c SET
+                fdb RESET                       ; 0x9d RESET
+                fdb CLS                         ; 0x9e CLS
+                fdb MOTOR                       ; 0x9f MOTOR
+                fdb SOUND                       ; 0xa0 SOUND
+                fdb AUDIO                       ; 0xa1 AUDIO
+                fdb EXEC                        ; 0xa2 EXEC
+                fdb SKIPF                       ; 0xa3 SKIPF
+; Error message table
+LABAF           fcc 'NF'                        ; 0 NEXT without FOR
+                fcc 'SN'                        ; 1 Syntax error
+                fcc 'RG'                        ; 2 RETURN without GOSUB
+                fcc 'OD'                        ; 3 Out of data
+                fcc 'FC'                        ; 4 Illegal function call
+                fcc 'OV'                        ; 5 Overflow
+                fcc 'OM'                        ; 6 Out of memory
+                fcc 'UL'                        ; 7 Undefined line number
+                fcc 'BS'                        ; 8 Bad subscript
+                fcc 'DD'                        ; 9 Redimensioned array
+                fcc '/0'                        ; 10 Division by 0
+                fcc 'ID'                        ; 11 Illegal direct statement
+                fcc 'TM'                        ; 12 Type mismatch
+                fcc 'OS'                        ; 13 Out of string space
+                fcc 'LS'                        ; 14 String too long
+                fcc 'ST'                        ; 15 String formula too complex
+                fcc 'CN'                        ; 16 Can't continue
+                fcc 'FD'                        ; 17 Bad file data
+                fcc 'AO'                        ; 18 File already open
+                fcc 'DN'                        ; 19 Device number error
+                fcc 'IO'                        ; 20 Input/output error
+                fcc 'FM'                        ; 21 Bad file mode
+                fcc 'NO'                        ; 22 File not open
+                fcc 'IE'                        ; 23 Input past end of file
+                fcc 'DS'                        ; 24 Direct statement in file
+LABE1           fcn ' ERROR'
+LABE8           fcn ' IN '
+LABED           fcb 0x0d
+LABEE           fcc 'OK'
+                fcb 0x0d,0x00
+LABF2           fcb 0x0d
+                fcn 'BREAK'
+; Search stack for a FOR/NEXT stack frame. Stop search when something that isn't a FOR/NEXT
+; stack frame is found. Enter with the index variable descriptor pointer in VARDES, or NULL
+; for the first match.
+;
+; NOTE: this routine can be reworked to avoid needed two temporaries by taking advantage of the
+; 6809's registers. This requires some minor tweaks where the routine is called. Further, the
+; use of B is completely pointless and, even if B is going to be used, why is it reloaded on
+; every loop?
+LABF9           leax 4,s                        ; skip past our caller and the main command loop return address
+LABFB           ldb #18                         ; each FOR/NEXT frame is 18 bytes
+                stx TEMPTR                      ; save current search pointer
+                lda ,x                          ; get first byte of this frame
+                suba #0x80                      ; set to 0 if FOR/NEXT
+                bne LAC1A                       ; brif not FOR/NEXT (we hit the end of the stack for a GOSUB frame)
+                ldx 1,x                         ; get index variable descriptor
+                stx TMPTR1                      ; save it
+                ldx VARDES                      ; get desired index descriptor
+                beq LAC16                       ; brif NULL - we found something
+                cmpx TMPTR1                     ; does this one match?
+                beq LAC1A                       ; brif so
+                ldx TEMPTR                      ; get back frame pointer
+                abx                             ; move to next entry
+                bra LABFB                       ; check next block of data
+LAC16           ldx TMPTR1                      ; get index variable of this frame
+                stx VARDES                      ; set it as the one found
+LAC1A           ldx TEMPTR                      ; get matching frame pointer
+                tsta                            ; set Z if FOR/NEXT
+                rts
+; This is a block copy routine which copies from top to bottom. It's not clear that the use of
+; this routine actually saves any ROM space compared to just implementing the copies directly
+; once all the marshalling to set up the parameter variables is taken into account.
+LAC1E           bsr LAC37                       ; check to see if stack collides with D
+LAC20           ldu V41                         ; point to destination
+                leau 1,u                        ; offset for pre-dec
+                ldx V43                         ; point to source
+                leax 1,x                        ; offset for pre-dec
+LAC28           lda ,-x                         ; get source byte
+                pshu a                          ; store at destination (sta ,-u would be less weird)
+                cmpx V47                        ; at the bottom of the copy?
+                bne LAC28                       ; brif not
+                stu V45                         ; save final destination address
+LAC32           rts
+; Check for 2*B (0 <= B <= 127) bytes for free memory
+LAC33           clra                            ; zero extend
+                aslb                            ; times 2 (loses bit 7 of B)
+                addd ARYEND                     ; add to top of used memory
+LAC37           addd #STKBUF                    ; add a fudge factor for interpreter operation
+                bcs LAC44                       ; brif >65535!
+                sts BOTSTK                      ; get current stack pointer
+                cmpd BOTSTK                     ; is our new address above that?
+                blo LAC32                       ; brif not - no error
+LAC44           ldb #6*2                        ; raise OM error
+; The error servicing routine
+LAC46           jsr RVEC16                      ; do the RAM hook dance (ON ERROR reserved hook)
+LAC49           jsr RVEC17                      ; do the RAM hook dance again
+                jsr LA7E9                       ; turn off tape
+                jsr LA974                       ; disable sound
+                jsr LAD33                       ; reset stack, etc.
+                clr DEVNUM                      ; reset output to screen
+                jsr LB95C                       ; do a newline
+                jsr LB9AF                       ; send a ?
+                ldx #LABAF                      ; point to error table
+                abx                             ; offset to correct message
+                bsr LACA0                       ; send a char from X
+                bsr LACA0                       ; send another char from X
+                ldx #LABE1-1                    ; point to "ERROR" message
+LAC68           jsr LB99C                       ; print ERROR message (or BREAK)
+                lda CURLIN                      ; are we in immediate mode?
+                inca
+                beq LAC73                       ; brif not - go to immediate mode
+                jsr LBDC5                       ; print "IN ****"
+; This is the immediate mode loop
+LAC73           jsr LB95C                       ; do a newline if needed
+LAC76           ldx #LABEE-1                    ; point to prompt (without leading CR)
+                jsr LB99C                       ; show prompt
+LAC7C           jsr LA390                       ; read an input line
+                ldu #0xffff                     ; flag immediate mode
+                stu CURLIN
+                bcs LAC7C                       ; brif we ended on BREAK - just go for another line
+                tst CINBFL                      ; EOF?
+                lbne LA4BF                      ; brif so
+                stx CHARAD                      ; save start of input line as input pointer
+                jsr GETNCH                      ; get character from input line
+                beq LAC7C                       ; brif no input
+                bcs LACA5                       ; brif numeric - adding or removing a line number
+                ldb #2*24                       ; code for "direct statement in file"
+                tst DEVNUM                      ; keyboard input?
+                bne LAC46                       ; brif not - complain about direct statement
+                jsr LB821                       ; go tokenize the input line
+                jmp LADC0                       ; go execute the newly tokenized line
+LACA0           lda ,x+                         ; get character and advance pointer
+                jmp LB9B1                       ; output it
+LACA5           jsr LAF67                       ; convert line number to binary
+                ldx BINVAL                      ; get converted number
+                stx LINHDR                      ; put it before the line we just read
+                jsr LB821                       ; tokenize the input line
+                stb TMPLOC                      ; save line length
+                bsr LAD01                       ; find where the line should be in the program
+                bcs LACC8                       ; brif the line number isn't already present
+                ldd V47                         ; get address where the line is in the program
+                subd ,x                         ; get the difference between here and the end of the line (negative)
+                addd VARTAB                     ; subtract line length from the end of the program
+                std VARTAB                      ; save new end of program address
+                ldu ,x                          ; get start of next line
+LACC0           pulu a                          ; get source byte (lda ,u+ would be less weird)
+                sta ,x+                         ; move it down
+                cmpx VARTAB                     ; have we moved everything yet?
+                bne LACC0                       ; brif not
+LACC8           lda LINBUF                      ; see if there is actually a line to input
+                beq LACE9                       ; brif not - we just needed to remove the line
+                ldd VARTAB                      ; get current end of program
+                std V43                         ; set as source pointer
+                addb TMPLOC                     ; add in the length of the new line
+                adca #0
+                std V41                         ; save destination pointer
+                jsr LAC1E                       ; make sure there's enough room and then make a hole for the new line
+                ldu #LINHDR-2                   ; point to the line (well, 4 bytes before it, incl line number and fake next line pointer)
+LACDD           pulu a                          ; get byte from new line (lda ,u+ would be less weird)
+                sta ,x+                         ; stow it
+                cmpx V45                        ; at the end of the hole we just made?
+                bne LACDD                       ; brif not
+                ldx V41                         ; get save new top of program address
+                stx VARTAB
+LACE9           bsr LAD21                       ; reset variables, etc.
+                bsr LACEF                       ; adjust next line pointers
+                bra LAC7C                       ; go read another input line
+; Recompute next line pointers
+LACEF           ldx  TXTTAB                     ; point to start of program
+LACF1           ldd ,x                          ; get address of next line
+                beq LAD16                       ; brif end of program
+                leau 4,x                        ; move past pointer and line number
+LACF7           lda ,u+                         ; are we at the end of the line?
+                bne LACF7                       ; brif not
+                stu ,x                          ; save new next line pointer
+                ldx ,x                          ; point to next line
+                bra LACF1                       ; process the next line
+; Find a line in the program
+LAD01           ldd BINVAL                      ; get desired line number
+                ldx TXTTAB                      ; point to start of program
+LAD05           ldu ,x                          ; get address of next line
+                beq LAD12                       ; brif end of program
+                cmpd 2,x                        ; do we have a match?
+                bls LAD14                       ; brif our search number is <= the number here
+                ldx ,x                          ; move to next line
+                bra LAD05                       ; check another line
+LAD12           orcc #1                         ; set C for not found
+LAD14           stx V47                         ; save address of matching line *or* line just after where it would have been
+LAD16           rts
+; NEW command
+; This routine has multiple entry points used for various "levels" of NEW
+NEW             bne LAD14                       ; brif there was input given; should be LAD16!
+LAD19           ldx TXTTAB                      ; point to start of program
+                clr ,x+                         ; blank out program (with NULL next line pointer)
+                clr ,x+
+                stx VARTAB                      ; save end of program
+LAD21           ldx TXTTAB                      ; get start of program
+                jsr LAEBB                       ; put input pointer there
+LAD26           ldx MEMSIZ                      ; reset string space
+                stx STRTAB
+                jsr RESTOR                      ; reset DATA pointer
+                ldx VARTAB                      ; clear out scalars and arrays
+                stx ARYTAB
+                stx ARYEND
+LAD33           ldx #STRSTK                     ; reset the string stack
+                stx TEMPPT
+                ldx ,s                          ; get return address (we're going to reset the stack)
+                lds FRETOP                      ; reset the stack to top of memory
+                clr ,-s                         ; put stopper so FOR/NEXT search will actually stop here
+                clr OLDPTR                      ; reset "CONT" state
+                clr OLDPTR+1
+                clr ARYDIS                      ; un-disable arrays
+                jmp ,x                          ; return to original caller
+; FOR command
+FOR             lda #0x80                       ; disable array parsing
+                sta ARYDIS
+                jsr LET                         ; assign start value to index
+                jsr LABF9                       ; search stack for matching FOR/NEXT frame
+                leas 2,s                        ; lose return address
+                bne LAD59                       ; brif variable not already being used
+                ldx TEMPTR                      ; get address of matched data
+                leas b,x                        ; move stack pointer to the end of it (B is set to 18 in the stack search)
+LAD59           ldb #9                          ; is there room for 18 bytes in memory?
+                jsr LAC33
+                jsr LAEE8                       ; get address of the end of this statement in X
+                ldd CURLIN                      ; get line number
+                pshs x,b,a                      ; save next line address and current line number
+                ldb #0xa5                       ; make sure we have TO
+                jsr LB26F
+                jsr LB143                       ; make sure we have a numeric index
+                jsr LB141                       ; evaluate terminal condition value
+                ldb FP0SGN                      ; pack FPA0 in place
+                orb #0x7f
+                andb FPA0
+                stb FPA0
+                ldy #LAD7F                      ; where to come back to
+                jmp LB1EA                       ; stash terminal condition on the stack
+LAD7F           ldx #LBAC5                      ; point to FP 1.0 (default step)
+                jsr LBC14                       ; unpack it to FPA0
+                jsr GETCCH                      ; get character after the terminal
+                cmpa #0xa9                      ; is it STEP?
+                bne LAD90                       ; brif not
+                jsr GETNCH                      ; eat STEP
+                jsr LB141                       ; evaluate step condition
+LAD90           jsr LBC6D                       ; get "status" of FPA0
+                jsr LB1E6                       ; stash FPA0 on the stack (for step value)
+                ldd VARDES                      ; get variable descriptor pointer
+                pshs d                          ; put that on the stack too
+                lda #0x80                       ; flag the frame as a FOR/NEXT frame
+                pshs a
+; Main command interpretation loop
+LAD9E           jsr RVEC20                      ; do the RAM hook dance
+                andcc #0xaf                     ; make sure interrupts are running
+                bsr LADEB                       ; check for BREAK/pause
+                ldx CHARAD                      ; get input pointer
+                stx TINPTR                      ; save input pointer for start of line
+                lda ,x+                         ; get current input character
+                beq LADB4                       ; brif end of line - move to another line
+                cmpa #':                        ; end of statement?
+                beq LADC0                       ; brif so - keep processing
+LADB1           jmp LB277                       ; raise a syntax error
+LADB4           lda ,x++                        ; get MSB of next line pointer and skip past pointer
+                sta ENDFLG
+                beq LAE15                       ; brif MSB of next line address is 0 (do END)
+                ldd ,x+                         ; get line number but only advance one
+                std CURLIN                      ; set current line number
+                stx CHARAD                      ; set input pointer to one before line text
+LADC0           jsr GETNCH                      ; move past statement separator or to first character in line
+                bsr LADC6                       ; process a command
+                bra LAD9E                       ; handle next statement or line
+LADC6           beq LAE40                       ; return if end of statement
+                tsta                            ; is it a token?
+                lbpl LET                        ; brif not - do a LET
+                cmpa #0xa3                      ; above SKIPF?
+                bhi LADDC                       ; brif so
+                ldx COMVEC+3                    ; point to jump table
+                lsla                            ; two bytes per entry (loses the token bias)
+                tfr a,b                         ; put it in B for unsigned ABX
+                abx
+                jsr GETNCH                      ; move past token
+                jmp [,x]                        ; transfer control to the handler (which will return to the main loop)
+LADDC           cmpa #0xb4                      ; is it a non-executable token?
+                bls LADB1                       ; brif so
+                jmp [COMVEC+13]                 ; transfer control to ECB command handler
+; RESTORE command
+RESTOR          ldx TXTTAB                      ; point to beginning of the program
+                leax -1,x                       ; move back one (to compensate for "GETNCH")
+LADE8           stx DATPTR                      ; save as new data pointer
+                rts
+; BREAK check
+LADEB           jsr KEYIN                       ; read keyboard
+                beq LADFA                       ; brif no key down
+LADF0           cmpa #3                         ; BREAK?
+                beq STOP                        ; brif so - do a STOP
+                cmpa #0x13                      ; pause (SHIFT-@)?
+                beq LADFB                       ; brif so
+                sta IKEYIM                      ; cache key for later INKEY$ so break check doesn't break INKEY$
+LADFA           rts
+LADFB           jsr KEYIN                       ; read keyboard
+                beq LADFB                       ; brif no key down
+                bra LADF0                       ; process pressed key in case BREAK or SHIFT-@ again
+; END command
+ENDTOK          jsr LA426                       ; close files
+                jsr GETCCH                      ; re-get input character
+                bra LAE0B
+; STOP command
+STOP            orcc #1                         ; flag "STOP"
+LAE0B           bne LAE40                       ; brif not end of statement
+                ldx CHARAD                      ; save current input pointer
+                stx TINPTR
+LAE11           ror ENDFLG                      ; save END/STOP flag (C)
+                leas 2,s                        ; lose return address
+LAE15           ldx CURLIN                      ; get current input line (end of program comes here)
+                cmpx #0xffff                    ; immediate mode?
+                beq LAE22                       ; brif so
+                stx OLDTXT                      ; save line where we stopped executing
+                ldx TINPTR                      ; get input pointer
+                stx OLDPTR                      ; save location where we stopped executing
+LAE22           clr DEVNUM                      ; reset to screen/keyboard
+                ldx #LABF2-1                    ; point to BREAK message
+                tst ENDFLG                      ; are we doing "BREAK"?
+                lbpl LAC73                      ; brif not
+                jmp LAC68                       ; go do the BREAK message and return to main loop
+; CONT command
+CONT            bne LAE40                       ; brif not end of statement
+                ldb #2*16                       ; code for can't continue
+                ldx OLDPTR                      ; get saved execution pointer
+                lbeq LAC46                      ; brif no saved pointer - raise CN error
+                stx CHARAD                      ; reset input pointer
+                ldx OLDTXT                      ; reset current line number
+                stx CURLIN
+LAE40           rts
+; CLEAR command
+CLEAR           beq LAE6F                       ; brif no argument
+                jsr LB3E6                       ; evaluate string space size
+                pshs d                          ; save it
+                ldx MEMSIZ                      ; get memory size (top of memory)
+                jsr GETCCH                      ; is there anything after the string space size?
+                beq LAE5A                       ; brif not
+                jsr LB26D                       ; force a comma
+                jsr LB73D                       ; get top of memory value in X
+                leax -1,x                       ; move back one (top of cleared space)
+                cmpx TOPRAM                     ; is it within the memory available?
+                bhi LAE72                       ; brif higher than top of memory - OM error
+LAE5A           tfr x,d                         ; so we can do math for checking memory usage
+                subd ,s++                       ; subtract out string space value
+                bcs LAE72                       ; brif less than 0
+                tfr d,u                         ; U is bottom of cleared space
+                subd #STKBUF                    ; also account for slop space
+                bcs LAE72                       ; brif less than 0
+                subd VARTAB                     ; is there still room for the program?
+                blo LAE72                       ; brif not
+                stu FRETOP                      ; set top of free memory
+                stx MEMSIZ                      ; set size of usable memory
+LAE6F           jmp LAD26                       ; erase variables, etc.
+LAE72           jmp LAC44                       ; raise OM error
+; RUN command
+RUN             jsr RVEC18                      ; do the RAM hook dance
+                jsr LA426                       ; close any open files
+                jsr GETCCH                      ; is there a line number
+                lbeq LAD21                      ; brif no line number - start from beginning
+                jsr LAD26                       ; clear variables, etc.
+                bra LAE9F                       ; "GOTO" the line number
+; GO command (GOTO and GOSUB)
+GO              tfr a,b                         ; save TO/SUB
+LAE88           jsr GETNCH                      ; eat the TO/SUB token
+                cmpb #0xa5                      ; TO?
+                beq LAEA4                       ; brif GOTO
+                cmpb #0xa6                      ; SUB?
+                bne LAED7                       ; brif not
+                ldb #3                          ; room for 6 bytes?
+                jsr LAC33
+                ldu CHARAD                      ; get input pointer
+                ldx CURLIN                      ; get line number
+                lda #0xa6                       ; flag for GOSUB frame
+                pshs u,x,a                      ; set stack frame
+LAE9F           bsr LAEA4                       ; do "GOTO"
+                jmp LAD9E                       ; go back to main loop
+; Actual GOTO is here
+LAEA4           jsr GETCCH                      ; get current input
+                jsr LAF67                       ; convert number to binary
+                bsr LAEEB                       ; move input pointer to end of statement
+                leax 1,x                        ; point to start of next line
+                ldd BINVAL                      ; get desired line number
+                cmpd CURLIN                     ; is it beyond here?
+                bhi LAEB6                       ; brif so
+                ldx TXTTAB                      ; start search at beginning of program
+LAEB6           jsr LAD05                       ; find line number
+                bcs LAED2                       ; brif not found
+LAEBB           leax -1,x                       ; move to just before start of line
+                stx CHARAD                      ; reset input pointer
+LAEBF           rts
+; RETURN command
+RETURN          bne LAEBF                       ; exit if argument given
+                lda #0xff                       ; set VARDES to an illegal value so we ignore FOR frames
+                sta VARDES
+                jsr LABF9                       ; look for a GOSUB frame
+                tfr x,s                         ; reset stack
+                cmpa #0xa6-0x80                 ; is it a GOSUB frame?
+                beq LAEDA                       ; brif so
+                ldb #2*2                        ; code for RETURN without GOSUB
+                skip2
+LAED2           ldb #7*2                        ; code for undefined line number
+                jmp LAC46                       ; raise error
+LAED7           jmp LB277                       ; raise syntax error
+LAEDA           puls a,x,u                      ; get back saved line number and input pointer
+                stx CURLIN                      ; reset line number
+                stu CHARAD                      ; reset input pointer
+; DATA command
+DATA            bsr LAEE8                       ; move input pointer to end of statement
+                skip2
+; REM command (also ELSE)
+REM             bsr LAEEB                       ; move input pointer to end of line
+                stx CHARAD                      ; save new input pointer
+LAEE7           rts
+; Return end of statement (LAEE8) or line (AEEB) in X
+LAEE8           ldb #':                         ; colon is statement terminator
+                skip1lda
+LAEEB           clrb                            ; make main terminator NUL
+                stb CHARAC                      ; save terminator
+                clrb                            ; end of line - always terminates
+                ldx CHARAD                      ; get input pointer
+LAEF1           tfr b,a                         ; save secondary terminator
+                ldb CHARAC                      ; get main terminator
+                sta CHARAC                      ; save secondary
+LAEF7           lda ,x                          ; get input character
+                beq LAEE7                       ; brif end of line
+                pshs b                          ; save terminator
+                cmpa ,s+                        ; does it match?
+                beq LAEE7                       ; brif so - bail
+                leax 1,x                        ; move pointer ahead
+                cmpa #'"                        ; start of string?
+                beq LAEF1                       ; brif so
+                inca                            ; functon token?
+                bne LAF0C                       ; brif not
+                leax 1,x                        ; skip second part of function token
+LAF0C           cmpa #0x85+1                    ; IF?
+                bne LAEF7                       ; brif not
+                inc IFCTR                       ; bump "IF" count
+                bra LAEF7                       ; get check another input character
+; IF command
+IFTOK           jsr LB141                       ; evaluate condition
+                jsr GETCCH                      ; find out what's after the conditin
+                cmpa #0x81                      ; GO?
+                beq LAF22                       ; treat same as THEN
+                ldb #0xa7                       ; make sure we have a THEN
+                jsr LB26F
+LAF22           lda FP0EXP                      ; get true/false (false is 0)
+                bne LAF39                       ; brif condition true
+                clr IFCTR                       ; reset IF counter
+LAF28           bsr DATA                        ; skip over statement
+                tsta                            ; end of line?
+                beq LAEE7                       ; brif so
+                jsr GETNCH                      ; get start of this statement
+                cmpa #0x84                      ; ELSE?
+                bne LAF28                       ; brif not
+                dec IFCTR                       ; is it a matching ELSE?
+                bpl LAF28                       ; brif not - keep looking
+                jsr GETNCH                      ; eat the ELSE
+LAF39           jsr GETCCH                      ; get current input
+                lbcs LAEA4                      ; brif numeric - to a GOTO
+                jmp LADC6                       ; let main loop interpret the next command
+; ON command
+ON              jsr LB70B                       ; evaluate index expression
+LAF45           ldb #0x81                       ; make sure we have "GO"
+                jsr LB26F
+                pshs a                          ; save TO/SUB
+                cmpa #0xa6                      ; SUB?
+                beq LAF54                       ; brif so
+                cmpa #0xa5                      ; TO?
+LAF52           bne LAED7                       ; brif not
+LAF54           dec FPA0+3                      ; are we at the right index?
+                bne LAF5D                       ; brif not
+                puls b                          ; get TO/SUB token
+                jmp LAE88                       ; go do GOTO or GOSUB
+LAF5D           jsr GETNCH                      ; munch a character
+                bsr LAF67                       ; parse line number
+                cmpa #',                        ; is there another line following?
+                beq LAF54                       ; brif so - see if we're there yet
+                puls b,pc                       ; clean up TO/SUB token and return - we fell through
+; Parse a line number
+LAF67           ldx ZERO                        ; initialize line number accumulator to 0
+                stx BINVAL
+LAF6B           bcc LAFCE                       ; brif not numeric
+                suba #'0                        ; adjust to actual value of digit
+                sta CHARAC                      ; save digit
+                ldd BINVAL                      ; get accumulated number
+                cmpa #24                        ; will this overflow?
+                bhi LAF52                       ; brif so - raise syntax error
+                aslb                            ; times 2
+                rola
+                aslb                            ; times 4
+                rola
+                addd BINVAL                     ; times 5
+                aslb                            ; times 10
+                rola
+                addb CHARAC                     ; add in digit
+                adca #0
+                std BINVAL                      ; save new accumulated number
+                jsr GETNCH                      ; fetch next character
+                bra LAF6B                       ; process next digit
+; LET command (the LET keyword requires Extended Basic)
+LET             jsr LB357                       ; evaluate destination variable
+                stx VARDES                      ; save descriptor pointer
+                ldb #0xb3                       ; make sure we have =
+                jsr LB26F
+                lda VALTYP                      ; get destination variable type
+                pshs a                          ; save it for later
+                jsr LB156                       ; evaluate the expression to assign
+                puls a                          ; get back original variable type
+                rora                            ; put type in C
+                jsr LB148                       ; make sure the current result matches the type
+                lbeq LBC33                      ; bri fnumeric - copy FPA0 to variable
+LAFA4           ldx FPA0+2                      ; point to descriptor of replacement string
+                ldd FRETOP                      ; get bottom of string space
+                cmpd 2,x                        ; is the string already in string space?
+                bhs LAFBE                       ; brif so
+                cmpx VARTAB                     ; is the descriptor in variable space?
+                blo LAFBE                       ; brif not
+LAFB1           ldb ,x                          ; get length of string
+                jsr LB50D                       ; allocate space for this string
+                ldx V4D                         ; get descriptor pointer back
+                jsr LB643                       ; copy string into string space
+                ldx #STRDES                     ; point to temporary string descriptor
+LAFBE           stx V4D                         ; save descriptor pointer
+                jsr LB675                       ; remove string from string stack if appropriate
+                ldu V4D                         ; get back replacement descriptor
+                ldx VARDES                      ; get target descriptor
+                pulu a,b,y                      ; get string length (A) and data pointer (Y)
+                sta ,x                          ; save new length
+                sty 2,x                         ; save new pointer
+LAFCE           rts
+; READ and INPUT commands.
+LAFCF           fcc '?REDO'                     ; The ?REDO message
+                fcb 0x0d,0x00
+LAFD6           ldb #2*17                       ; bad file data code
+                tst DEVNUM                      ; are we reading from the keyboard?
+                beq LAFDF                       ; brif so
+LAFDC           jmp LAC46                       ; raise the error
+LAFDF           lda INPFLG                      ; are we doing INPUT?
+                beq LAFEA                       ; brif so
+                ldx DATTXT                      ; get line number where the DATA statement happened
+                stx CURLIN                      ; set current line number to that so can report the correct location
+                jmp LB277                       ; raise a syntax error on bad data
+LAFEA           ldx #LAFCF-1                    ; show the ?REDO if we're doing INPUT
+                jsr LB99C
+                ldx TINPTR                      ;* reset input pointer to start of statement (this will cause the
+                stx CHARAD                      ;* INPUT statement to be re-executed
+                rts
+INPUT           ldb #11*2                       ; code for illegal direct statement
+                ldx CURLIN                      ; are we in immediate mode?
+                leax 1,x
+                beq LAFDC                       ; brif so - raise ID error
+                bsr LB002                       ; go do the INPUT thing
+                clr DEVNUM                      ; reset device to screen/keyboard
+                rts
+LB002           cmpa #'#                        ; is there a device number?
+                bne LB00F                       ; brif not
+                jsr LA5A5                       ; parse device number
+                jsr LA3ED                       ; make sure it's valid for input
+                jsr LB26D                       ; make sure we have a comma after the device number
+LB00F           cmpa #'"                        ; is there a prompt string?
+                bne LB01E                       ; brif not
+                jsr LB244                       ; parse the prompt string
+                ldb #';                         ; make sure we have a semicolon after the prompt
+                jsr LB26F
+                jsr LB99F                       ; print the prompt
+LB01E           ldx #LINBUF                     ; point to line input buffer
+                clr ,x                          ; NUL first byte to indicate no data
+                tst DEVNUM                      ; is it keyboard input?
+                bne LB049                       ; brif not
+                bsr LB02F                       ; read a line from the keyboard
+                ldb #',                         ; put a comma at the start of the buffer
+                stb ,x
+                bra LB049                       ; go process some input
+LB02F           jsr LB9AF                       ; send a ?
+                jsr LB9AC                       ; send a space
+LB035           jsr LA390                       ; read input from the keyboard
+                bcc LB03F                       ; brif not BREAK
+                leas 4,s                        ; clean up stack
+LB03C           jmp LAE11                       ; go process BREAK
+LB03F           ldb #2*23                       ; input past end of file error code
+                tst CINBFL                      ; was it EOF?
+                bne LAFDC                       ; brif so - raise the error
+                rts
+READ            ldx DATPTR                      ; fetch current DATA pointer
+                skip1lda                        ; set A to nonzero (for READ)
+LB049           clra                            ; set A to zero (for INPUT)
+                sta INPFLG                      ; record whether we're doing READ or INPUT
+                stx DATTMP                      ; save current input location
+LB04E           jsr LB357                       ; evaluate a variable (destination of data)
+                stx VARDES                      ; save descriptor
+                ldx CHARAD                      ; save interpreter input pointer
+                stx BINVAL
+                ldx DATTMP                      ; get data pointer
+                lda ,x                          ; is there anything to read?
+                bne LB069                       ; brif so
+                lda INPFLG                      ; is it INPUT?
+                bne LB0B9                       ; brif not
+                jsr RVEC10                      ; do the RAM hook dance
+                jsr LB9AF                       ; send a ? (so subsequent lines get ??)
+                bsr LB02F                       ; go read an input line
+LB069           stx CHARAD                      ; save data pointer
+                jsr GETNCH                      ; fetch next data character
+                ldb VALTYP                      ; do we want a number?
+                beq LB098                       ; brif so
+                ldx CHARAD                      ; get input pointer
+                sta CHARAC                      ; save initial character as the delimiter
+                cmpa #'"                        ; do we have a string delimiter?
+                beq LB08B                       ; brif so - use " as both delimiters
+                leax -1,x                       ; back up input if we don't have a delimiter
+                clra                            ; set delimiter to NUL (end of line)
+                sta CHARAC
+                jsr LA35F                       ; set up print parameters
+                tst PRTDEV                      ; is it a file type device?
+                bne LB08B                       ; brif so - use two NULs
+                lda #':                         ; use colon as one delimiter
+                sta CHARAC
+                lda #',                         ; and use comma as the other
+LB08B           sta ENDCHR                      ; save second terminator
+                jsr LB51E                       ; parse out the string
+                jsr LB249                       ; move input pointer past the string
+                jsr LAFA4                       ; assign the string to the variable
+                bra LB09E                       ; go see if there's more to read
+LB098           jsr LBD12                       ; parse a numeric string
+                jsr LBC33                       ; assign the numbe to the variable
+LB09E           jsr GETCCH                      ; get current input character
+                beq LB0A8                       ; brif end of line
+                cmpa #',                        ; check for comma
+                lbne LAFD6                      ; brif not - we have bad data
+LB0A8           ldx CHARAD                      ; get current data pointer
+                stx DATTMP                      ; save the data pointer
+                ldx BINVAL                      ; restore the interpreter input pointer
+                stx CHARAD
+                jsr GETCCH                      ; get current input from program
+                beq LB0D5                       ; brif end of statement
+                jsr LB26D                       ; make sure there's a comma between variables
+                bra LB04E                       ; go read another item
+LB0B9           stx CHARAD                      ; reset input pointer
+                jsr LAEE8                       ; search for end of statement
+                leax 1,x                        ; move past end of statement
+                tsta                            ; was it end of line?
+                bne LB0CD                       ; brif not
+                ldb #2*3                        ; code for out of data
+                ldu ,x++                        ; get pointer to next line
+                beq LB10A                       ; brif end of program - raise OD error
+                ldd ,x++                        ; get line number
+                std DATTXT                      ; record it for raising errors in DATA statements
+LB0CD           lda ,x                          ; do we have a DATA statement?
+                cmpa #0x86
+                bne LB0B9                       ; brif not - keep scanning
+                bra LB069                       ; go process the input
+LB0D5           ldx DATTMP                      ; get data pointer
+                ldb INPFLG                      ; were we doing READ?
+                lbne LADE8                      ; brif so - save DATA pointer
+                lda ,x                          ; is there something after the input in the input buffer?
+                beq LB0E7                       ; brif not - we consumed everything
+                ldx #LB0E8-1                    ; print the ?EXTRA IGNORED message
+                jmp LB99C
+LB0E7           rts
+LB0E8           fcc '?EXTRA IGNORED'
+                fcb 0x0d,0x00
+; NEXT command
+NEXT            bne LB0FE                       ; brif argument given
+                ldx ZERO                        ; set to NULL descriptor pointer
+                bra LB101                       ; go process "any index will do"
+LB0FE           jsr LB357                       ; evaluate the variable
+LB101           stx VARDES                      ; save the index we're looking for
+                jsr LABF9                       ; search the stack for the matching frame
+                beq LB10C                       ; brif we found a matching frame
+                ldb #0                          ; code for NEXT without FOR
+LB10A           bra LB153                       ; raise the error
+LB10C           tfr x,s                         ; reset the stack to the start of the stack frame
+                leax 3,x                        ; point to the STEP value
+                jsr LBC14                       ; copy the value to FPA0
+                lda 8,s                         ; get step direction
+                sta FP0SGN                      ; save as sign of FPA0
+                ldx VARDES                      ; point to index variable
+                jsr LB9C2                       ; add (X) to FPA0 (steps the index)
+                jsr LBC33                       ; save new value to the index
+                leax 9,s                        ; point to terminal condition
+                jsr LBC96                       ; compare the new index value with the terminal
+                subb 8,s                        ; set B=0 if we hit the terminal (or passed it with nonzero step)
+                beq LB134                       ; brif loop complete
+                ldx 14,s                        ; restore line number and input pointer to start of loop
+                stx CURLIN
+                ldx 16,s
+                stx CHARAD
+LB131           jmp LAD9E                       ; return to interpretation loop
+LB134           leas 18,s                       ; remove the frame from the stack
+                jsr GETCCH                      ; get character after the index
+                cmpa #',                        ; do we have more indexes?
+                bne LB131                       ; brif not
+                jsr GETNCH                      ; munch the comma
+                bsr LB0FE                       ; go process another value
+; NOTE: despite the BSR on the preceding line, execution of the NEXT command will not fall
+; through this point, nor will the stack grow without bound. The BSR is required to make sure
+; the stack is aligned properly for the stack search for the subsequent index variable.
+;
+; The following is the expression evaluation system. It has various entry points including for type
+; checking. This really consists of two co-routines, one for evaluating operators and one for individual
+; terms. However, it does some rather confusing stack operations so it's a bit difficult to follow
+; just how some of this works.
+;
+; Evaluate numeric expression
+LB141           bsr LB156                       ; evaluate an expression
+; TM error if string
+LB143           andcc #0xfe                     ; clear C to indicate we want a number
+                skip2keepc
+; TM error if numeric
+LB146           orcc #1                         ; set C to indicate we want a string
+; TM error if: C = 1 and number, OR C = 0 and string
+LB148           tst VALTYP                      ; set flags on the current value to (doesn't change C)
+                bcs LB14F                       ; brif we want a string
+                bpl LB0E7                       ; brif we have a number (we want a number)
+                skip2
+LB14F           bmi LB0E7                       ; brif we have a string (we want a string)
+LB151           ldb #12*2                       ; code for TM error
+LB153           jmp LAC46                       ; raise the error
+; The general expression evaluation entry point
+LB156           bsr LB1C6                       ; back up input pointer to compensate for GETNCH below
+LB158           clra                            ; set operator precedence to 0 (no previous operator)
+                skip2
+LB15A           pshs b                          ; save relational operator flags
+                pshs a                          ; save previous operator precedence
+                ldb #1                          ; make sure we aren't overflowing the stack
+                jsr LAC33
+                jsr LB223                       ; go evaluate the first term
+LB166           clr TRELFL                      ; flag no relational operators seen
+LB168           jsr GETCCH                      ; get input character
+LB16A           suba #0xb2                      ; token for > (lowest relational operator)
+                blo LB181                       ; brif below relational operators
+                cmpa #3                         ; there are three relational operators, is it one?
+                bhs LB181                       ; brif not
+                cmpa #1                         ; set C if >
+                rola                            ; shift C into bit 0 (4: <, 2: =, 1: >)
+                eora TRELFL                     ; flip the bit for this operator
+                cmpa TRELFL                     ; did the result get lower?
+                blo LB1DF                       ; brif so - we have a duplicate so raise an error
+                sta TRELFL                      ; save new operator flags
+                jsr GETNCH                      ; munch the operator
+                bra LB16A                       ; go see if we have another one
+LB181           ldb TRELFL                      ; do we have a relational comparison?
+                bne LB1B8                       ; brif so
+                lbcc LB1F4                      ; brif the token is above the relational operators
+                adda #7                         ; put operators starting at 0
+                bhs LB1F4                       ; brif we're above 0 - it's an operator, Jim
+                adca VALTYP                     ; add carry, numeric flag, and modified token number
+                lbeq LB60F                      ; brif we have string and A is + - do concatenation
+                adca #-1                        ; restore operator number
+                pshs a                          ; save operator number
+                asla                            ; times 2
+                adda ,s+                        ; and times 3 (3 bytes per entry)
+                ldx #LAA51                      ; point to operator pecedence and jump table
+                leax a,x                        ; point to correct entry
+LB19F           puls a                          ; get precedence of previous operation
+                cmpa ,x                         ; is hit higher (or same) than the current one?
+                bhs LB1FA                       ; brif so - we need to process that operator
+                bsr LB143                       ; TM error if we have a string
+LB1A7           pshs a                          ; save previous operation precedence
+                bsr LB1D4                       ; push operator handler address and FPA0 onto the stack
+                ldx RELPTR                      ; get pointer to arithmetic/logical table entry for last operation
+                puls a                          ; get back precedence
+                bne LB1CE                       ; brif we had a relational operation
+                tsta                            ; check precedence of previous operation
+                lbeq LB220                      ; brif end of expression
+                bra LB203                       ; go handle operation
+LB1B8           asl VALTYP                      ; get type of value to C
+                rolb                            ; mix it in to bit 0 of relational flags
+                bsr LB1C6                       ; back up input pointer
+                ldx #LB1CB                      ; point to relational operator precedence and handler
+                stb TRELFL                      ; save relational comparison flags
+                clr VALTYP                      ; result will be numeric
+                bra LB19F                       ; to process the operation
+LB1C6           ldx CHARAD                      ; get input pointer
+                jmp LAEBB                       ; back it up one and put it back
+LB1CB           fcb 0x64                        ; precedence of relational comparison
+                fdb LB2F4                       ; handler address for relational comparison
+LB1CE           cmpa ,x                         ; is last done operation higher (or same) precedence?
+                bhs LB203                       ; brif so - go process it
+                bra LB1A7                       ; go push things on the stack and process this operation otherwise
+LB1D4           ldd 1,x                         ; get address of operatorroutine
+                pshs d                          ; save it
+                bsr LB1E2                       ; push FPA0 onto the stack
+                ldb TRELFL                      ; get back relational operator flags
+                lbra LB15A                      ; go evaluate another operation
+LB1DF           jmp LB277                       ; raise a syntax error
+LB1E2           ldb FP0SGN                      ; get sign of FPA0
+                lda ,x                          ; get precedence of this operation
+LB1E6           puls y                          ; get back original caller
+                pshs b                          ; save sign
+LB1EA           ldb FP0EXP                      ; get exponent
+                ldx FPA0                        ; get mantissa
+                ldu FPA0+2
+                pshs u,x,b                      ; stow FPA0 sign and mantissa
+                jmp ,y                          ; return to caller
+LB1F4           ldx ZERO                        ; point to dummy value
+                lda ,s+                         ; get precedence of previous operation (and set flags)
+                beq LB220                       ; brif end of expression
+LB1FA           cmpa #0x64                      ; relational operation?
+                beq LB201                       ; brif so
+                jsr LB143                       ; type mismatch if string
+LB201           stx RELPTR                      ; save pointer to operator routine
+LB203           puls b                          ; get relational flags
+                cmpa #0x5a                      ; NOT operation?
+                beq LB222                       ; brif so (it was unary)
+                cmpa #0x7d                      ; unary negation?
+                beq LB222                       ; brif so
+                lsrb                            ; shift value type flag out of relational flags
+                stb RELFLG                      ; save relational operator flag
+                puls a,x,u                      ; get FP value back
+                sta FP1EXP                      ; set exponent and mantissa in FPA1
+                stx FPA1
+                stu FPA1+2
+                puls b                          ; and the sign
+                stb FP1SGN
+                eorb FP0SGN                     ; set RESSGN if the two operand signs differ
+                stb RESSGN
+LB220           ldb FP0EXP                      ; get exponent of FPA0
+LB222           rts                             ; return or transfer control to operator handler routine
+LB223           jsr RVEC15                      ; do the RAM hook dance
+                clr VALTYP                      ; set type to numeric
+LB228           jsr GETNCH                      ; get first character in the term
+                bcc LB22F                       ; brif not numeric
+LB22C           jmp LBD12                       ; parse a number (and return)
+LB22F           jsr LB3A2                       ; set carry if not alpha
+                bcc LB284                       ; brif alpha character (variable)
+                cmpa #'.                        ; decimal point?
+                beq LB22C                       ; brif so - evaluate number
+                cmpa #0xac                      ; minus?
+                beq LB27C                       ; brif so - process unary negation
+                cmpa #0xab                      ; plus?
+                beq LB228                       ; brif so - ignore unary "posation"
+                cmpa #'"                        ; string delimiter?
+                bne LB24E                       ; brif not
+LB244           ldx CHARAD                      ; get input pointer
+                jsr LB518                       ; go parse the string
+LB249           ldx COEFPT                      ; get address of end of string
+                stx CHARAD                      ; move input pointer past string
+                rts
+LB24E           cmpa #0xa8                      ; NOT?
+                bne LB25F                       ; brif not
+                lda #0x5a                       ; precedence of unary NOT
+                jsr LB15A                       ; process the operand of NOT
+                jsr INTCNV                      ; convert to integer in D
+                coma                            ; do a bitwise complement
+                comb
+                jmp GIVABF                      ; resturn the result
+LB25F           inca                            ; is it a function token?
+                beq LB290                       ; brif so
+LB262           bsr LB26A                       ; only other legal thing must be a (expr)
+                jsr LB156                       ; evaluate parentheticized expression
+LB267           ldb #')                         ; force a )
+                skip2
+LB26A           ldb #'(                         ; force a (
+                skip2
+LB26D           ldb #',                         ; force a ,
+LB26F           cmpb [CHARAD]                   ; does character match?
+                bne LB277                       ; brif not
+                jmp GETNCH                      ; each the character and return the next
+LB277           ldb #2*1                        ; raise syntax error
+                jmp LAC46
+LB27C           lda #0x7d                       ; unary negation precedence
+                jsr LB15A                       ; evaluate argument
+                jmp LBEE9                       ; flip sign of FPA0 and return
+LB284           jsr LB357                       ; evaluate variable
+LB287           stx FPA0+2                      ; save descriptor address in FPA0
+                lda VALTYP                      ; test variable type
+                bne LB222                       ; brif string - we're done
+                jmp LBC14                       ; copy FP number from (X) into FPA0
+LB290           jsr GETNCH                      ; get the actual token number
+                tfr a,b                         ; save it (for offsetting X)
+                lslb                            ; two bytes per jump table entry (and lose high bit)
+                jsr GETNCH                      ; eat the token byte
+                cmpb #2*19                      ; is it a valid token for Color Basic?
+                bls LB29F                       ; brif so
+                jmp [COMVEC+18]                 ; transfer control to Extended Basic if not
+LB29F           pshs b                          ; save jump table offset
+                cmpb #2*14                      ; does it expect a numeric argument?
+                blo LB2C7                       ; brif so
+                cmpb #2*18                      ; does it need no arguments?
+                bhs LB2C9                       ; brif so
+                bsr LB26A                       ; force a (
+                lda ,s                          ; get token value
+                cmpa #2*17                      ; is it POINT?
+                bhs LB2C9                       ; brif so
+                jsr LB156                       ; evaluate first argument string
+                bsr LB26D                       ; force a comma
+                jsr LB146                       ; TM error if string
+                puls a                          ; get token value
+                ldu FPA0+2                      ; get string descriptor
+                pshs u,a                        ; now we save the first string argument and the token value
+                jsr LB70B                       ; evaluate first numeric argument
+                puls a                          ; get back token value
+                pshs b,a                        ; save second argument and token value
+                fcb 0x8e                        ; opcode of LDX immediate (skips two bytes)
+LB2C7           bsr LB262                       ; force a (
+LB2C9           puls b                          ; get offset
+                ldx COMVEC+8                    ; get jump table pointer
+                abx                             ; add offset into table
+                jsr [,x]                        ; go process function
+                jmp LB143                       ; make sure result is numeric
+; operator OR
+LB2D4           skip1lda                        ; set flag to nonzero to signal OR
+; operator AND
+LB2D5           clra                            ; set flag to zero to signal AND
+                sta TMPLOC                      ; save AND/OR flag
+                jsr INTCNV                      ; convert second argument to intenger
+                std CHARAC                      ; save it
+                jsr LBC4A                       ; move first argument to FPA0
+                jsr INTCNV                      ; convert first argument to integer
+                tst TMPLOC                      ; is it AND or OR?
+                bne LB2ED                       ; brif OR
+                anda CHARAC                     ; do the bitwise AND
+                andb ENDCHR
+                bra LB2F1                       ; finish up
+LB2ED           ora CHARAC                      ; do the bitwise OR
+                orb ENDCHR
+LB2F1           jmp GIVABF                      ; return integer result
+; relational comparision operators
+LB2F4           jsr LB148                       ; TM error if type mismatch
+                BNE LB309                       ; brif we have a string comparison
+                lda FP1SGN                      ; pack FPA1
+                ora #0x7f
+                anda FPA1
+                sta FPA1
+                ldx #FP1EXP                     ; point to packed FPA1
+                jsr LBC96                       ; compare FPA0 to FPA1
+                bra LB33F                       ; handle truth comparison
+LB309           clr VALTYP                      ; the result of a comparison is always a number
+                dec TRELFL                      ; remove the string flag from the comparison data
+                jsr LB657                       ; get string details for second argument
+                stb STRDES                      ; save them in the temporary string descriptor
+                stx STRDES+2
+                ldx FPA1+2                      ; get pointer to first argument descriptor
+                jsr LB659                       ; get string details for second argument
+                lda STRDES                      ; get length of second argument
+                pshs b                          ; save length of first argument
+                suba ,s+                        ; now A is the difference in string lengths
+                beq LB328                       ; brif string lengths are equal
+                lda #1                          ; flag for second argument is longer than first
+                bcc LB328                       ; brif second string is longer than first
+                ldb STRDES                      ; get length of second string (shorter)
+                nega                            ; invert default comparison result
+LB328           sta FP0SGN                      ; save default truth flag
+                ldu STRDES+2                    ; get pointer to start of second string
+                incb                            ; compensate for DECB
+LB32D           decb                            ; have we compared everything?
+                bne LB334                       ; brif not
+                ldb FP0SGN                      ; get default truth value
+                bra LB33F                       ; decide comparison truth
+LB334           lda ,x+                         ; get byte from first argument
+                cmpa ,u+                        ; compare with second argument
+                beq LB32D                       ; brif equal - keep comparing
+                ldb #0xff                       ; negative if first string is > second
+                bcc LB33F                       ; brif string A > string B
+                negb                            ; invert result
+LB33F           addb #1                         ; convert to 0,1,2
+                rolb                            ; shift left - now it's 4,2,1 for <, =, >
+                andb RELFLG                     ; keep only the truth we care about
+                beq LB348                       ; brif no matching bits - it's false
+                ldb #0xff                       ; set true
+LB348           jmp LBC7C                       ; convert result to FP and return it
+; DIM command
+LB34B           jsr LB26D                       ; make sure there's a comma between variables
+DIM             ldb #1                          ; flag that we're dimensioning
+                bsr LB35A                       ; go allocate the variable
+                jsr GETCCH                      ; are we done?
+                bne LB34B                       ; brif not
+                rts
+; This routine parses a variable. For scalars, it will return a NULL string or 0 value number
+; if it is called from "evaluate term". Otherwise, it allocates the variable. For arrays, it will
+; allocate a default sized array if dimensioning is not underway and then attempt to look up
+; the requested coordinates in that array. Otherwise, it will allocate an array based on the
+; specified dimension values.
+LB357           clrb                            ; flag that we're not setting up an array
+                jsr GETCCH
+LB35A           stb DIMFLG                      ; save dimensioning flag
+                sta VARNAM                      ; save first character of variable name
+                jsr GETCCH                      ; get input character (why? we already have it)
+                bsr LB3A2                       ; set carry if not alpha
+                lbcs LB277                      ; brif our variable doesn't start with a letter
+                clrb                            ; default second variable character to NUL
+                stb VALTYP                      ; set value type to numeric
+                jsr GETNCH                      ; get second character
+                bcs LB371                       ; brif numeric - numbers are allowed
+                bsr LB3A2                       ; set carry if not alpha
+                bcs LB37B                       ; brif not alpha
+LB371           tfr a,b                         ; save set second character of variable name
+LB373           jsr GETNCH                      ; get an input character
+                bcs LB373                       ; brif numeric - still in variable name
+                bsr LB3A2                       ; set carry if not alpha
+                bcc LB373                       ; brif alpha - still in variable name
+LB37B           cmpa #'$                        ; do we have the string sigil?
+                bne LB385                       ; brif not
+                com VALTYP                      ; set value type to string
+                addb #0x80                      ; set bit 7 of second variable character to indicate string
+                jsr GETNCH                      ; eat the sigil
+LB385           stb VARNAM+1                    ; save second variable name character
+                ora ARYDIS                      ; merge array disable flag (will set bit 7 of input character if no arrays)
+                suba #'(                        ; do we have a subscript?
+                lbeq LB404                      ; brif so
+                clr ARYDIS                      ; disable the array disable flag - it's single use
+                ldx VARTAB                      ; point to the start of the variable table
+                ldd VARNAM                      ; get variable name
+LB395           cmpx ARYTAB                     ; are we at the top of the variable table?
+                beq LB3AB                       ; brif so
+                cmpd ,x++                       ; does the variable name match (and move pointer to variable data)
+                beq LB3DC                       ; brif so
+                leax 5,x                        ; move to next table entry
+                bra LB395                       ; see if we have a match
+; Set carry if not upper case alpha
+LB3A2           cmpa #'A                        ; set C if less than A
+                bcs LB3AA                       ; brif less than A
+                suba #'Z+1                      ; set C if greater than Z
+                suba #-('Z+1)
+LB3AA           rts
+LB3AB           ldx #ZERO                       ; point to empty location (NULL/0 value)
+                ldu ,s                          ; get caller address
+                cmpu #LB287                     ; coming from "evaluate term"?
+                beq LB3DE                       ; brif so - don't allocate
+                ldd ARYEND                      ; get end of arrays
+                std V43                         ; save as top of source block
+                addd #7                         ; 7 bytes per scalar entry
+                std V41                         ; save as top of destination block
+                ldx ARYTAB                      ; get bottom of arrays
+                stx V47                         ; save as bottom of source block
+                jsr LAC1E                       ; move the arrays up to make a hole
+                ldx V41                         ; get new top of arrays
+                stx ARYEND                      ; set new end of arrays
+                ldx V45                         ; get bottom of destination block
+                stx ARYTAB                      ; set as new start of arrays
+                ldx V47                         ; get old end of variables
+                ldd VARNAM                      ; get name of variable
+                std ,x++                        ; set variable name and advance X to the value
+                clra                            ; zero out the variable value
+                clrb
+                std ,x
+                std 2,x
+                sta 4,x
+LB3DC           stx VARPTR                      ; save descriptor address of return value
+LB3DE           rts
+; Various integer conversion routines
+LB3DF           fcb 0x90,0x80,0x00,0x00,0x00    ; FP constant -32768
+LB3E4           jsr GETNCH                      ; fetch input character
+LB3E6           jsr LB141                       ; evaluate numeric expression
+LB3E9           lda FP0SGN                      ; get sign of value
+                bmi LB44A                       ; brif negative (raise FC error)
+INTCNV          lda FP0EXP                      ; get exponent
+                cmpa #0x90                      ; is it within the range for a 16 bit integer?
+                blo LB3FE                       ; brif smaller than 32768
+                ldx #LB3DF                      ; point to -32678 constant
+                jsr LBC96                       ; is FPA0 equal to -32768?
+                bne LB44A                       ; brif not - magnitude is too far negative
+LB3FE           jsr LBCC8                       ; move binary point to the right of FPA0 and correct sign
+                ldd FPA0+2                      ; get the resulting integer
+                rts
+LB404           ldb DIMFLG                      ; get dimensioning flag
+                lda VALTYP                      ; get type of variable
+                pshs b,a                        ; save them (to avoid issues while evaluating dimension values)
+                clrb                            ; reset dimension counter
+LB40A           ldx VARNAM                      ; get variable name
+                pshs x,b                        ; save dimension counter and variable name
+                bsr LB3E4                       ; evaluate a dimension value (and skip either ( or ,)
+                puls b,x,y                      ; get variable name, dimension counter, and dimensioning/type flag
+                stx VARNAM                      ; restore variable name
+                ldu FPA0+2                      ; get dimension size/index
+                pshs u,y                        ; save dimension size and dimensioning/type flag
+                incb                            ; bump dimension counter
+                jsr GETCCH                      ; get what's after the dimension count
+                cmpa #',                        ; do we have another dimension?
+                beq LB40A                       ; brif so - parse it
+                stb TMPLOC                      ; save dimension counter
+                jsr LB267                       ; make sure we have a )
+                puls a,b                        ; get back variable type and dimensioning flag
+                sta VALTYP                      ; restore variable type
+                stb DIMFLG                      ; restore dimensioning flag
+                ldx ARYTAB                      ; get start of arrays
+LB42A           cmpx ARYEND                     ; are we at the end of the array table
+                beq LB44F                       ; brif so
+                ldd VARNAM                      ; get variable name
+                cmpd ,x                         ; does it match?
+                beq LB43B                       ; brif so
+                ldd 2,x                         ; get length of this array
+                leax d,x                        ; move to next array
+                bra LB42A                       ; go check another entry
+LB43B           ldb #2*9                        ; code for redimensioned array error
+                lda DIMFLG                      ; are we dimensioning?
+                bne LB44C                       ; brif so - raise error
+                ldb TMPLOC                      ; get number of dimensions given
+                cmpb 4,x                        ; does it match?
+                beq LB4A0                       ; brif so
+LB447           ldb #8*2                        ; raise "bad subscript"
+                skip2
+LB44A           ldb #4*2                        ; raise "illegal function call"
+LB44C           jmp LAC46                       ; raise error
+LB44F           ldd #5                          ; 5 bytes per array entry
+                std COEFPT                      ; initialize array size to entry size
+                ldd VARNAM                      ; get variable name
+                std ,x                          ; set array name
+                ldb TMPLOC                      ; get dimension count
+                stb 4,x                         ; set dimension count
+                jsr LAC33                       ; make sure we haven't overflowed memory
+                stx V41                         ; save array descriptor address
+LB461           ldb #11                         ; default dimension value (zero-based, gives max index of 10)
+                clra                            ; zero extend (??? why not LDD above?)
+                tst DIMFLG                      ; are we dimensioning?
+                beq LB46D                       ; brif not
+                puls a,b                        ; get dimension size
+                addd #1                         ; account for zero based indexing
+LB46D           std 5,x                         ; save dimension size
+                bsr LB4CE                       ; multiply by accumulated array size
+                std COEFPT                      ; save new array size
+                leax 2,x                        ; move to next dimension
+                dec TMPLOC                      ; have we done all dimensions?
+                bne LB461                       ; brif not
+                stx TEMPTR                      ; save end of array descriptor (minus 5)
+                addd TEMPTR                     ; add total size of array to address of descriptor
+                lbcs LAC44                      ; brif it overflows memory
+                tfr d,x                         ; save end of array for later
+                jsr LAC37                       ; does array fit in memory?
+                subd #STKBUF-5                  ; subtract out the "stack fudge factor" but add 5 to the result
+                std ARYEND                      ; save new end of arrays
+                clra                            ; set up for clearing
+LB48C           leax -1,x                       ; move back one
+                sta 5,x                         ; blank out a byte in the array data
+                cmpx TEMPTR                     ; have we reached the array header?
+                bne LB48C                       ; brif not
+                ldx V41                         ; get address of start of descriptor
+                lda ARYEND                      ; get MSB of end of array back (B still has LSB)
+                subd V41                        ; subtract start of descriptor
+                std 2,x                         ; save length of array in array header
+                lda DIMFLG                      ; are we dimensioning?
+                bne LB4CD                       ; brif so - we're done
+LB4A0           ldb 4,x                         ; get number of dimensions
+                stb TMPLOC                      ; initialize counter
+                clra                            ; initialize accumulated offset
+                clrb
+LB4A6           std COEFPT                      ; save accumulated offset
+                puls a,b                        ; get desired index
+                std FPA0+2                      ; save it
+                cmpd 5,x                        ; is it in range for this dimension?
+                bhs LB4EB                       ; brif not
+                ldu COEFPT                      ; get accumulated offset
+                beq LB4B9                       ; brif first dimension
+                bsr LB4CE                       ; multiply accumulated offset by dimension length
+                addd FPA0+2                     ; add in offset into this dimension
+LB4B9           leax 2,x                        ; move to next dimension in header
+                dec TMPLOC                      ; done all dimensions?
+                bne LB4A6                       ; brif not
+                std ,--s                        ; save D for multiply by 5 (should be pshs d)
+                aslb                            ; times 2
+                rola
+                aslb                            ; times 4
+                rola
+                addd ,s++                       ; times 5
+                leax d,x                        ; add in offset from start of array data
+                leax 5,x                        ; offset to end of header
+                stx VARPTR                      ; save pointer to element data
+LB4CD           rts
+; multiply 16 bit number at 5,x by the 16 bit number in COEFPT; return result in D; BS error if carry
+LB4CE           lda #16                         ; 16 shifts to do a multiply
+                sta V45                         ; save shift counter
+                ldd 5,x                         ; get multiplier
+                std BOTSTK                      ; save it
+                clra                            ; zero out product
+                clrb
+LB4D8           aslb                            ; shift product left
+                rola
+                bcs LB4EB                       ; brif we have a carry
+                asl COEFPT+1                    ; shift other factor left
+                rol COEFPT
+                bcc LB4E6                       ; brif no carry - this bit position is 0
+                addd BOTSTK                     ; add in multiplier at this bit position
+                bcs LB4EB                       ; brif carry - do an error
+LB4E6           dec V45                         ; have we done all 16 bits?
+                bne LB4D8                       ; brif not
+                rts
+LB4EB           jmp LB447                       ; raise a BS error
+; MEM function
+; BUG: this doesn't account for the STKBUF fudge factor used for memory availability checks
+MEM             tfr s,d                         ; get stack pointer where we can do math
+                subd ARYEND                     ; calculate number of bytes between the stack and the top of arrays
+                skip1                           ; return result
+; Convert unsigned value in B to FP
+LB4F3           clra                            ; zero extend
+; Convert signed value in D to FP
+GIVABF          clr VALTYP                      ; set value type to numeric
+                std FPA0                        ; save value in FPA0
+                ldb #0x90                       ; exponent for top two bytes to be an integer
+                jmp LBC82                       ; finish conversion to integer
+; STR$ function
+STR             jsr LB143                       ; make sure we have a number
+                ldu #STRBUF+2                   ; convert FP number to string in temporary string buffer
+                jsr LBDDC
+                leas 2,s                        ; don't return to the function evaluator (which will do a numeric type check)
+                ldx #STRBUF+1                   ; point to number string
+                bra LB518                       ; to stash the string in string space and return to the "evaluate term" caller
+; Reserve B bytes of string space. Return start in X and FRESPC
+LB50D           stx V4D                         ; save X somewhere in case the caller needs it
+LB50F           bsr LB56D                       ; allocate string space
+LB511           stx STRDES+2                    ; save pointer to allocated space in the temporary descriptor
+                stb STRDES                      ; save length in the temporary descriptor
+                rts
+LB516           leax -1,x                       ; move pointer back one (to compensate for the increment below)
+; Scan from X until either NUL or one of the string terminators is found
+LB518           lda #'"                         ; set terminator to be string delimiter
+LB51A           sta CHARAC                      ; set both delimiters
+                sta ENDCHR
+LB51E           leax 1,x                        ; move to next character        
+                stx RESSGN                      ; save start of string
+                stx STRDES+2                    ; save start of string in the temporary string descriptor
+                ldb #-1                         ; initialize length counter to -1 (compensate for initial INCB)
+LB526           incb                            ; bump string length
+                lda ,x+                         ; get character from string
+                beq LB537                       ; brif end of line
+                cmpa CHARAC                     ; is it delimiter #1?
+                beq LB533                       ; brif so
+                cmpa ENDCHR                     ; is it delimiter #2?
+                bne LB526                       ; brif not - keep scanning
+LB533           cmpa #'"                        ; string delimiter?
+                beq LB539                       ; brif so - don't move pointer back
+LB537           leax -1,x                       ; move pointer back (so we don't consume the delimiter)
+LB539           stx COEFPT                      ; save end of string address
+                stb STRDES                      ; save string length
+                ldu RESSGN                      ; get start of string
+                cmpu #STRBUF+2                  ; is it at the start of the string buffer?
+                bhi LB54C                       ; brif so - don't copy it to string space
+                bsr LB50D                       ; allocate string space
+                ldx RESSGN                      ; point to beginning of the string
+                jsr LB645                       ; copy string data (B bytes) from (X) to (FRESPC)
+; Put temporary string descriptor on the string stack
+LB54C           ldx TEMPPT                      ; get top of string stack
+                cmpx #CFNBUF                    ; is the string stack full?
+                bne LB558                       ; brif not
+                ldb #15*2                       ; code for "string formula too complex"
+LB555           jmp LAC46                       ; raise error
+LB558           lda STRDES                      ; get string length
+                sta 0,x                         ; save it in the string stack descriptor
+                ldd STRDES+2                    ; get string data pointer
+                std 2,x                         ; save in string stack descriptor
+                lda #0xff                       ; set value type to string
+                sta VALTYP
+                stx LASTPT                      ; set pointer to last used entry on the string stack
+                stx FPA0+2                      ; set pointer to descriptor in the current evaluation value
+                leax 5,x                        ; advance string stack pointer
+                stx TEMPPT
+                rts
+; Reserve B bytes in string space. If there isn't enough space, try compacting string space and
+; then try the allocation again. If it still fails, raise OS error.
+LB56D           clr GARBFL                      ; flag that compaction not yet done
+LB56F           clra                            ; zero extend the length
+                pshs d                          ; save requested string length
+                ldd STRTAB                      ; get current bottom of strings
+                subd ,s+                        ; calculate new bottom of strings and remove zero extension
+                cmpd FRETOP                     ; does the string fit?
+                blo LB585                       ; brif not - try compaction
+                std STRTAB                      ; save new bottom of strings
+                ldx STRTAB                      ; get bottom of strings
+                leax 1,x                        ; now X points to the real start of the allocated space
+                stx FRESPC                      ; save the string pointer
+                puls b,pc                       ; restore length and return
+LB585           ldb #2*13                       ; code for out of string space
+                com GARBFL                      ; have we compacted string space yet?
+                beq LB555                       ; brif so - raise error
+                bsr LB591                       ; compact string space
+                puls b                          ; get back string length
+                bra LB56F                       ; go try allocation again
+; Compact string space
+; This is an O(n^2) algorithm. It first searches all extant strings for the highest address data pointer
+; that hasn't already been moved into the freshly compacted string space. If then moves that string data
+; up to the highest address it can go to. It repeats this process over and over until it finds no string
+; that isn't already in the compacted space. While doing this, it has to search all strings on the string
+; stack (this is why the string stack is needed - so we can track anonymous strings), all scalar string
+; variables, and *every* entry in every string array.
+LB591           ldx MEMSIZ                      ; get to of string space
+LB593           stx STRTAB                      ; save top of uncompacted stringspace
+                clra                            ; zero out D and reset pointer to discovered variable to NULL
+                clrb
+                std V4B
+                ldx FRETOP                      ; point to bottom of string space
+                stx V47                         ; save as lowest match address (match will be higher)
+                ldx #STRSTK                     ; point to start of string stack
+LB5A0           cmpx TEMPPT                     ; are we at the top of the string stack?
+                beq LB5A8                       ; brif so - done with the string stack
+                bsr LB5D8                       ; check for string in uncompacted space (and advance pointer)
+                bra LB5A0                       ; check another on the string stack
+LB5A8           ldx VARTAB                      ; point to start of scalar variables
+LB5AA           cmpx ARYTAB                     ; end of scalars?
+                beq LB5B2                       ; brif so
+                bsr LB5D2                       ; check for string in uncompacted space and advance pointer
+                bra LB5AA                       ; check another variable
+LB5B2           stx V41                         ; save address of end of variables (address of first array)
+LB5B4           ldx V41                         ; get start of the next array
+LB5B6           cmpx ARYEND                     ; end of arrays?
+                beq LB5EF                       ; brif so
+                ldd 2,x                         ; get length of array
+                addd V41                        ; add to start of array
+                std V41                         ; save address of next array
+                lda 1,x                         ; get second character of variable name
+                bpl LB5B4                       ; brif numeric
+                ldb 4,x                         ; get number of dimensions
+                aslb                            ; two bytes per dimension size
+                addb #5                         ; add in fixed overhead for array descriptor
+                abx                             ; now X points to first array element
+LB5CA           cmpx V41                        ; at the start of the next array?
+                beq LB5B6                       ; brif so - go handle another array
+                bsr LB5D8                       ; check for string in uncompacted space (and advance pointer)
+                bra LB5CA                       ; process next array element
+LB5D2           lda 1,x                         ; get second character of variable name
+                leax 2,x                        ; move to variable data
+                bpl LB5EC                       ; brif numeric
+LB5D8           ldb ,x                          ; get length of string
+                beq LB5EC                       ; brif NULL - don't need to check data pointer
+                ldd 2,x                         ; get data pointer
+                cmpd STRTAB                     ; is it in compacted string space?
+                bhi LB5EC                       ; brif so
+                cmpd V47                        ; is it better match than previous best?
+                bls LB5EC                       ; brif not
+                stx V4B                         ; save descriptor address of best match
+                std V47                         ; save new best data pointer match
+LB5EC           leax 5,x                        ; move to next descriptor
+LB5EE           rts
+LB5EF           ldx V4B                         ; get descriptor address of the matched string
+                beq LB5EE                       ; brif we didn't find one - we're done
+                clra                            ; zero extend length
+                ldb ,x                          ; get string length
+                decb                            ; subtract one (we won't have a NULL string here)
+                addd V47                        ; now D points to the address of the end of the string data
+                std V43                         ; save as top address of move
+                ldx STRTAB                      ; set top of uncompacted space as destination
+                stx V41
+                jsr LAC20                       ; move string to top of uncompactedspace
+                ldx V4B                         ; point to string descriptor
+                ldd V45                         ; get new data pointer address
+                std 2,x                         ; update descriptor
+                ldx V45                         ; get bottom of copy destination
+                leax -1,x                       ; move back below it
+                jmp LB593                       ; go search for another string to move (and set new bottom of string space)
+; Concatenate two strings. We come here directly from the operator handler rather than via a JSR.
+LB60F           ldd FPA0+2                      ; get string descriptor for the first string
+                pshs d                          ; save it
+                jsr LB223                       ; evaluate a second string (concatenation is left associative)
+                jsr LB146                       ; make sure we have a string
+                puls x                          ; get back first string descriptor
+                stx RESSGN                      ; save it
+                ldb ,x                          ; get length of first string
+                ldx FPA0+2                      ; get pointer to second string
+                addb ,x                         ; add length of second string
+                bcc LB62A                       ; brif combined length is OK
+                ldb #2*14                       ; raise string too long error
+                jmp LAC46
+LB62A           jsr LB50D                       ; reserve room for new string
+                ldx RESSGN                      ; get descriptor address of the first string
+                ldb ,x                          ; get length of first string
+                bsr LB643                       ; copy it to string space
+                ldx V4D                         ; get descriptor address of second string
+                bsr LB659                       ; get string details for second string
+                bsr LB645                       ; copy second string into new string space
+                ldx RESSGN                      ; get pointer to first string
+                bsr LB659                       ; remove it from the string stack if possible
+                jsr LB54C                       ; put new string on the string stack
+                jmp LB168                       ; return to expression evaluator
+; Copy B bytes to space pointed to by FRESPC
+LB643           ldx 2,x                         ; get source address from string descriptor
+LB645           ldu FRESPC                      ; get destination address
+                incb                            ; compensate for decb
+                bra LB64E                       ; do the copy
+LB64A           lda ,x+                         ; copy a byte
+                sta ,u+
+LB64E           decb                            ; done yet?
+                bne LB64A                       ; brif not
+                stu FRESPC                      ; save destination pointer
+                rts
+; Fetch details of string in FPA0+2 and remove from the string stack if possible
+LB654           jsr LB146                       ; make sure we have a string
+LB657           ldx FPA0+2                      ; get descriptor pointer
+LB659           ldb ,x                          ; get length of string
+                bsr LB675                       ; see if it's at the top of the string stack and remove it if so
+                bne LB672                       ; brif not removed
+                ldx 5+2,x                       ; get start address of string just removed
+                leax -1,x                       ; move pointer down 1
+                cmpx STRTAB                     ; is it at the bottom of string space?
+                bne LB66F                       ; brif not
+                pshs b                          ; save length
+                addd STRTAB                     ; add length to start of strings (A was cleared previously)
+                std STRTAB                      ; save new string space start (deallocated space for this string)
+                puls b                          ; get back string length
+LB66F           leax 1,x                        ; restore pointer to pointing at the actual string data
+                rts
+LB672           ldx 2,x                         ; get data pointer for the string
+                rts
+; Remove string pointed to by X from the string stack if it is at the top of the stack; return with
+; A clear and Z set if string removed
+LB675           cmpx LASTPT                     ; is it at the top of the string stack?
+                bne LB680                       ; brif not - do nothing
+                stx TEMPPT                      ; save new top of stack
+                leax -5,x                       ; move the "last" pointer back as well
+                stx LASTPT
+                clra                            ; flag string removed
+LB680           rts
+; LEN function
+LEN             bsr LB686                       ; get string details
+LB683           jmp LB4F3                       ; return unsigned length in B
+LB686           bsr LB654                       ; get string details and remove from string stack
+                clr VALTYP                      ; set value type to numeric
+                tstb                            ; set flags according to length
+                rts
+; CHR$ function
+CHR             jsr LB70E                       ; get 8 bit unsigned integer to B
+LB68F           ldb #1                          ; allocate a one byte string
+                jsr LB56D
+                lda FPA0+3                      ; get character code
+                jsr LB511                       ; save reserved string details in temp descriptor
+                sta ,x                          ; put character in string
+LB69B           leas 2,s                        ; don't go back to function handler - avoid numeric type check
+LB69D           jmp LB54C                       ; return temporary string on string stack
+; ASC function
+ASC             bsr LB6A4                       ; get first character of argument
+                bra LB683                       ; return unsigned code in B
+LB6A4           bsr LB686                       ; fetch string details
+                beq LB706                       ; brif NULL string
+                ldb ,x                          ; get character at start of string
+                rts
+; LEFT$ function
+LEFT            bsr LB6F5                       ; get arguments from the stack
+LB6AD           clra                            ; clear pointer offset (set to start of string)
+LB6AE           cmpb ,x                         ; are we asking for more characters than there are in the string?
+                bls LB6B5                       ; brif not
+                ldb ,x                          ; only return the number that are in the string
+                clra                            ; force starting offset to be the start of the string
+LB6B5           pshs b,a                        ; save offset and length
+                jsr LB50F                       ; reserve space in string space
+                ldx V4D                         ; point to original string descriptor
+                bsr LB659                       ; get string details
+                puls b                          ; get string offset
+                abx                             ; now X points to the start of the data to copy
+                puls b                          ; get length of copy
+                jsr LB645                       ; copy the data to the allocated space
+                bra LB69D                       ; return temp string on string stack
+; RIGHT$ function
+RIGHT           bsr LB6F5                       ; get arguments from stack
+                suba ,x                         ; subtract length of original string from desired length
+                nega                            ; now A is offset into old string where we start copying
+                bra LB6AE                       ; go handle everything else
+; MID$ function
+MID             ldb #255                        ; default length is the whole string
+                stb FPA0+3                      ; save it
+                jsr GETCCH                      ; see what we have after offset
+                cmpa #')                        ; end of function?
+                beq LB6DE                       ; brif so - no length
+                jsr LB26D                       ; force a comma
+                bsr LB70B                       ; get length parameter
+LB6DE           bsr LB6F5                       ; get string and offset parameters from the stack
+                beq LB706                       ; brif we have a 0 offset requested (string offsets are 1-based)
+                clrb                            ; clear length counter
+                deca                            ; subtract one from position parameter (we work on 0-based, param is 1-based)
+                cmpa ,x                         ; is start greater than length of string?
+                bhs LB6B5                       ; brif so - return NULL string
+                tfr a,b                         ; save absolute position parameter
+                subb ,x                         ; now B is postition less length
+                negb                            ; now B is amount of string to copy
+                cmpb FPA0+3                     ; is it less than the length requested?
+                bls LB6B5                       ; brif so
+                ldb FPA0+3                      ; set length to the requested length
+                bra LB6B5                       ; go finish up copying the substring
+; Common routine for LEFT$, RIGHT$, MID$ - check for ) and fetch string data and first parameter
+; from the stack. These were evaluated in the function evaluation handler. (It's not clear that doing
+; it that way is actually beneficial. However, this is what the ROM designers did, so here we are.)
+LB6F5           jsr LB267                       ; make sure we have )
+                ldu ,s                          ; get return address - we're going to mess with the stack
+                ldx 5,s                         ; get address of string descriptor
+                stx V4D                         ; save descriptor adddress
+                lda 4,s                         ; get first numeric parameter in both A and B
+                ldb 4,s
+                leas 7,s                        ; clean up stack
+                tfr u,pc                        ; return to original caller
+LB706           jmp LB44A                       ; raise FC error
+; Evaluate an unsigned 8 bit expression to B
+LB709           jsr GETNCH                      ; move to next character
+LB70B           jsr LB141                       ; evaluate a numeric expression
+LB70E           jsr LB3E9                       ; convert to integer in D
+                tsta                            ; are we negative or > 255?
+                bne LB706                       ; brif so - FC error
+                jmp GETCCH                      ; fetch current input character and return
+; VAL function
+VAL             jsr LB686                       ; get string details
+                lbeq LBA39                      ; brif NULL string - return 0
+                ldu CHARAD                      ; get input pointer so we can replace it later
+                stx CHARAD                      ; point interpreter at string data
+                abx                             ; calculate end address of the string
+                lda ,x                          ; get byte after the end of the string
+                pshs u,x,a                      ; save end of string address, input pointer, and character after end of string
+                clr ,x                          ; put a NUL after the string (stops the number interpreter)
+                jsr GETCCH                      ; get input character at start of string
+                jsr LBD12                       ; evaluate numeric expression in string
+                puls a,x,u                      ; get back saved character and pointers
+                sta ,x                          ; restore byte after string
+                stu CHARAD                      ; restore interpeter's input pointer
+                rts
+; Evaluate unsigned expression to BINVAL, then evaluate an unsigned expression to B
+LB734           bsr LB73D                       ; evaluate expression
+                stx BINVAL                      ; save result
+LB738           jsr LB26D                       ; make sure there's a comma
+                bra LB70B                       ; evaluate unsigned expression to B
+; Evaluate unsigned expression in X
+LB73D           jsr LB141                       ; evaluate numeric expression
+LB740           lda FP0SGN                      ; is it negative?
+                bmi LB706                       ; brif so
+                lda FP0EXP                      ; get exponent
+                cmpa #0x90                      ; largest possible exponent for 16 bits
+                bhi LB706                       ; brif too large
+                jsr LBCC8                       ; move binary point to right of FPA0
+                ldx FPA0+2                      ; get resulting unsigned value
+                rts
+; PEEK function
+PEEK            bsr LB740                       ; get address to X
+                ldb ,x                          ; get the value at that address
+                jmp LB4F3                       ; return B as unsigned value
+; POKE function
+POKE            bsr LB734                       ; evaluate address and byte value
+                ldx BINVAL                      ; get address
+                stb ,x                          ; put value there
+                rts
+; LLIST command
+LLIST           ldb #-2                         ; set output device to printer
+                stb DEVNUM
+                jsr GETCCH                      ; reset flags for input character and fall through to LIST
+; LIST command
+LIST            pshs cc                         ; save zero flag (end of statement)
+                jsr LAF67                       ; parse line number
+                jsr LAD01                       ; find address of that line
+                stx LSTTXT                      ; save that address as the start of the list
+                puls cc                         ; get back ent of statement flag
+                beq LB784                       ; brif end of line - list whole program
+                jsr GETCCH                      ; are we at the end of the line (one number)?
+                beq LB789                       ; brif end of line
+                cmpa #0xac                      ; is it "-"?
+                bne LB783                       ; brif not
+                jsr GETNCH                      ; eat the "-"
+                beq LB784                       ; brif no second number - list to end of program
+                jsr LAF67                       ; evaluate the second number
+                beq LB789                       ; brif illegal number
+LB783           rts
+LB784           ldu #0xffff                     ; this will cause listing to do the entire program
+                stu BINVAL
+LB789           leas 2,s                        ; don't return to the caller - we'll jump back to the main loop
+                ldx LSTTXT                      ; get address of line to list
+LB78D           jsr LB95C                       ; do a newline if needed
+                jsr LA549                       ; do a break check
+                ldd ,x                          ; get address of next line
+                bne LB79F                       ; brif not end of program
+LB797           jsr LA42D                       ; close output file
+                clr DEVNUM                      ; reset device to screen
+                jmp LAC73                       ; go back to immediate mode
+LB79F           stx LSTTXT                      ; save new line address
+                ldd 2,x                         ; get line number of this line
+                cmpd BINVAL                     ; is it above the end line?
+                bhi LB797                       ; brif so - return
+                jsr LBDCC                       ; display line number
+                jsr LB9AC                       ; put a space after it
+                ldx LSTTXT                      ; get line address
+                bsr LB7C2                       ; detokenize the line
+                ldx [LSTTXT]                    ; get pointer to next line
+                ldu #LINBUF+1                   ; point to start of detokenized line
+LB7B9           lda ,u+                         ; get byte from detokenized line
+                beq LB78D                       ; brif end of line
+                jsr LB9B1                       ; output character
+                bra LB7B9                       ; handle next character
+; Detokenize a line from (X) to the line input buffer
+LB7C2           jsr RVEC24                      ; do the RAM hook dance
+                leax 4,x                        ; move past next line pointer and line number
+                ldy #LINBUF+1                   ; point to line input buffer (destination)
+LB7CB           lda ,x+                         ; get character from tokenized line
+                beq LB820                       ; brif end of input
+                bmi LB7E6                       ; brif it's a token
+                cmpa #':                        ; colon?
+                bne LB7E2                       ; brif not
+                ldb ,x                          ; get what's after the colon
+                cmpb #0x84                      ; ELSE?
+                beq LB7CB                       ; brif so - suppress the colon
+                cmpb #0x83                      ; '?
+                beq LB7CB                       ; brif so - suppress the colon
+                skip2
+LB7E0           lda #'!                         ; placeholder for unknown token
+LB7E2           bsr LB814                       ; stow output character
+                bra LB7CB                       ; go process another input character
+LB7E6           ldu #COMVEC-10                  ; point to command interptation table
+                cmpa #0xff                      ; is it a function?
+                bne LB7F1                       ; brif not
+                lda ,x+                         ; get function token
+                leau 5,u                        ; shift to the function half of the interpretation tables
+LB7F1           anda #0x7f                      ; remove token bias
+LB7F3           leau 10,u                       ; move to next command/function table
+                tst ,u                          ; is this table active?
+                beq LB7E0                       ; brif not - use place holder
+                suba ,u                         ; subtract number of tokens handled by this table entry
+                bpl LB7F3                       ; brif this token isn't handled here
+                adda ,u                         ; undo extra subtraction
+                ldu 1,u                         ; get reserved word list for this table
+LB801           deca                            ; are we at the right entry?
+                bmi LB80A                       ; brif so
+LB804           tst ,u+                         ; end of entry?
+                bpl LB804                       ; brif not
+                bra LB801                       ; see if we're there yet
+LB80A           lda ,u                          ; get character from wordlist
+                bsr LB814                       ; put character in the buffer
+                tst ,u+                         ; end of word?
+                bpl LB80A                       ; brif not
+                bra LB7CB                       ; go handle another input character
+LB814           cmpy #LINBUF+LBUFMX             ; is there room?
+                bhs LB820                       ; brif not
+                anda #0x7f                      ; lose bit 7
+                sta ,y+                         ; save character in output
+                clr ,y                          ; make sure there's always a NUL terminator
+LB820           rts
+; Tokenize the line that the input pointer is pointing to; put result in the line input buffer; return
+; length in D
+LB821           jsr RVEC23                      ; do the RAM hook dance
+                ldx CHARAD                      ; get input pointer
+                ldu #LINBUF                     ; set destination pointer
+LB829           clr V43                         ; clear alpha string flag
+                clr V44                         ; clear DATA flag
+LB82D           lda ,x+                         ; get input character
+                beq LB852                       ; brif end of input
+                tst V43                         ; are we handling an alphanumeric string?
+                beq LB844                       ; brif not
+                jsr LB3A2                       ; set carry if not alpha
+                bcc LB852                       ; brif alpha
+                cmpa #'0                        ; is it below the digits?
+                blo LB842                       ; brif so
+                cmpa #'9                        ; is it within the digits?
+                bls LB852                       ; brif so
+LB842           clr V43                         ; flag that we're past the alphanumeric string
+LB844           cmpa #0x20                      ; space?
+                beq LB852                       ; brif so - keep it
+                sta V42                         ; save scan delimiter
+                cmpa #'"                        ; string delimiter?
+                beq LB886                       ; brif so - copy until another "
+                tst V44                         ; doing "DATA"?
+                beq LB86B                       ; brif not
+LB852           sta ,u+                         ; put character in output
+                beq LB85C                       ; brif end of input
+                cmpa #':                        ; colon?
+                beq LB829                       ; brif so - reset DATA and alpha string flags
+LB85A           bra LB82D                       ; go process another input character
+LB85C           clr ,u+                         ; put a double NUL at the end
+                clr ,u+
+                tfr u,d                         ; calculate length of result (includes double NUL and an extra two bytes)
+                subd #LINHDR
+                ldx #LINBUF-1                   ; point to one before the output
+                stx CHARAD                      ; set input pointer there
+                rts
+LB86B           cmpa #'?                        ; print abbreviation?
+                bne LB873                       ; brif not
+                lda #0x87                       ; token for PRINT
+                bra LB852                       ; go stash it
+LB873           cmpa #''                        ; REM abbreviation?
+                bne LB88A                       ; brif not
+                ldd #0x3a83                     ; colon plus ' token
+                std ,u++                        ; put it in the output
+LB87C           clr V42                         ; set delimiter to NUL
+LB87E           lda ,x+                         ; get input
+                beq LB852                       ; brif end of line
+                cmpa V42                        ; at the delimiter?
+                beq LB852                       ; brif so
+LB886           sta ,u+                         ; save in output
+                bra LB87E                       ; keep scanning for delimiter
+LB88A           cmpa #'0                        ; is it below digits?
+                blo LB892                       ; brif so
+                cmpa #';+1                      ; is it digit, colon, or semicolon?
+                blo LB852                       ; brif so
+LB892           leax -1,x                       ; move input pointer back one (to point at this input character)
+                pshs u,x                        ; save input and output pointers
+                clr V41                         ; set token type to 0 (command)
+                ldu #COMVEC-10                  ; point to command interpretation table
+LB89B           clr V42                         ; set token counter to 0 (0x80)
+LB89D           leau 10,u                       ; 
+                lda ,u                          ; get number of reserved words
+                beq LB8D4                       ; brif this table isn't active
+                ldy 1,u                         ; point to reserved words list
+LB8A6           ldx ,s                          ; get input pointer
+LB8A8           ldb ,y+                         ; get character from reserved word table
+                subb ,x+                        ; compare with input character
+                beq LB8A8                       ; brif exact match
+                cmpb #0x80                      ; brif it was the last character in word and exact match
+                bne LB8EA                       ; brif not
+                leas 2,s                        ; remove original input pointer from stack
+                puls u                          ; get back output pointer
+                orb V42                         ; create token value (B has 0x80 from above)
+                lda V41                         ; get token type
+                bne LB8C2                       ; brif function
+                cmpb #0x84                      ; is it ELSE?
+                bne LB8C6                       ; brif not
+                lda #':                         ; silently add a colon before ELSE
+LB8C2           std ,u++                        ; put two byte token into output
+                bra LB85A                       ; go handle more input
+LB8C6           stb ,u+                         ; save single byte token
+                cmpb #0x86                      ; DATA?
+                bne LB8CE                       ; brif not
+                inc V44                         ; set DATA flag
+LB8CE           cmpb #0x82                      ; REM?
+                beq LB87C                       ; brif so - skip over rest of line
+LB8D2           bra LB85A                       ; go handle more input
+LB8D4           ldu #COMVEC-5                   ; point to interpretation table, function style
+LB8D7           com V41                         ; invert token flag
+                bne LB89B                       ; brif we haven't already done functions
+                puls x,u                        ; restore input and output pointers
+                lda ,x+                         ; copy first character
+                sta ,u+
+                jsr LB3A2                       ; set C if not alpha
+                bcs LB8D2                       ; brif not alpha - it isn't a variable
+                com V43                         ; set alphanumeric string flag
+                bra LB8D2                       ; process more input
+LB8EA           inc V42                         ; bump token number
+                deca                            ; checked all in this table?
+                beq LB89D                       ; brif so
+                leay -1,y                       ; unconsume last compared character
+LB8F1           ldb ,y+                         ; end of entry?
+                bpl LB8F1                       ; brif not
+                bra LB8A6                       ; check next reserved word
+; PRINT command
+PRINT           beq LB958                       ; brif no argument - do a newline
+                bsr LB8FE                       ; process print options
+                clr DEVNUM                      ; reset output to screen
+                rts
+LB8FE           cmpa #'@                        ; is it PRINT @?
+                bne LB907                       ; brif not
+                jsr LA554                       ; move cursor to correct location
+                bra LB911                       ; handle some more
+LB907           cmpa #'#                        ; device number specified?
+                bne LB918                       ; brif not
+                jsr LA5A5                       ; parse device number
+                jsr LA406                       ; check for valid output file
+LB911           jsr GETCCH                      ; get input character
+                beq LB958                       ; brif nothing - do newline
+                jsr LB26D                       ; need comma after @ or #
+LB918           jsr RVEC9                       ; do the RAM hook boogaloo
+LB91B           beq LB965                       ; brif end of input
+LB91D           cmpa #0xa4                      ; TAB(?
+                beq LB97E                       ; brif so
+                cmpa #',                        ; comma (next tab field)?
+                beq LB966                       ; brif so
+                cmpa #';                        ; semicolon (do not advance print position)
+                beq LB997                       ; brif so
+                jsr LB156                       ; evaluate expression
+                lda VALTYP                      ; get type of value
+                pshs a                          ; save it
+                bne LB938                       ; brif string
+                jsr LBDD9                       ; convert FP number to string
+                jsr LB516                       ; parse a string and put on string stack
+LB938           bsr LB99F                       ; print string
+                puls b                          ; get back variable type
+                jsr LA35F                       ; set up print parameters
+                tst PRTDEV                      ; is it a display device?
+                beq LB949                       ; brif so
+                bsr LB958                       ; do a newline
+                jsr GETCCH                      ; get input
+                bra LB91B                       ; process more print stuff
+LB949           tstb                            ; set flags on print position
+                bne LB954                       ; brif not at start of line
+                jsr GETCCH                      ; get current input
+                cmpa #',                        ; comma?
+                beq LB966                       ; skip to next tab field if so
+                bsr LB9AC                       ; send a space
+LB954           jsr GETCCH                      ; get input character
+                bne LB91D                       ; brif not end of statement
+LB958           lda #0x0d                       ; carriage return
+                bra LB9B1                       ; send it to output
+LB95C           jsr LA35F                       ; set up print parameters
+LB95F           beq LB958                       ; brif width is 0
+                lda DEVPOS                      ; get line position
+                bne LB958                       ; brif not at start of line
+LB965           rts
+LB966           jsr LA35F                       ; set up print parameters
+                beq LB975                       ; brif line width is 0
+                ldb DEVPOS                      ; get line position
+                cmpb DEVLCF                     ; at or past last comma field?
+                blo LB977                       ; brif so
+                bsr LB958                       ; move to next line
+                bra LB997                       ; handle more stuff
+LB975           ldb DEVPOS                      ; get line position
+LB977           subb DEVCFW                     ; subtract a comma field width
+                bhs LB977                       ; brif we don't have a remainder yet
+                negb                            ; now B is number of of spaces needed
+                bra LB98E                       ; go advance
+LB97E           jsr LB709                       ; evaluate TAB distance
+                cmpa #')                        ; closing )?
+                lbne LB277                      ; brif not
+                jsr LA35F                       ; set up print parameters
+                subb DEVPOS                     ; subtract print position from desired position
+                bls LB997                       ; brif we're already past it
+LB98E           tst PRTDEV                      ; is it a display device?
+                bne LB997                       ; brif not
+LB992           bsr LB9AC                       ; output a space
+                decb                            ; done enough?
+                bne LB992                       ; brif not
+LB997           jsr GETNCH                      ; get input character
+                jmp LB91B                       ; process more items
+; cpoy string from (X-1) to output
+LB99C           jsr LB518                       ; parse the string
+LB99F           jsr LB657                       ; get string details
+LB9A2           incb                            ; compensate for decb
+LB9A3           decb                            ; done all of the string?
+                beq LB965                       ; brif so
+                lda ,x+                         ; get character from string
+                bsr LB9B1                       ; send to output
+                bra LB9A3                       ; go do another character
+LB9AC           lda #0x20                       ; space character
+                skip2
+LB9AF           lda #'?                         ; question mark character
+LB9B1           jmp PUTCHR                      ; output character
+; The floating point math package and related functions and operations follow from here
+; to the end of the Color Basic ROM area
+LB9B4           ldx #LBEC0                      ; point to FP constant 0.5
+                bra LB9C2                       ; add 0.5 to FPA0
+LB9B9           jsr LBB2F                       ; unpack FP data from (X) to FPA1
+; subtraction operator
+LB9BC           com FP0SGN                      ; invert sign of FPA0 (subtracting is adding the negative)
+                com RESSGN                      ; that also inverts the sign differential
+                bra LB9C5                       ; go add the negative of FPA0 to FPA1
+LB9C2           jsr LBB2F                       ; unpack FP data from (X) to FPA1
+; addition operator
+LB9C5           tstb                            ; check exponent of FPA0
+                lbeq LBC4A                      ; copy FPA1 to FPA0 if FPA0 is 0
+                ldx #FP1EXP                     ; point X to FPA1 (first operand) as the operand to denormalize
+LB9CD           tfr a,b                         ; put exponent of FPA1 into B
+                tstb                            ; is FPA1 0?
+                beq LBA3E                       ; brif exponent is 0 - no-op; adding 0 to FPA0
+                subb FP0EXP                     ; get difference in exponents - number of bits to shift the smaller mantissa
+                beq LBA3F                       ; brif exponents are equal - no need to denormalize
+                bmi LB9E2                       ; brif FPA0 > FPA1
+                sta FP0EXP                      ; replace result exponent with FPA1's (FPA1 is bigger)
+                lda FP1SGN                      ; also copy sign over
+                sta FP0SGN
+                ldx #FP0EXP                     ; point to FPA0 (we need to denormalize the smaller number)
+                negb                            ; invert the difference - this is the number of bits to shift the mantissa
+LB9E2           cmpb #-8                        ; do we have to shift by a whole byte?
+                ble LBA3F                       ; brif so start by shifting whole bytes to the right
+                clra                            ; clear overflow byte
+                lsr 1,x                         ; shift high bit of mantissa right (LSR will force a zero into the high bit)
+                jsr LBABA                       ; shift remainder of mantissa right -B times
+LB9EC           ldb RESSGN                      ; get the sign flag
+                bpl LB9FB                       ; brif signs are the same (we add the mantissas then)
+                com 1,x                         ; complement the mantissa and extra precision bytes
+                com 2,x
+                com 3,x
+                com 4,x
+                coma
+                adca #0                         ; add one to A (COM sets C); this may cause a carry to enter the ADD below
+LB9FB           sta FPSBYT                      ; save extra precision byte
+                lda FPA0+3                      ; add the main mantissa bytes (and propage carry from above)
+                adca FPA1+3
+                sta FPA0+3
+                lda FPA0+2
+                adca FPA1+2
+                sta FPA0+2
+                lda FPA0+1
+                adca FPA1+1
+                sta FPA0+1
+                lda FPA0
+                adca FPA1
+                sta FPA0
+                tstb                            ; were signs the same?
+                bpl LBA5C                       ; brif so - number may have gotten bigger so normalize if needed
+LBA18           bcs LBA1C                       ; brif we had a carry - result is positive?)
+                bsr LBA79                       ; do a proper negation of FPA0 mantissa
+LBA1C           clrb                            ; clear temporary exponent accumulator
+LBA1D           lda FPA0                        ; test high byte of mantissa
+                bne LBA4F                       ; brif not 0 - we need to do bit shifting
+                lda FPA0+1                      ; shift left 8 bits
+                sta FPA0
+                lda FPA0+2
+                sta FPA0+1
+                lda FPA0+3
+                sta FPA0+2
+                lda FPSBYT
+                sta FPA0+3
+                clr FPSBYT
+                addb #8                         ; account for 8 bits shifted
+                cmpb #5*8                       ; shifted 5 bytes worth?
+                blt LBA1D                       ; brif not
+LBA39           clra                            ; zero out exponent and sign - result is 0
+LBA3A           sta FP0EXP                      ; set exponent and sign
+                sta FP0SGN
+LBA3E           rts
+LBA3F           bsr LBAAE                       ; shift FPA0 mantissa to the right
+                clrb                            ; clear carry
+                bra LB9EC                       ; get on with adding
+LBA44           incb                            ; account for one bit shift
+                asl FPSBYT                      ; shift mantissa and extra precision left
+                rol FPA0+3
+                rol FPA0+2
+                rol FPA0+1
+                rol FPA0
+LBA4F           bpl LBA44                       ; brif we haven't got a 1 in bit 7
+                lda FP0EXP                      ; get exponent of result
+                pshs b                          ; subtract shift count from exponent
+                suba ,s+
+                sta FP0EXP                      ; save adjusted exponent
+                bls LBA39                       ; brif we underflowed - set result to 0
+	skip2
+LBA5C           bcs LBA66                       ; brif mantissa overflowed
+                asl FPSBYT                      ; get bit 7 of expra precision to C (used for round off)
+                lda #0                          ; set to 0 without affecting C
+                sta FPSBYT                      ; clear out extra precision bits
+                bra LBA72                       ; go round off result
+LBA66           inc FP0EXP                      ; bump exponent (for a right shift to bring carry in)
+                beq LBA92                       ; brif we overflowed
+                ror FPA0                        ; shift carry into mantissa, shift right
+                ror FPA0+1
+                ror FPA0+2
+                ror FPA0+3
+LBA72           bcc LBA78                       ; brif no round-off needed
+                bsr LBA83                       ; add one to mantissa
+                beq LBA66                       ; brif carry - need to shift right again
+LBA78           rts
+LBA79           com FP0SGN                      ; invert sign of value
+LBA7B           com FPA0                        ; first do a one's copmlement
+                com FPA0+1
+                com FPA0+2
+                com FPA0+3
+LBA83           ldx FPA0+2                      ; add one to mantissa (after one's complement gives two's complement)
+                leax 1,x                        ; bump low word
+                stx FPA0+2
+                bne LBA91                       ; brif no carry from low word
+                ldx FPA0                        ; bump high word
+                leax 1,x
+                stx FPA0
+LBA91           rts
+LBA92           ldb #2*5                        ; code for overflow
+                jmp LAC46                       ; raise error
+LBA97           ldx #FPA2-1                     ; point to FPA2
+LBA9A           lda 4,x                         ; shift mantissa right by 8 bits
+                sta FPSBYT
+                lda 3,x
+                sta 4,x
+                lda 2,x
+                sta 3,x
+                lda 1,x
+                sta 2,x
+                lda FPCARY                      ; and handle extra precision on the left
+                sta 1,x
+LBAAE           addb #8                         ; account for 8 bits shifted
+                ble LBA9A                       ; brif more shifts needed
+                lda FPSBYT                      ; get sub byte (extra precision)
+                subb #8                         ; undo the 8 added above
+                beq LBAC4                       ; brif difference is 0
+LBAB8           asr 1,x                         ; shift mantissa and sub byte one bit (keep mantissa high bit set)
+LBABA           ror 2,x
+                ror 3,x
+                ror 4,x
+                rora
+                incb                            ; account for one shift
+                bne LBAB8                       ; brif not enought shifts yet
+LBAC4           rts
+LBAC5           fcb 0x81,0x00,0x00,0x00,0x00    ; packed FP 1.0
+LBACA           bsr LBB2F                       ; unpack FP value from (X) to FPA1
+; multiplication operator
+LBACC           beq LBB2E                       ; brif exponent of FPA0 is 0 (result is 0)
+                bsr LBB48                       ; calculate exponent of product
+LBAD0           lda #0                          ; zero out mantissa of FPA2
+                sta FPA2
+                sta FPA2+1
+                sta FPA2+2
+                sta FPA2+3
+                ldb FPA0+3                      ; multiply FPA1 by LSB of FPA0
+                bsr LBB00
+                ldb FPSBYT                      ; save extra precision byte
+                stb VAE
+                ldb FPA0+2
+                bsr LBB00                       ; again for next byte of FPA0
+                ldb FPSBYT
+                stb VAD
+                ldb FPA0+1                      ; again for next byte of FPA0
+                bsr LBB00
+                ldb FPSBYT
+                stb VAC
+                ldb FPA0                        ; and finally for the high byte
+                bsr LBB02
+                ldb FPSBYT
+                stb VAB
+                jsr LBC0B                       ; copy mantissa from FPA2 to FPA0 (result)
+                jmp LBA1C                       ; normalize
+LBB00           beq LBA97                       ; brif multiplier is 0 - just shift, don't multiply
+LBB02           coma                            ; set carry
+LBB03           lda FPA2                        ; get FPA2 MS byte
+                rorb                            ; data bit to carry; will be 0 when all shifts done
+                beq LBB2E                       ; brif 8 shifts done
+                bcc LBB20                       ; brif data bit is 0 - no addition
+                lda FPA2+3                      ; add mantissa of FPA1 and FPA2
+                adda FPA1+3
+                sta FPA2+3
+                lda FPA2+2
+                adca FPA1+2
+                sta FPA2+2
+                lda FPA2+1
+                adca FPA1+1
+                sta FPA2+1
+                lda FPA2
+                adca FPA1
+LBB20           rora                            ; shift carry into FPA2
+                sta FPA2
+                ror FPA2+1
+                ror FPA2+2
+                ror FPA2+3
+                ror FPSBYT
+                clra                            ; clear carry
+                bra LBB03
+LBB2E           rts
+; Unpack FP value from (X) to FPA1
+LBB2F           ldd 1,x                         ; copy mantissa (and sign)
+                sta FP1SGN                      ; save sign bit
+                ora #0x80                       ; make sure mantissa has bit 7 set
+                std FPA1
+                ldb FP1SGN                      ; get sign
+                eorb FP0SGN                     ; set if FPA0 sign differs
+                stb RESSGN
+                ldd 3,x                         ; copy remainder of mantissa
+                std FPA1+2
+                lda ,x                          ; and exponent
+                sta FP1EXP
+                ldb FP0EXP                      ; fetch FPA0 exponent and set flags
+                rts
+; Calculate eponent for product of FPA0 and FPA1
+LBB48           tsta                            ; is FPA1 zero?
+                beq LBB61                       ; brif so
+                adda FP0EXP                     ; add to exponent of FPA0 (this is how scientific notation works)
+                rora                            ; set V if we *don't* have an overflow
+                rola
+                bvc LBB61                       ; brif exponent too larger or small
+                adda #0x80                      ; restore the bias
+                sta FP0EXP                      ; set result exponent
+                beq LBB63                       ; brif 0 - clear FPA0
+                lda RESSGN                      ; the result sign (negative if signs differ) is the result sign
+                sta FP0SGN                      ; so set it as such
+                rts
+LBB5C           lda FP0SGN                      ; get sign of FPA0
+                coma                            ; invert sign
+                bra LBB63                       ; zero sign and exponent
+LBB61           leas 2,s                        ; don't go back to caller (mul/div) - return to previous caller
+LBB63           lbpl LBA39                      ; brif we underflowed - go zero things out
+LBB67           jmp LBA92                       ; raise overflow error
+; fast multiply by 10 - leave result in FPA0
+LBB6A           jsr LBC5F                       ; copy FPA0 to FPA1 (for addition later)
+                beq LBB7C                       ; brif exponent is 0 - it's a no-op then
+                adda #2                         ; this gives "times 4"
+                bcs LBB67                       ; raise overflow if required
+                clr RESSGN                      ; set result sign to "signs the same"
+                jsr LB9CD                       ; add FPA1 to FPA0 "times 5"
+                inc FP0EXP                      ; times 10
+                beq LBB67                       ; brif overflow
+LBB7C           rts
+LBB7D           fcb 0x84,0x20,0x00,0x00,0x00    ; packed FP constant 10.0
+; Divide by 10
+LBB82           jsr LBC5F                       ; move FPA0 to FPA1
+                ldx #LBB7D                      ; point to constant 10
+                clrb                            ; zero sign
+LBB89           stb RESSGN                      ; result will be positive or zero
+                jsr LBC14                       ; unpack constant 10 to FPA0
+                skip2                           ; fall through to division (divide FPA1 by 10)
+LBB8F           bsr LBB2F                       ; unpack FP number from (X) to FPA1
+; division operator
+LBB91           beq LBC06                       ; brif FPA0 is 0 - division by zero
+                neg FP0EXP                      ; get exponent of reciprocal of the divisor
+                bsr LBB48                       ; calculate exponent of quotient
+                inc FP0EXP                      ; bump exponent (due to division algorithm below)
+                beq LBB67                       ; brif overflow
+                ldx #FPA2                       ; point to temporary storage location
+                ldb #4                          ; do 5 bytes
+                stb TMPLOC                      ; save counter
+                ldb #1                          ; shift counter and quotient byte
+LBBA4           lda FPA0                        ; compare mantissa of FPA0 to FPA1, set C if FPA1 less
+                cmpa FPA1
+                bne LBBBD
+                lda FPA0+1
+                cmpa FPA1+1
+                bne LBBBD
+                lda FPA0+2
+                cmpa FPA1+2
+                bne LBBBD
+                lda FPA0+3
+                cmpa FPA1+3
+                bne LBBBD
+                coma                            ; set C if FPA0 = FPA1 (it "goes")
+LBBBD           tfr cc,a                        ; save "it goes" status
+                rolb                            ; rotate carry into quotient
+                bcc LBBCC                       ; brif carry clear - haven't done 8 shifts yet
+                stb ,x+                         ; save quotient byte
+                dec TMPLOC                      ; done enough bytes?
+                bmi LBBFC                       ; brif done all 5
+                beq LBBF8                       ; brif last byte
+                ldb #1                          ; reset shift counter and quotient byte
+LBBCC           tfr a,cc                        ; get back carry status
+                bcs LBBDE                       ; brif it "went"
+LBBD0           asl FPA1+3                      ; shift mantissa (dividend) left
+                rol FPA1+2
+                rol FPA1+1
+                rol FPA1
+                bcs LBBBD                       ; brif carry - it "goes" so we have to bump quotient
+                bmi LBBA4                       ; brif high order bit is set - compare mantissas
+                bra LBBBD                       ; otherwise, count a 0 bit and try next bit
+LBBDE           lda FPA1+3                      ; subtract mantissa of FPA0 from mantissa of FPA1
+                suba FPA0+3
+                sta FPA1+3
+                lda FPA1+2
+                sbca FPA0+2