Disassembly of D64 ROM - 32K mode
($8000 - $9FFF)

*** standard JMP vectors

*** hardware routines
8000 7EBB3C     JMP   $BB3C     ;reset
8003 7EBB88     JMP   $BB88     ;set up $8f - $9b
8006 7EBBE5     JMP   $BBE5     ;scan keyboard (A)
8009 7EBBB5     JMP   $BBB5     ;blink cursor
800C 7EBCAB     JMP   $BCAB     ;write to VDU (A)
800F 7EBD1A     JMP   $BD1A     ;write to printer (A)
8012 7EBD52     JMP   $BD52     ;update joysticks

*** tape routines
8015 7EBDCF     JMP   $BDCF     ;motoron
8018 7EBDDC     JMP   $BDDC     ;motoroff
801B 7EBE68     JMP   $BE68     ;write leader
801E 7EBE12     JMP   $BE12     ;byte out (A)
8021 7EBDE7     JMP   $BDE7     ;read leader
8024 7EBDAD     JMP   $BDAD     ;byte in (A)
8027 7EBDA5     JMP   $BDA5     ;bit in (C)

*** serial routines
802A 7EBE7B     JMP   $BE7B     ;read serial (A)
802D 7EBE98     JMP   $BE98     ;write serial (A)
8030 7EBEA6     JMP   $BEA6     ;baud rate select

*** command table : last byte of each string has MSB set
    (token in final column)

8033  464FD2         ;FOR     80
8036  47CF           ;GO      81
8038  5245CD         ;REM     82
803B  A7             ;'       83
803C  454C53C5       ;ELSE    84
8040  49C6           ;IF      85
8042  444154C1       ;DATA    86
8046  5052494ED4     ;PRINT   87
804B  4FCE           ;ON      88
804D  494E5055D4     ;INPUT   89
8052  454EC4         ;END     8A
8055  4E4558D4       ;NEXT    8B
8059  4449CD         ;DIM     8C
805C  524541C4       ;READ    8D
8060  4C45D4         ;LET     8E
8063  5255CE         ;RUN     8F
8066  524553544F52C5 ;RESTORE 90
806D  5245545552CE   ;RETURN  91
8073  53544FD0       ;STOP    92
8077  504F4BC5       ;POKE    93
807B  434F4ED4       ;CONT    94
807F  4C4953D4       ;LIST    95
8083  434C4541D2     ;CLEAR   96
8088  4E45D7         ;NEW     97
808B  4445C6         ;DEF     98
808E  434C4F41C4     ;CLOAD   99
8093  43534156C5     ;CSAVE   9A
8098  4F5045CE       ;OPEN    9B
809C  434C4F53C5     ;CLOSE   9C
80A1  4C4C4953D4     ;LLIST   9D
80A6  5345D4         ;SET     9E
80A9  52455345D4     ;RESET   9F
80AE  434CD3         ;CLS     A0
80B1  4D4F544FD2     ;MOTOR   A1
80B6  534F554EC4     ;SOUND   A2
80BB  41554449CF     ;AUDIO   A3
80C0  455845C3       ;EXEC    A4
80C4  534B4950C6     ;SKIPF   A5
80C9  4445CC         ;DEL     A6
80CC  454449D4       ;EDIT    A7
80D0  54524FCE       ;TRON    A8
80D4  54524F46C6     ;TROFF   A9
80D9  4C494EC5       ;LINE    AA
80DD  50434CD3       ;PCLS    AB
80E1  505345D4       ;PSET    AC
80E5  5052455345D4   ;PRESET  AD
80EB  5343524545CE   ;SCREEN  AE
80F1  50434C4541D2   ;PCLEAR  AF
80F7  434F4C4FD2     ;COLOR   B0
80FC  434952434CC5   ;CIRCLE  B1
8102  5041494ED4     ;PAINT   B2
8107  4745D4         ;GET     B3
810A  5055D4         ;PUT     B4
810D  445241D7       ;DRAW    B5
8111  50434F50D9     ;PCOPY   B6
8116  504D4F44C5     ;PMODE   B7
811B  504C41D9       ;PLAY    B8
811F  444C4F41C4     ;DLOAD   B9
8124  52454E55CD     ;RENUM   BA
8129  544142A8       ;TAB(    BB
812D  54CF           ;TO      BC
812F  5355C2         ;SUB     BD
8132  46CE           ;FN      BE
8134  544845CE       ;THEN    BF
8138  4E4FD4         ;NOT     C0
813B  535445D0       ;STEP    C1
813F  4F46C6         ;OFF     C2
8142  AB             ;+       C3
8143  AD             ;-       C4
8144  AA             ;*       C5
8145  AF             ;/       C6
8146  DE             ;^       C7
8147  414EC4         ;AND     C8
814A  4FD2           ;OR      C9
814C  BE             ;>       CA
814D  BD             ;=       CB
814E  BC             ;<       CC
814F  5553494EC7     ;USING   CD

*** command vectors

8154  8448 85B9 8616 8616   ;for go rem '
815C  8616 8647 8613 903D   ;else if data print
8164  8675 872B 8532 8829   ;on input end next
816C  8A8B 8777 86BC 85A5   ;dim read let run
8174  8514 85F3 8539 8E9D   ;restore return stop poke
817C  8560 8EAA 8571 8415   ;cont list clear new
8184  9C81 B6D4 B682 B828   ;def cload csave open
818C  B64C 8EA4 B9D2 BA03   ;close llist set reset
8194  BA5F B981 BA9A BADF   ;cls motor sound audio
819C  B770 B81E 9D61 9965   ;exec skipf del edit
81A4  9AD9 9ADA A749 A8C0   ;tron troff line pcls
81AC  A6EF A6F3 A9FE AA19   ;pset preset screen pclear
81B4  A8D4 B238 AC87 AAF0   ;color circle paint get
81BC  AAF3 B051 AABE A9AF   ;put draw pcopy pmode
81C4  ADBD A049 9DFA        ;play dload renum

*** function table : last byte of each string has MSB set
    (token in final column)

81CA  5347CE         ;SGN     FF80
81CD  494ED4         ;INT     FF81
81D0  4142D3         ;ABS     FF82
81D3  504FD3         ;POS     FF83
81D6  524EC4         ;RND     FF84
81D9  5351D2         ;SQR     FF85
81DC  4C4FC7         ;LOG     FF86
81DF  4558D0         ;EXP     FF87
81E2  5349CE         ;SIN     FF88
81E5  434FD3         ;COS     FF89
81E8  5441CE         ;TAN     FF8A
81EB  4154CE         ;ATN     FF8B
81EE  504545CB       ;PEEK    FF8C
81F2  4C45CE         ;LEN     FF8D
81F5  535452A4       ;STR$    FF8E
81F9  5641CC         ;VAL     FF8F
81FC  4153C3         ;ASC     FF90
81FF  434852A4       ;CHR$    FF91
8203  454FC6         ;EOF     FF92
8206  4A4F595354CB   ;JOYSTK  FF93
820C  4649D8         ;FIX     FF94
820F  484558A4       ;HEX$    FF95
8213  4C454654A4     ;LEFT$   FF96
8218  5249474854A4   ;RIGHT$  FF97
821E  4D4944A4       ;MID$    FF98
8222  504F494ED4     ;POINT   FF99
8227  494E4B4559A4   ;INKEY$  FF9A
822D  4D45CD         ;MEM     FF9B
8230  5641525054D2   ;VARPTR  FF9C
8236  494E5354D2     ;INSTR   FF9D
823B  54494D45D2     ;TIMER   FF9E
8240  50504F494ED4   ;PPOINT  FF9F
8246  535452494E47A4 ;STRING$ FFA0
824D  5553D2         ;USR     FFA1

*** function vectors

8250  9425 9499 943E 9ADE    ;sgn int abs pos
8258  9772 9697 923C 9713    ;rnd sqr log exp
8260  97D1 97CB 9816 9877    ;sin cos tan atn
8268  8E96 8DC7 8C40 8E5C    ;peek len str$ val
8270  8DE6 8DD2 B800 BB0D    ;asc chr$ eof joystk
8278  9956 A00E 8DF1 8E0E    ;fix hex$ left$ right$
8280  8E15 BA44 B796 8C31    ;mid$ point inkey$ mem
8288  9AF4 9BB4 9D59 A6C7    ;varptr instr timer ppoint
8290  9B84 9D1D              ;string$ usr

*** binary operator table used during expression evaluation
    (1st byte is precedence level followed by address of handler)

8294  79 910E     ; +
8297  79 9105     ; -
829A  7B 9275     ; *
829D  7B 933C     ; /
82A0  7F 96A0     ; ^
82A3  50 8A12     ; AND
82A6  46 8A11     ; OR

*** error code strings

82A9 4E46 534E    NF  SN
82AD 5247 4F44    RG  OD
82B1 4643 4F56    FC  OV
82B5 4F4D 554C    OM  UL
82B9 4253 4444    BS  DD
82BD 2F30 4944    /0  ID
82C1 544D 4F53    TM  OS
82C5 4C53 5354    LS  ST
82C9 434E 5546    CN  UF
82CD 4644 414F    FD  AO
82D1 444E 494F    DN  IO
82D5 464D 4E4F    FM  NO
82D9 4945 4453    IE  DS
82DD 4E45         NE

*** misc strings

82DF  204552524F5200     ;/ERROR /
82E6  20494E2000         ;/ IN /
82EB  0D4F4B0D00         ;CR/OK/CR
82F0  0D425245414B00     ;CR/BREAK/

*** examine BASIC stack (maintained 'under' machine return addresses)
    
    $3b = varptr of FOR control variable to search for (zero if none)
          set $3b to #$ff to skip all FOR entries
    returns X = $0f = pointer to matching entry for FOR / NEXT
    $3b = varptr of control variable for unspecified NEXT
    Z = 0 if matching FOR entry not found

82F7 3064       LEAX  4,S       ;point X past 2 return addresses
82F9 C612       LDB   #$12      ;size of FOR stack entry
82FB 9F0F       STX   <$0F      ;$0f = this entry
82FD A684       LDA   ,X
82FF 8080       SUBA  #$80
8301 2615       BNE   $8318     ;not a FOR entry
8303 AE01       LDX   1,X
8305 9F11       STX   <$11      ;varptr of control variable
8307 9E3B       LDX   <$3B
8309 2709       BEQ   $8314     ;we were called by NEXT with no variable
830B 9C11       CMPX  <$11
830D 2709       BEQ   $8318     ;found a matching entry
830F 9E0F       LDX   <$0F
8311 3A         ABX             ;point X to next stack entry
8312 20E5       BRA   $82F9     ;examine next entry
8314 9E11       LDX   <$11      ;set $3b up with varptr of control variable
8316 9F3B       STX   <$3B       ;for unspecified NEXT
8318 9E0F       LDX   <$0F
831A 4D         TSTA
831B 39         RTS

*** move memory contents up     
start address   - $47
end address     - $43
new end address - $41 (D = new end address for memory check)
returns $45 = U = start of relocated block

831C 8D17       BSR   $8335     ;memory check
831E DE41       LDU   <$41
8320 3341       LEAU  1,U
8322 9E43       LDX   <$43
8324 3001       LEAX  1,X
8326 A682       LDA   ,-X
8328 3602       PSHU  A
832A 9C47       CMPX  <$47
832C 26F8       BNE   $8326
832E DF45       STU   <$45
8330 39         RTS

*** check if there are B free words of storage left

8331 4F         CLRA
8332 58         ASLB
8333 D31F       ADDD  <$1F      ;end of BASIC storage
8335 C3003A     ADDD  #$003A
8338 2508       BCS   $8342      ;?OM ERROR
833A 10DF17     STS   <$17
833D 109317     CMPD  <$17
8340 25EE       BCS   $8330     ;RTS
8342 C60C       LDB   #$0C      ;?OM ERROR

*** ?xx ERROR - error code in B

8344 BD018E     JSR   $018E     ;user error trap
8347 BD0191     JSR   $0191     ;system error trap
834A BD8018     JSR   $8018     ;cassette relay off
834D BDBAC3     JSR   $BAC3     ;disable audio
8350 BD8434     JSR   $8434     ;reset stack & bits & pieces
8353 0F6F       CLR   <$6F      ;DEVN
8355 BD90A5     JSR   $90A5     ;initialise virtual DEVN device & new line
8358 BD90F8     JSR   $90F8     ;print '?' to DEVN
835B 8E82A9     LDX   #$82A9    ;error string table
835E 3A         ABX
835F 8D3D       BSR   $839E     ;output to DEVN from ,X+
8361 8D3B       BSR   $839E     ;output to DEVN from ,X+
8363 8E82DE     LDX   #$82DE    ;'ERROR'
8366 BD90E5     JSR   $90E5     ;print string to DEVN
8369 9668       LDA   <$68      ;current line number
836B 4C         INCA
836C 2703       BEQ   $8371     ;command mode
836E BD9573     JSR   $9573     ;print 'IN xxxx' (current line number)

*** command mode

8371 BD90A5     JSR   $90A5     ;initialise virtual DEVN device & new line
8374 8E82EB     LDX   #$82EB
8377 BD90E5     JSR   $90E5     ;print 'OK'
837A BDB5C6     JSR   $B5C6     ;line input from DEVN
837D CEFFFF     LDU   #$FFFF
8380 DF68       STU   <$68      ;current line number
8382 25F6       BCS   $837A     ;command mode without 'OK'
8384 0D70       TST   <$70      ;eof flag
8386 10263373  LBNE   $B6FD     ;close file & return to command mode
838A 9FA6       STX   <$A6      ;BASIC source pointer
838C 9D9F       JSR   <$9F      ;get next character from BASIC source
838E 27EA       BEQ   $837A     ;command mode without 'OK'
8390 2511       BCS   $83A3     ;enter BASIC line
8392 C632       LDB   #$32      ;?DS ERROR
8394 0D6F       TST   <$6F      ;DEVN
8396 26AC       BNE   $8344     ;cause error
8398 BD8F67     JSR   $8F67     ;tokenize BASIC line
839B 7E84D6     JMP   $84D6     ;enter interpreter loop

*** used by error routine to print error code

839E A680       LDA   ,X+
83A0 7E90FA     JMP   $90FA     ;output character to DEVN

*** enter a BASIC line

83A3 BD869A     JSR   $869A     ;read line number & store in $2b
83A6 9E2B       LDX   <$2B
83A8 BF02DA     STX   $02DA
83AB BD8F67     JSR   $8F67     ;tokenize BASIC line
83AE D703       STB   <$03      ;line length
83B0 8D4D       BSR   $83FF     ;search program for line number in <$2b
83B2 2512       BCS   $83C6     ;line number doesn't exist
83B4 DC47       LDD   <$47      ;address where line needs to go
83B6 A384       SUBD  ,X        ;subtract next line pointer (-ve result)
83B8 D31B       ADDD  <$1B      ;start of simple variables
83BA DD1B       STD   <$1B      ;new end of program
83BC EE84       LDU   ,X
83BE 3702       PULU  A         ;move program down, erasing existing line
83C0 A780       STA   ,X+       ;
83C2 9C1B       CMPX  <$1B      ;start of simple variables
83C4 26F8       BNE   $83BE     ;
83C6 B602DC     LDA   $02DC
83C9 271C       BEQ   $83E7     ;new line is empty
83CB DC1B       LDD   <$1B      ;start of simple variables
83CD DD43       STD   <$43
83CF DB03       ADDB  <$03      ;new line length
83D1 8900       ADCA  #$00
83D3 DD41       STD   <$41
83D5 BD831C     JSR   $831C     ;move memory contents up
83D8 CE02D8     LDU   #$02D8
83DB 3702       PULU  A         ;
83DD A780       STA   ,X+       ;copy new line into space just created
83DF 9C45       CMPX  <$45      ;
83E1 26F8       BNE   $83DB     ;
83E3 9E41       LDX   <$41
83E5 9F1B       STX   <$1B      ;new end of program
83E7 8D36       BSR   $841F     ;clear variables and reset stack & cmd ptr
83E9 8D02       BSR   $83ED     ;set up next line pointers in BASIC program
83EB 208D       BRA   $837A     ;command mode without 'OK'

*** set up next line pointers in BASIC program

83ED 9E19       LDX   <$19      ;start of BASIC program
83EF EC84       LDD   ,X
83F1 2721       BEQ   $8414     ;RTS
83F3 3304       LEAU  4,X
83F5 A6C0       LDA   ,U+
83F7 26FC       BNE   $83F5
83F9 EF84       STU   ,X
83FB AE84       LDX   ,X
83FD 20F0       BRA   $83EF

*** search program for line number in <$2b

83FF DC2B       LDD   <$2B
8401 9E19       LDX   <$19      ;start of BASIC program

*** scan ahead for line in D & store address in $47
    (first line after if it doesn't exist - carry clear if found)

8403 EE84       LDU   ,X
8405 2709       BEQ   $8410     ; end of program
8407 10A302     CMPD  2,X       ; scan program until line no. is greater
840A 2306       BLS   $8412     ; than D
840C AE84       LDX   ,X        ; next line
840E 20F3       BRA   $8403
8410 1A01       ORCC  #$01
8412 9F47       STX   <$47
8414 39         RTS

*** NEW

8415 26FB       BNE   $8412
8417 9E19       LDX   <$19      ;start of BASIC program
8419 6F80       CLR   ,X+
841B 6F80       CLR   ,X+
841D 9F1B       STX   <$1B      ;start of simple variables
841F 9E19       LDX   <$19      ;start of BASIC program
8421 BD85EE     JSR   $85EE     ;subtract 1 from X & store in $a6
8424 BD0197     JSR   $0197     ;PATCH - reset BASIC memory
8427 9E27       LDX   <$27      ;top of BASIC RAM
8429 9F23       STX   <$23      ;top of free string space
842B BD8514     JSR   $8514     ;RESTORE
842E 9E1B       LDX   <$1B      ;start of simple variables
8430 9F1D       STX   <$1D      ;start of array variables
8432 9F1F       STX   <$1F      ;end of BASIC storage
8434 8E01A9     LDX   #$01A9
8437 9F0B       STX   <$0B
8439 AEE4       LDX   ,S
843B 10DE21     LDS   <$21      ;stack root / string storage start
843E 6FE2       CLR   ,-S
8440 0F2D       CLR   <$2D      ;CONT source address
8442 0F2E       CLR   <$2E      ;
8444 0F08       CLR   <$08
8446 6E84       JMP   ,X

*** FOR

    creates following 18 byte stack entry:

      ,S   #$80
     1,S   varptr of control variable
     3,S   STEP value (unsigned FP)
     8,S   sign of STEP value (-1, 0 ,1)
     9,S   TO value (signed FP)
    14,S   line number of FOR statement
    16,S   address of statement after FOR

8448 8680       LDA   #$80
844A 9708       STA   <$08      ;array illegal flag
844C BD86BC     JSR   $86BC     ;LET
844F BD82F7     JSR   $82F7     ;examine BASIC stack
8452 3262       LEAS  2,S       ;lose return address
8454 2604       BNE   $845A     ;no FOR with same control variable already
8456 9E0F       LDX   <$0F
8458 3285       LEAS  B,X       ;overwrite duplicate FOR entry
845A C609       LDB   #$09
845C BD8331     JSR   $8331     ;memory check
845F BD861B     JSR   $861B     ;find end of statement
8462 DC68       LDD   <$68      ;current line number
8464 3416       PSHS  A,B,X     ;push next statement ptr & current line no.
8466 C6BC       LDB   #$BC      ;token TO
8468 BD89AC     JSR   $89AC     ;skip character in B
846B BD8874     JSR   $8874     ;validate numeric expression
846E BD8872     JSR   $8872     ;read numeric expression into FPA1
8471 D654       LDB   <$54      ;
8473 CA7F       ORB   #$7F      ;convert FPA1 back to standard variable
8475 D450       ANDB  <$50      ;
8477 D750       STB   <$50      ;
8479 108E8480   LDY   #$8480
847D 7E891B     JMP   $891B     ;push FPA1 onto stack & JMP ,Y
8480 8E920E     LDX   #$920E    ;FP constant 1
8483 BD93BF     JSR   $93BF     ;load variable into FPA1 (X is varptr)
8486 9DA5       JSR   <$A5      ;get current character from BASIC source
8488 81C1       CMPA  #$C1      ;token STEP
848A 2605       BNE   $8491     ;no STEP value specified
848C 9D9F       JSR   <$9F      ;get next character from BASIC source
848E BD8872     JSR   $8872     ;read numeric expression into FPA1
8491 BD9418     JSR   $9418     ;sets B to -1, 0 or 1 as per sign of FPA1
8494 BD8917     JSR   $8917     ;push B then FPA1 onto stack
8497 DC3B       LDD   <$3B      ;varptr of control variable
8499 3406       PSHS  A,B
849B 8680       LDA   #$80      ;FOR signature on stack
849D 3402       PSHS  A

*** interpreter loop

849F BD019A     JSR   $019A     ;PATCH - get command
84A2 1CAF       ANDCC #$AF      ;unmask interrupts
84A4 8D75       BSR   $851B     ;scan for BREAK / pause
84A6 9EA6       LDX   <$A6      ;BASIC source pointer
84A8 9F2F       STX   <$2F      ;address of current BASIC statement
84AA A680       LDA   ,X+
84AC 2707       BEQ   $84B5     ;end of line
84AE 813A       CMPA  #$3A   :
84B0 2724       BEQ   $84D6
84B2 7E89B4     JMP   $89B4     ;?SN ERROR
84B5 A681       LDA   ,X++
84B7 9700       STA   <$00      ;this will be zero when end reached
84B9 10270088  LBEQ   $8545     ;end of program
84BD EC80       LDD   ,X+
84BF DD68       STD   <$68      ;current line number
84C1 9FA6       STX   <$A6      ;BASIC source pointer
84C3 96AF       LDA   <$AF      ;trace flag
84C5 270F       BEQ   $84D6     ;trace off
84C7 865B       LDA   #$5B   [
84C9 BDB54A     JSR   $B54A     ;output character to DEVN
84CC 9668       LDA   <$68      ;current line number
84CE BD957A     JSR   $957A     ;print unsigned number in D
84D1 865D       LDA   #$5D   ]
84D3 BDB54A     JSR   $B54A     ;output character to DEVN
84D6 9D9F       JSR   <$9F      ;get next character from BASIC source
84D8 8D02       BSR   $84DC     ;interpret statement
84DA 20C3       BRA   $849F     ;interpreter loop

*** interpret statement

84DC 273C       BEQ   $851A     ;RTS
84DE BD0179     JSR   $0179     ;PATCH - interpreter
84E1 4D         TSTA
84E2 102A01D6  LBPL   $86BC     ;variable on LHS (LET)
84E6 81BA       CMPA  #$BA
84E8 220B       BHI   $84F5     ;not a BASIC command
84EA BE0123     LDX   $0123     ;command JMP table
84ED 48         ASLA
84EE 1F89       TFR   A,B
84F0 3A         ABX
84F1 9D9F       JSR   <$9F      ;get next character from BASIC source
84F3 6E94       JMP  (,X)
84F5 81FF       CMPA  #$FF
84F7 2708       BEQ   $8501     ;function
84F9 81CD       CMPA  #$CD
84FB 23B5       BLS   $84B2     ;?SN ERROR
84FD 6E9F012D   JMP  ($012D)    ;must be disk command
8501 9D9F       JSR   <$9F      ;get next character from BASIC source
8503 8198       CMPA  #$98
8505 10271603  LBEQ   $9B0C     ;MID$ on LHS
8509 819E       CMPA  #$9E
850B 10271842  LBEQ   $9D51     ;TIMER on LHS
850F BD01A0     JSR   $01A0     ;PATCH - CLS GET PUT ???
8512 209E       BRA   $84B2     ;?SN ERROR

*** RESTORE

8514 9E19       LDX   <$19      ;start of BASIC program
8516 301F       LEAX  -1,X
8518 9F33       STX   <$33      ;READ pointer
851A 39         RTS

*** scan keyboard for break & pause

851B BD8006     JSR   $8006     ;scan keyboard
851E 270A       BEQ   $852A
8520 8103       CMPA  #$03
8522 2715       BEQ   $8539     ;BREAK
8524 8113       CMPA  #$13
8526 2703       BEQ   $852B     ;SHIFT + @
8528 9787       STA   <$87
852A 39         RTS
852B BD8006     JSR   $8006     ;scan keyboard
852E 27FB       BEQ   $852B
8530 20EE       BRA   $8520

*** END

8532 BDB65C     JSR   $B65C     ;close cassette stream
8535 9DA5       JSR   <$A5      ;get current character from BASIC source
8537 2002       BRA   $853B

*** STOP

8539 1A01       ORCC  #$01
853B 2633       BNE   $8570     ;RTS
853D 9EA6       LDX   <$A6      ;BASIC source pointer
853F 9F2F       STX   <$2F      ;address of current BASIC statement
8541 0600       ROR   <$00      ;make -ve for STOP
8543 3262       LEAS  2,S       ;lose return address
8545 9E68       LDX   <$68      ;current line number
8547 8CFFFF     CMPX  #$FFFF
854A 2706       BEQ   $8552     ;already in command mode
854C 9F29       STX   <$29      ;CONT line number
854E 9E2F       LDX   <$2F      ;address of current BASIC statement
8550 9F2D       STX   <$2D      ;CONT source address
8552 0F6F       CLR   <$6F      ;DEVN
8554 8E82EF     LDX   #$82EF    ;/BREAK/
8557 0D00       TST   <$00
8559 102AFE14  LBPL   $8371     ;command mode
855D 7E8366     JMP   $8366     ;print BREAK message

*** CONT

8560 260E       BNE   $8570     ;RTS
8562 C620       LDB   #$20      ;?CN ERROR
8564 9E2D       LDX   <$2D      ;CONT source address
8566 1027FDDA  LBEQ   $8344     ;cause error
856A 9FA6       STX   <$A6      ;BASIC source pointer
856C 9E29       LDX   <$29      ;CONT line number
856E 9F68       STX   <$68      ;current line number
8570 39         RTS

*** CLEAR

8571 272C       BEQ   $859F     ;clear variables & reset stack
8573 BD8B23     JSR   $8B23     ;read unsigned number into $52 & D
8576 3406       PSHS  A,B
8578 9E27       LDX   <$27      ;top of BASIC RAM
857A 9DA5       JSR   <$A5      ;get current character from BASIC source
857C 270C       BEQ   $858A
857E BD89AA     JSR   $89AA     ;skip comma
8581 BD8E83     JSR   $8E83     ;read 16 bit number into X
8584 301F       LEAX  -1,X
8586 9C74       CMPX  <$74      ;top of RAM
8588 2218       BHI   $85A2     ;?OM ERROR
858A 1F10       TFR   X,D
858C A3E1       SUBD  ,S++
858E 2512       BCS   $85A2     ;?OM ERROR
8590 1F03       TFR   D,U
8592 83003A     SUBD  #$003A
8595 250B       BCS   $85A2     ;?OM ERROR
8597 931B       SUBD  <$1B      ;start of simple variables
8599 2507       BCS   $85A2     ;?OM ERROR
859B DF21       STU   <$21      ;new stack address
859D 9F27       STX   <$27      ;new top of BASIC RAM
859F 7E8424     JMP   $8424     ;clear variables & reset stack

85A2 7E8342     JMP   $8342     ;?OM ERROR

*** RUN

85A5 BD0194     JSR   $0194     ;PATCH - run
85A8 BD98E3     JSR   $98E3     ;set up sound & graphics variables
85AB BDB65C     JSR   $B65C     ;close cassette stream
85AE 9DA5       JSR   <$A5      ;get current character from BASIC source
85B0 1027FE6B  LBEQ   $841F     ;clear variables and reset stack & cmd ptr
85B4 BD8424     JSR   $8424     ;clear variables & reset stack
85B7 2019       BRA   $85D2     ;perform GOTO

*** GO  (TO/SUB)

    GOSUB creates following 5 byte stack entry:

     ,S     #$BD
    1,S     line number of GOSUB statement
    3,S     address of GOSUB statement (points to SUB token)

85B9 1F89       TFR   A,B
85BB 9D9F       JSR   <$9F      ;get next character from BASIC source
85BD C1BC       CMPB  #$BC      ;token TO
85BF 2716       BEQ   $85D7     ;perform GOTO
85C1 C1BD       CMPB  #$BD      ;token SUB
85C3 2645       BNE   $860A     ;?SN ERROR
85C5 C603       LDB   #$03
85C7 BD8331     JSR   $8331     ;memory check
85CA DEA6       LDU   <$A6      ;BASIC source pointer
85CC 9E68       LDX   <$68      ;current line number
85CE 86BD       LDA   #$BD      ;token SUB
85D0 3452       PSHS  A,X,U
85D2 8D03       BSR   $85D7     ;perform GOTO
85D4 7E849F     JMP   $849F     ;interpreter loop

*** perform GOTO

85D7 9DA5       JSR   <$A5      ;get current character from BASIC source
85D9 BD869A     JSR   $869A     ;read line number & store in $2b
85DC 8D40       BSR   $861E     ;find end of line
85DE 3001       LEAX  1,X
85E0 DC2B       LDD   <$2B
85E2 109368     CMPD  <$68      ;current line number
85E5 2202       BHI   $85E9
85E7 9E19       LDX   <$19      ;start of BASIC program
85E9 BD8403     JSR   $8403     ;scan for line D
85EC 2517       BCS   $8605     ;?UL ERROR
85EE 301F       LEAX  -1,X
85F0 9FA6       STX   <$A6      ;BASIC source pointer
85F2 39         RTS

*** RETURN

85F3 26FD       BNE   $85F2     ;RTS
85F5 86FF       LDA   #$FF
85F7 973B       STA   <$3B      ;set $3b to skip all FOR entries
85F9 BD82F7     JSR   $82F7     ;examine BASIC stack
85FC 1F14       TFR   X,S       ;point stack to this entry
85FE 813D       CMPA  #$3D
8600 270B       BEQ   $860D     ;GOSUB signature (#$BD - #$80)
8602 C604       LDB   #$04      ;?RG ERROR
8604 8C         CMPX  #
(8605 C60E       LDB   #$0E)    ;?UL ERROR
8607 7E8344     JMP   $8344     ;cause error

860A 7E89B4     JMP   $89B4     ;?SN ERROR

860D 3552       PULS  A,X,U
860F 9F68       STX   <$68      ;current line number
8611 DFA6       STU   <$A6      ;BASIC source pointer

*** DATA
    (simply skips to next statement)

8613 8D06       BSR   $861B     ;find end of statement
8615 8C         CMPX  #

*** REM / ELSE

(8616 8D06       BSR   $861E)   ;find end of line
8618 9FA6       STX   <$A6      ;BASIC source pointer
861A 39         RTS

*** find end of statement

861B C63A       LDB   #$3A   :
861D 86         LDA   #
(861E 5F         CLRB)
861F D701       STB   <$01
8621 5F         CLRB
8622 9EA6       LDX   <$A6      ;BASIC source pointer
8624 1F98       TFR   B,A
8626 D601       LDB   <$01
8628 9701       STA   <$01
862A A684       LDA   ,X
862C 27EC       BEQ   $861A     ;RTS
862E 3404       PSHS  B
8630 A1E0       CMPA  ,S+
8632 27E6       BEQ   $861A     ;RTS
8634 3001       LEAX  1,X
8636 8122       CMPA  #$22   "
8638 27EA       BEQ   $8624
863A 4C         INCA
863B 2602       BNE   $863F
863D 3001       LEAX  1,X
863F 8186       CMPA  #$86      ;token IF (+1)
8641 26E7       BNE   $862A
8643 0C04       INC   <$04      ;increment for each IF token encountered
8645 20E3       BRA   $862A

*** IF

    IF condition (THEN/GOTO) [IF...THEN [IF...THEN...ELSE] ELSE] ELSE
    --                                                           ----
    ELSEs are tied to previous IFs

8647 BD8872     JSR   $8872     ;read numeric expression into FPA1
864A 9DA5       JSR   <$A5      ;get current character from BASIC source
864C 8181       CMPA  #$81      ;token GO
864E 2705       BEQ   $8655
8650 C6BF       LDB   #$BF      ;token THEN
8652 BD89AC     JSR   $89AC     ;skip character in B
8655 964F       LDA   <$4F
8657 2613       BNE   $866C     ;IF condition true
8659 0F04       CLR   <$04      ;clear IF counter
865B 8DB6       BSR   $8613     ;skip to start of next statement
865D 4D         TSTA
865E 27BA       BEQ   $861A     ;RTS
8660 9D9F       JSR   <$9F      ;get next character from BASIC source
8662 8184       CMPA  #$84      ;token ELSE
8664 26F5       BNE   $865B     ;we're looking for ELSE
8666 0A04       DEC   <$04      ;any IFs skipped?
8668 2AF1       BPL   $865B     ;this ELSE doesn't go with this IF
866A 9D9F       JSR   <$9F      ;get next character from BASIC source
866C 9DA5       JSR   <$A5      ;get current character from BASIC source
866E 1025FF65  LBCS   $85D7     ;it's a number - perform GOTO
8672 7E84DC     JMP   $84DC     ;interpret statement

*** ON

8675 BD8E51     JSR   $8E51     ;get number into B
8678 C681       LDB   #$81      ;token GO
867A BD89AC     JSR   $89AC     ;skip character in B
867D 3402       PSHS  A
867F 81BD       CMPA  #$BD      ;token SUB
8681 2704       BEQ   $8687
8683 81BC       CMPA  #$BC      ;token TO
8685 2683       BNE   $860A     ;?SN ERROR
8687 0A53       DEC   <$53      ;control variable
8689 2605       BNE   $8690
868B 3504       PULS  B
868D 7E85BB     JMP   $85BB     ;GO (cmd pointer now at desired choice)
8690 9D9F       JSR   <$9F      ;get next character from BASIC source
8692 8D06       BSR   $869A     ;read line number & store in $2b
8694 812C       CMPA  #$2C   ,
8696 27EF       BEQ   $8687
8698 3584       PULS  B,PC

*** read line number from command & store in $2b

869A 9E8A       LDX   <$8A      ;zero
869C 9F2B       STX   <$2B
869E 2464       BCC   $8704     ;not a digit - RTS
86A0 8030       SUBA  #$30   0
86A2 9701       STA   <$01
86A4 DC2B       LDD   <$2B
86A6 8118       CMPA  #$18      ; D > 6399?
86A8 22DB       BHI   $8685     ;?SN ERROR
86AA 58         ASLB            ;
86AB 49         ROLA            ;
86AC 58         ASLB            ; D = D * 10
86AD 49         ROLA            ;
86AE D32B       ADDD  <$2B      ;
86B0 58         ASLB            ;
86B1 49         ROLA            ;
86B2 DB01       ADDB  <$01      ;add new digit
86B4 8900       ADCA  #$00      ;
86B6 DD2B       STD   <$2B
86B8 9D9F       JSR   <$9F      ;get next character from BASIC source
86BA 20E2       BRA   $869E     ;process another digit

*** LET

86BC BD8A94     JSR   $8A94     ;get varptr of variable in X
86BF 9F3B       STX   <$3B
86C1 C6CB       LDB   #$CB      ;token =
86C3 BD89AC     JSR   $89AC     ;skip character in B
86C6 9606       LDA   <$06      ;numeric / string flag
86C8 3402       PSHS  A
86CA BD8887     JSR   $8887     ;get expression
86CD 3502       PULS  A
86CF 46         RORA            ;check that variable & expression
86D0 BD8879     JSR   $8879      ;are of same type
86D3 10270D07  LBEQ   $93DE     ;assign FPA1 to varptr in <$3b
86D7 BD019D     JSR   $019D     ;PATCH - assign string variable
86DA 9E52       LDX   <$52
86DC DC21       LDD   <$21      ;stack root / string storage start
86DE 10A302     CMPD  2,X
86E1 2411       BCC   $86F4
86E3 9C1B       CMPX  <$1B      ;start of simple variables
86E5 250D       BCS   $86F4
86E7 E684       LDB   ,X
86E9 BD8C50     JSR   $8C50     ;reserve B bytes of string space
86EC 9E4D       LDX   <$4D
86EE BD8D89     JSR   $8D89     ;copy string (len B) from varptr X to ($25)+
86F1 8E0056     LDX   #$0056
86F4 9F4D       STX   <$4D
86F6 BD8DBB     JSR   $8DBB     ;if X is top of string stack then pull it
86F9 DE4D       LDU   <$4D
86FB 9E3B       LDX   <$3B
86FD 3726       PULU  A,B,Y
86FF A784       STA   ,X
8701 10AF02     STY   2,X
8704 39         RTS

*** string used by INPUT

8705  3F5245444F0D00     ;/?REDO/CR

*** take action for illegal input

870C C624       LDB   #$24      ;?FD ERROR
870E 0D6F       TST   <$6F      ;DEVN
8710 2703       BEQ   $8715
8712 7E8344     JMP   $8344     ;cause error
8715 9609       LDA   <$09
8717 2707       BEQ   $8720
8719 9E31       LDX   <$31      ;line number of current DATA statement
871B 9F68       STX   <$68      ;current line number
871D 7E89B4     JMP   $89B4     ;?SN ERROR
8720 8E8704     LDX   #$8704    ;/?REDO/
8723 BD90E5     JSR   $90E5     ;print string to DEVN
8726 9E2F       LDX   <$2F      ;address of current BASIC statement
8728 9FA6       STX   <$A6      ;BASIC source pointer
872A 39         RTS

*** INPUT

872B BD9C76     JSR   $9C76     ;test for command mode
872E 8D03       BSR   $8733
8730 0F6F       CLR   <$6F      ;DEVN
8732 39         RTS

8733 8123       CMPA  #$23   #
8735 2609       BNE   $8740
8737 BDB7D7     JSR   $B7D7     ;read #-n & set up DEVN
873A BDB623     JSR   $B623     ;test cassette status OK for input
873D BD89AA     JSR   $89AA     ;skip comma
8740 8122       CMPA  #$22   "
8742 260B       BNE   $874F     ;no prompt
8744 BD8975     JSR   $8975     ;read literal string
8747 C63B       LDB   #$3B   ;
8749 BD89AC     JSR   $89AC     ;skip character in B
874C BD90E8     JSR   $90E8     ;print prompt
874F 8E02DC     LDX   #$02DC
8752 6F84       CLR   ,X
8754 0D6F       TST   <$6F      ;DEVN
8756 2622       BNE   $877A
8758 8D06       BSR   $8760     ;get something into input buffer
875A C62C       LDB   #$2C   ,
875C E784       STB   ,X
875E 201A       BRA   $877A     ;read input into variables

8760 BD90F8     JSR   $90F8     ;print '?' to DEVN
8763 BD90F5     JSR   $90F5     ;print a space to DEVN
8766 BDB5C6     JSR   $B5C6     ;line input from DEVN
8769 2405       BCC   $8770
876B 3264       LEAS  4,S
876D 7E8541     JMP   $8541     ;BREAK
8770 C630       LDB   #$30      ;?IE ERROR
8772 0D70       TST   <$70      ;eof flag
8774 269C       BNE   $8712
8776 39         RTS

*** READ

8777 9E33       LDX   <$33      ;READ pointer
8779 864F       LDA   #$4F
877B 9709       STA   <$09
877D 9F35       STX   <$35
877F BD8A94     JSR   $8A94     ;get varptr of variable in X
8782 9F3B       STX   <$3B
8784 9EA6       LDX   <$A6      ;BASIC source pointer
8786 9F2B       STX   <$2B
8788 9E35       LDX   <$35
878A A684       LDA   ,X
878C 260C       BNE   $879A
878E 9609       LDA   <$09
8790 2658       BNE   $87EA
8792 BD017C     JSR   $017C     ;PATCH - re-request input
8795 BD90F8     JSR   $90F8     ;print '?' to DEVN
8798 8DC6       BSR   $8760
879A 9FA6       STX   <$A6      ;BASIC source pointer
879C 9D9F       JSR   <$9F      ;get next character from BASIC source
879E D606       LDB   <$06      ;numeric / string flag
87A0 2727       BEQ   $87C9
87A2 9EA6       LDX   <$A6      ;BASIC source pointer
87A4 9701       STA   <$01
87A6 8122       CMPA  #$22   "
87A8 2712       BEQ   $87BC
87AA 301F       LEAX  -1,X
87AC 4F         CLRA
87AD 9701       STA   <$01
87AF BDB595     JSR   $B595     ;initialise virtual DEVN device
87B2 0D6E       TST   <$6E      ;cassette IO flag
87B4 2606       BNE   $87BC     ;IO in progress
87B6 863A       LDA   #$3A   :
87B8 9701       STA   <$01
87BA 862C       LDA   #$2C   ,
87BC 9702       STA   <$02
87BE BD8C61     JSR   $8C61     ;compile literal string at X
87C1 BD897A     JSR   $897A
87C4 BD86D7     JSR   $86D7     ;assign string variable
87C7 2006       BRA   $87CF
87C9 BD94BD     JSR   $94BD     ;read numeric constant into FPA1
87CC BD93DE     JSR   $93DE     ;assign FPA1 to varptr in <$3b
87CF 9DA5       JSR   <$A5      ;get current character from BASIC source
87D1 2706       BEQ   $87D9
87D3 812C       CMPA  #$2C   ,
87D5 1026FF33  LBNE   $870C     ;take action for illegal input
87D9 9EA6       LDX   <$A6      ;BASIC source pointer
87DB 9F35       STX   <$35
87DD 9E2B       LDX   <$2B
87DF 9FA6       STX   <$A6      ;BASIC source pointer
87E1 9DA5       JSR   <$A5      ;get current character from BASIC source
87E3 2721       BEQ   $8806
87E5 BD89AA     JSR   $89AA     ;skip comma
87E8 2095       BRA   $877F
87EA 9FA6       STX   <$A6      ;BASIC source pointer
87EC BD861B     JSR   $861B     ;find end of statement
87EF 3001       LEAX  1,X
87F1 4D         TSTA
87F2 260A       BNE   $87FE
87F4 C606       LDB   #$06
87F6 EE81       LDU   ,X++
87F8 2741       BEQ   $883B
87FA EC81       LDD   ,X++
87FC DD31       STD   <$31      ;line number of current DATA statement
87FE A684       LDA   ,X
8800 8186       CMPA  #$86
8802 26E6       BNE   $87EA
8804 2094       BRA   $879A
8806 9E35       LDX   <$35
8808 D609       LDB   <$09
880A 1026FD0A  LBNE   $8518
880E A684       LDA   ,X
8810 2706       BEQ   $8818
8812 8E8818     LDX   #$8818
8815 7E90E5     JMP   $90E5     ;print string to DEVN
8818 39         RTS

*** string used by INPUT

8819  3F45585452412049474E4F5245440D00   ;/?EXTRA IGNORED/CR

*** NEXT

8829 2604       BNE   $882F     ;control variable specified
882B 9E8A       LDX   <$8A      ;zero
882D 2003       BRA   $8832
882F BD8A94     JSR   $8A94     ;get varptr of variable in X
8832 9F3B       STX   <$3B
8834 BD82F7     JSR   $82F7     ;examine BASIC stack
8837 2704       BEQ   $883D     ;found match
8839 C600       LDB   #$00      ;?NF ERROR
883B 2047       BRA   $8884
883D 1F14       TFR   X,S       ;point stack to this entry
883F 3003       LEAX  3,X       ;point X to STEP value
8841 BD93BF     JSR   $93BF     ;load variable into FPA1 (X is varptr)
8844 A668       LDA   8,S       ;sign of STEP value
8846 9754       STA   <$54
8848 9E3B       LDX   <$3B      ;varptr of control variable
884A BD910B     JSR   $910B     ;add varptr X to FPA1
884D BD93DE     JSR   $93DE     ;assign FPA1 to varptr in <$3b
8850 3069       LEAX  9,S       ;point X to terminating value
8852 BD9441     JSR   $9441     ;compare FPA1 - varptr X
8855 E068       SUBB  8,S       ;test depends on step direction
8857 270C       BEQ   $8865     ;terminating condition met
8859 AE6E       LDX   14,S
885B 9F68       STX   <$68      ;current line number
885D AEE810     LDX   16,S
8860 9FA6       STX   <$A6      ;BASIC source pointer
8862 7E849F     JMP   $849F     ;interpreter loop
8865 32E812     LEAS  18,S      ;finished with this entry
8868 9DA5       JSR   <$A5      ;get current character from BASIC source
886A 812C       CMPA  #$2C   ,
886C 26F4       BNE   $8862     ;no more variables after NEXT
886E 9D9F       JSR   <$9F      ;get next character from BASIC source
8870 8DBD       BSR   $882F     ;BSR used for correct stack structure
                                 ;(never returns to $8872)

*** get numeric expression into FPA1

8872 8D13       BSR   $8887     ;get expression

*** cause error if expression last evaluated not numeric

8874 1CFE       ANDCC #$FE
8876 7D         TST

*** cause error if expression last evaluated not string

(8877 1A01       ORCC  #$01)
8879 0D06       TST   <$06      ;numeric / string flag
887B 2503       BCS   $8880
887D 2A99       BPL   $8818     ;RTS
887F 8C         CMPX  #
(8880 2B96       BMI   $8818)   ;RTS
8882 C618       LDB   #$18      ;?TM ERROR
8884 7E8344     JMP   $8344     ;cause error

*** get expression

8887 8D6E       BSR   $88F7     ;move source pointer back one
8889 4F         CLRA
888A 8C         CMPX  #
(888B 3404       PSHS  B)
888D 3402       PSHS  A
888F C601       LDB   #$01
8891 BD8331     JSR   $8331     ;memory check
8894 BD8954     JSR   $8954     ;evaluate sub-expression
8897 0F3F       CLR   <$3F      ;flag used for relational operators
8899 9DA5       JSR   <$A5      ;get current character from BASIC source
889B 80CA       SUBA  #$CA      ;branch to $88B2 if token is not in the set
889D 2513       BCS   $88B2     ;  [ >, =, < ]
889F 8103       CMPA  #$03      ;
88A1 240F       BCC   $88B2     ;
88A3 8101       CMPA  #$01       ;map [0, 1, 2] to [1, 2, 4]
88A5 49         ROLA             ;
88A6 983F       EORA  <$3F      ;determine valid combination of > = <
88A8 913F       CMPA  <$3F      ;
88AA 2564       BCS   $8910     ;?SN ERROR
88AC 973F       STA   <$3F
88AE 9D9F       JSR   <$9F      ;get next character from BASIC source
88B0 20E9       BRA   $889B

*** 

88B2 D63F       LDB   <$3F      ; $3f = [ 1, 2, 3, 4, 5, 6 ]
88B4 2633       BNE   $88E9     ; for   [ >  =  >= <  <> <= ]
88B6 1024006B  LBCC   $8925
88BA 8B07       ADDA  #$07
88BC 2467       BCC   $8925     ;not a binary operator
88BE 9906       ADCA  <$06      ; A = A + 1 + ($06)
88C0 10270491  LBEQ   $8D55     ; '+' in a string expression
88C4 89FF       ADCA  #$FF      ; A = A - 1 if numeric expression
88C6 3402       PSHS  A         ;
88C8 48         ASLA            ;
88C9 ABE0       ADDA  ,S+       ; A = A * 3
88CB 8E8294     LDX   #$8294    ;binary operator precedence table
88CE 3086       LEAX  A,X
88D0 3502       PULS  A         ;precedence of last operator
88D2 A184       CMPA  ,X
88D4 2455       BCC   $892B     ;new op. has a lower precedence
88D6 8D9C       BSR   $8874     ;validate numeric expression
88D8 3402       PSHS  A
88DA 8D29       BSR   $8905     ;push op handler & FPA1 / get expression
88DC 9E3D       LDX   <$3D
88DE 3502       PULS  A
88E0 261D       BNE   $88FF
88E2 4D         TSTA
88E3 1027006A  LBEQ   $8951     ;LDB <$4F  RTS
88E7 204B       BRA   $8934

*** set up precedence / handler for rel. op.

88E9 0806       ASL   <$06      ;numeric / string flag
88EB 59         ROLB
88EC 8D09       BSR   $88F7     ;move source pointer back one
88EE 8E88FC     LDX   #$88FC
88F1 D73F       STB   <$3F
88F3 0F06       CLR   <$06      ;numeric / string flag
88F5 20D9       BRA   $88D0

*** move source pointer back one

88F7 9EA6       LDX   <$A6      ;BASIC source pointer
88F9 7E85EE     JMP   $85EE     ;subtract 1 from X & store in $a6

*** rel. op. precedence & handler

88FC  64  8A31

88FF A184       CMPA  ,X
8901 2431       BCC   $8934
8903 20D3       BRA   $88D8

*** push op handler & FPA1 onto stack / get expression

8905 EC01       LDD   1,X       ;op handler
8907 3406       PSHS  A,B
8909 8D08       BSR   $8913     ;push FPA1 onto stack
890B D63F       LDB   <$3F      ;rel. op. flag
890D 16FF7B     LBRA  $888B     ;get expression

8910 7E89B4     JMP   $89B4     ;?SN ERROR

*** push FPA1 onto stack

8913 D654       LDB   <$54
8915 A684       LDA   ,X
8917 3520       PULS  Y
8919 3404       PSHS  B
891B D64F       LDB   <$4F
891D 9E50       LDX   <$50
891F DE52       LDU   <$52
8921 3454       PSHS  B,X,U
8923 6EA4       JMP   ,Y

*** end of expression / execute operator

8925 9E8A       LDX   <$8A      ;zero
8927 A6E0       LDA   ,S+
8929 2726       BEQ   $8951     ;LDB <$4F  RTS
892B 8164       CMPA  #$64   d
892D 2703       BEQ   $8932
892F BD8874     JSR   $8874     ;validate numeric expression
8932 9F3D       STX   <$3D
8934 3504       PULS  B
8936 815A       CMPA  #$5A   Z
8938 2719       BEQ   $8953     ;RTS
893A 817D       CMPA  #$7D
893C 2715       BEQ   $8953     ;RTS
893E 54         LSRB            ;sets carry if rel. op. was for string
893F D70A       STB   <$0A      ;
8941 3552       PULS  A,X,U     ;pull FPA2 off stack
8943 975C       STA   <$5C      ;set $62 up with sign difference
8945 9F5D       STX   <$5D      ;
8947 DF5F       STU   <$5F      ;LDB <$4F
8949 3504       PULS  B         ;
894B D761       STB   <$61      ;RTS calls operator handler
894D D854       EORB  <$54      ;(with carry from above)
894F D762       STB   <$62      ;
8951 D64F       LDB   <$4F      ;
8953 39         RTS             ;

*** evaluate sub-expression ('+' & '-' treated as signs)

8954 BD018B     JSR   $018B     ;PATCH - evaluate expression
8957 0F06       CLR   <$06      ;numeric / string flag
8959 9D9F       JSR   <$9F      ;get next character from BASIC source
895B 2403       BCC   $8960
895D 7E94BD     JMP   $94BD     ;read numeric constant into FPA1
8960 BD8ADF     JSR   $8ADF     ;carry clear if A-Z
8963 245C       BCC   $89C1     ;evaluate variable
8965 812E       CMPA  #$2E   .
8967 27F4       BEQ   $895D
8969 81C4       CMPA  #$C4      ;token -
896B 274C       BEQ   $89B9     ;read expression & negate
896D 81C3       CMPA  #$C3      ;token +
896F 27E3       BEQ   $8954     ;ignore +
8971 8122       CMPA  #$22   "
8973 260A       BNE   $897F
8975 9EA6       LDX   <$A6      ;BASIC source pointer
8977 BD8C5B     JSR   $8C5B     ;compile literal string at X
897A 9E64       LDX   <$64
897C 9FA6       STX   <$A6      ;move source pointer to end of string
897E 39         RTS
897F 81C0       CMPA  #$C0      ;token NOT
8981 260D       BNE   $8990
8983 865A       LDA   #$5A   Z
8985 BD888B     JSR   $888B
8988 BD8B2D     JSR   $8B2D     ;read signed number from FPA1 to $52 & D
898B 43         COMA
898C 53         COMB
898D 7E8C37     JMP   $8C37     ;assign D to FPA1
8990 81BE       CMPA  #$BE      ;token FN
8992 1027132E  LBEQ   $9CC4
8996 8126       CMPA  #$26   &
8998 1027127F  LBEQ   $9C1B     ;read octal or hex number into $52 / $53
899C 4C         INCA
899D 272E       BEQ   $89CD     ;evaluate function
899F 8D06       BSR   $89A7     ;skip open bracket (only legal chr. left)
89A1 BD8887     JSR   $8887     ;get expression

*** check for close bracket

89A4 C629       LDB   #$29   )
89A6 8C         CMPX  #

*** check for open bracket

(89A7 C628       LDB   #$28)
89A9 8C         CMPX  #

*** check for comma

(89AA C62C       LDB   #$2C)

*** check for character in B

89AC E19F00A6   CMPB ($00A6)
89B0 2602       BNE   $89B4     ;?SN ERROR
89B2 0E9F       JMP   <$9F      ;get next character from BASIC source
89B4 C602       LDB   #$02      ;?SN ERROR
89B6 7E8344     JMP   $8344     ;cause error

*** read expression & negate FPA1

89B9 867D       LDA   #$7D
89BB BD888B     JSR   $888B
89BE 7E96DE     JMP   $96DE     ;COM $54 if FPA1 non zero

*** evaluate variable

89C1 BD8A94     JSR   $8A94     ;get varptr of variable in X
89C4 9F52       STX   <$52
89C6 9606       LDA   <$06      ;numeric / string flag
89C8 2689       BNE   $8953     ;RTS (string)
89CA 7E93BF     JMP   $93BF     ;load variable into FPA1 (X is varptr)

*** evaluate function

89CD 9D9F       JSR   <$9F      ;get next character from BASIC source
89CF 1F89       TFR   A,B
89D1 58         ASLB
89D2 9D9F       JSR   <$9F      ;get next character from BASIC source
89D4 C142       CMPB  #$42
89D6 2304       BLS   $89DC
89D8 6E9F0132   JMP  ($0132)    ;disk function despatch
89DC 3404       PSHS  B
89DE C12C       CMPB  #$2C
89E0 2522       BCS   $8A04     ;functions with single arguments
89E2 C134       CMPB  #$34
89E4 2420       BCC   $8A06     ;functions with special or no arguments
89E6 8DBF       BSR   $89A7     ;skip open bracket
89E8 A6E4       LDA   ,S
89EA 8132       CMPA  #$32
89EC 2418       BCC   $8A06     ;not LEFT$, RIGHT$ or MID$
89EE BD8887     JSR   $8887     ;get expression
89F1 8DB7       BSR   $89AA     ;skip comma
89F3 BD8877     JSR   $8877     ;validate string
89F6 3502       PULS  A
89F8 DE52       LDU   <$52
89FA 3442       PSHS  A,U
89FC BD8E51     JSR   $8E51     ;get number into B
89FF 3502       PULS  A
8A01 3406       PSHS  A,B
8A03 8E         LDX   #
(8A04 8D99       BSR   $899F)   ;get expression inside brackets
8A06 3504       PULS  B
8A08 BE0128     LDX   $0128     ;function despatch table
8A0B 3A         ABX
8A0C AD94       JSR  (,X)
8A0E 7E8874     JMP   $8874     ;validate numeric expression

*** OR

8A11 86         LDA   #

*** AND

(8A12 4F         CLRA)
8A13 9703       STA   <$03
8A15 BD8B2D     JSR   $8B2D     ;read signed number from FPA1 to $52 & D
8A18 DD01       STD   <$01
8A1A BD93F5     JSR   $93F5     ;copy FPA2 to FPA1
8A1D BD8B2D     JSR   $8B2D     ;read signed number from FPA1 to $52 & D
8A20 0D03       TST   <$03
8A22 2606       BNE   $8A2A
8A24 9401       ANDA  <$01
8A26 D402       ANDB  <$02
8A28 2004       BRA   $8A2E
8A2A 9A01       ORA   <$01
8A2C DA02       ORB   <$02
8A2E 7E8C37     JMP   $8C37     ;assign D to FPA1

*** handler for relational operators

8A31 BD8879     JSR   $8879     ;validate string / numeric using carry
8A34 2610       BNE   $8A46     ;valid string
8A36 9661       LDA   <$61
8A38 8A7F       ORA   #$7F
8A3A 945D       ANDA  <$5D
8A3C 975D       STA   <$5D
8A3E 8E005C     LDX   #$005C    ;FPA2
8A41 BD9441     JSR   $9441     ;compare FPA1 - varptr X
8A44 2036       BRA   $8A7C
8A46 0F06       CLR   <$06      ;numeric / string flag
8A48 0A3F       DEC   <$3F
8A4A BD8D9D     JSR   $8D9D     ;point X to string just compiled & len in B
8A4D D756       STB   <$56
8A4F 9F58       STX   <$58
8A51 9E5F       LDX   <$5F
8A53 BD8D9F     JSR   $8D9F     ;point X to string & length in B
8A56 9656       LDA   <$56
8A58 3404       PSHS  B
8A5A A0E0       SUBA  ,S+
8A5C 2707       BEQ   $8A65
8A5E 8601       LDA   #$01
8A60 2403       BCC   $8A65
8A62 D656       LDB   <$56
8A64 40         NEGA
8A65 9754       STA   <$54
8A67 DE58       LDU   <$58
8A69 5C         INCB
8A6A 5A         DECB
8A6B 2604       BNE   $8A71
8A6D D654       LDB   <$54
8A6F 200B       BRA   $8A7C
8A71 A680       LDA   ,X+
8A73 A1C0       CMPA  ,U+
8A75 27F3       BEQ   $8A6A
8A77 C6FF       LDB   #$FF
8A79 2401       BCC   $8A7C
8A7B 50         NEGB
8A7C CB01       ADDB  #$01      ;map [-1, 0, 1] to [1, 2, 4]
8A7E 59         ROLB            ;
8A7F D40A       ANDB  <$0A      ;rel. op. number
8A81 2702       BEQ   $8A85
8A83 C6FF       LDB   #$FF
8A85 7E9427     JMP   $9427     ;assign B to FPA1 (result of relation)

8A88 BD89AA     JSR   $89AA     ;skip comma

*** DIM

8A8B C601       LDB   #$01
8A8D 8D08       BSR   $8A97     ;create variable
8A8F 9DA5       JSR   <$A5      ;get current character from BASIC source
8A91 26F5       BNE   $8A88     ;skip comma & read next array
8A93 39         RTS

*** gets VARPTR address of following variable
    set $08 to #$80 to exclude array variables
    creates new variable if not found
    returns $39 = X = varptr address

8A94 5F         CLRB
8A95 9DA5       JSR   <$A5      ;get current character from BASIC source

*** set B to cause error if array variable already exists

8A97 D705       STB   <$05
8A99 9737       STA   <$37
8A9B 9DA5       JSR   <$A5      ;get current character from BASIC source
8A9D 8D40       BSR   $8ADF     ;carry clear if A-Z
8A9F 1025FF11  LBCS   $89B4     ;?SN ERROR
8AA3 5F         CLRB
8AA4 D706       STB   <$06      ;numeric / string flag
8AA6 9D9F       JSR   <$9F      ;get next character from BASIC source
8AA8 2504       BCS   $8AAE
8AAA 8D33       BSR   $8ADF     ;carry clear if A-Z
8AAC 250A       BCS   $8AB8
8AAE 1F89       TFR   A,B
8AB0 9D9F       JSR   <$9F      ;get next character from BASIC source
8AB2 25FC       BCS   $8AB0
8AB4 8D29       BSR   $8ADF     ;carry clear if A-Z
8AB6 24F8       BCC   $8AB0
8AB8 8124       CMPA  #$24   $
8ABA 2606       BNE   $8AC2     ;numeric variable
8ABC 0306       COM   <$06      ;numeric / string flag
8ABE CB80       ADDB  #$80
8AC0 9D9F       JSR   <$9F      ;get next character from BASIC source
8AC2 D738       STB   <$38
8AC4 9A08       ORA   <$08      ;set $08 to #$80 to exclude array variables
8AC6 8028       SUBA  #$28   (
8AC8 10270078  LBEQ   $8B44     ;array variable
8ACC 0F08       CLR   <$08
8ACE 9E1B       LDX   <$1B      ;start of simple variables
8AD0 DC37       LDD   <$37
8AD2 9C1D       CMPX  <$1D      ;start of array variables
8AD4 2712       BEQ   $8AE8     ;not found - create variable
8AD6 10A381     CMPD  ,X++
8AD9 273E       BEQ   $8B19     ;found existing variable - STX <$39 & RTS
8ADB 3005       LEAX  5,X
8ADD 20F3       BRA   $8AD2     ;keep looking

*** clear carry if A contains 'A'-'Z'

8ADF 8141       CMPA  #$41   A
8AE1 2504       BCS   $8AE7
8AE3 805B       SUBA  #$5B   [
8AE5 80A5       SUBA  #$A5
8AE7 39         RTS

*** create variable

8AE8 8E008A     LDX   #$008A
8AEB EEE4       LDU   ,S
8AED 118389C4   CMPU  #$89C4    ;if called by evaluate variable routine - RTS
8AF1 2728       BEQ   $8B1B      ;(with X pointing to zero)
8AF3 DC1F       LDD   <$1F      ;end of BASIC storage
8AF5 DD43       STD   <$43
8AF7 C30007     ADDD  #$0007
8AFA DD41       STD   <$41
8AFC 9E1D       LDX   <$1D      ;start of array variables
8AFE 9F47       STX   <$47
8B00 BD831C     JSR   $831C     ;move memory contents up
8B03 9E41       LDX   <$41
8B05 9F1F       STX   <$1F      ;end of BASIC storage
8B07 9E45       LDX   <$45
8B09 9F1D       STX   <$1D      ;start of array variables
8B0B 9E47       LDX   <$47
8B0D DC37       LDD   <$37      ;variable name
8B0F ED81       STD   ,X++
8B11 4F         CLRA
8B12 5F         CLRB
8B13 ED84       STD   ,X
8B15 ED02       STD   2,X
8B17 A704       STA   4,X
8B19 9F39       STX   <$39
8B1B 39         RTS

8B1C  90 80 00 00 00        ;FP constant -32768

*** read unsigned number into $52 & D

8B21 9D9F       JSR   <$9F      ;get next character from BASIC source
8B23 BD8872     JSR   $8872     ;read numeric expression into FPA1
8B26 BD8874     JSR   $8874     ;validate numeric expression

*** read +ve number from FPA1 into $52 & D

8B29 9654       LDA   <$54
8B2B 2B60       BMI   $8B8D     ;?FC ERROR

*** read signed number from FPA1 into $52 & D

8B2D BD8874     JSR   $8874     ;validate numeric expression
8B30 964F       LDA   <$4F
8B32 8190       CMPA  #$90
8B34 2508       BCS   $8B3E
8B36 8E8B1C     LDX   #$8B1C    ;only 16 bit number allowed is -32768
8B39 BD9441     JSR   $9441     ;compare FPA1 - varptr X
8B3C 264F       BNE   $8B8D     ;?FC ERROR
8B3E BD9473     JSR   $9473     ;denormalize FPA1 to an integer
8B41 DC52       LDD   <$52
8B43 39         RTS

*** get varptr of variable continued (handle arrays)

8B44 D605       LDB   <$05
8B46 9606       LDA   <$06      ;numeric / string flag
8B48 3406       PSHS  A,B
8B4A 5F         CLRB
8B4B 9E37       LDX   <$37
8B4D 3414       PSHS  B,X
8B4F 8DD0       BSR   $8B21     ;read unsigned number into $52 & D
8B51 3534       PULS  B,X,Y
8B53 9F37       STX   <$37
8B55 DE52       LDU   <$52
8B57 3460       PSHS  Y,U
8B59 5C         INCB
8B5A 9DA5       JSR   <$A5      ;get current character from BASIC source
8B5C 812C       CMPA  #$2C   ,
8B5E 27EB       BEQ   $8B4B     ;get next dimension
8B60 D703       STB   <$03      ;number of dimensions
8B62 BD89A4     JSR   $89A4     ;skip close bracket
8B65 3506       PULS  A,B
8B67 9706       STA   <$06      ;numeric / string flag
8B69 D705       STB   <$05
8B6B 9E1D       LDX   <$1D      ;start of array variables
8B6D 9C1F       CMPX  <$1F      ;end of BASIC storage
8B6F 2721       BEQ   $8B92     ;not found - create new array
8B71 DC37       LDD   <$37
8B73 10A384     CMPD  ,X
8B76 2706       BEQ   $8B7E     ;found array name
8B78 EC02       LDD   2,X
8B7A 308B       LEAX  D,X
8B7C 20EF       BRA   $8B6D     ;keep looking
8B7E C612       LDB   #$12      ;?DD ERROR
8B80 9605       LDA   <$05
8B82 260B       BNE   $8B8F     ;cause error if array exists & $05 set
8B84 D603       LDB   <$03
8B86 E104       CMPB  4,X
8B88 2759       BEQ   $8BE3     ;correct number of dimensions
8B8A C610       LDB   #$10      ;?BS ERROR
8B8C 8C         CMPX  #
(8B8D C608       LDB   #$08)    ;?FC ERROR
8B8F 7E8344     JMP   $8344     ;cause error
8B92 CC0005     LDD   #$0005    ;bytes per element
8B95 DD64       STD   <$64
8B97 DC37       LDD   <$37
8B99 ED84       STD   ,X        ;array name
8B9B D603       LDB   <$03
8B9D E704       STB   4,X       ;number of dimensions
8B9F BD8331     JSR   $8331     ;memory check
8BA2 9F41       STX   <$41      ;start of array header
8BA4 C60B       LDB   #$0B      ;default number of elements
8BA6 4F         CLRA
8BA7 0D05       TST   <$05
8BA9 2705       BEQ   $8BB0
8BAB 3506       PULS  A,B
8BAD C30001     ADDD  #$0001
8BB0 ED05       STD   5,X
8BB2 8D5D       BSR   $8C11     ;D = word at 5,X * word at $64
8BB4 DD64       STD   <$64
8BB6 3002       LEAX  2,X
8BB8 0A03       DEC   <$03
8BBA 26E8       BNE   $8BA4     ;next dimension
8BBC 9F0F       STX   <$0F      ;start of array element storage
8BBE D30F       ADDD  <$0F      ;D = end of array
8BC0 1025F77E  LBCS   $8342     ;?OM ERROR
8BC4 1F01       TFR   D,X
8BC6 BD8335     JSR   $8335     ;memory check (also adds #$3a to D)
8BC9 830035     SUBD  #$0035
8BCC DD1F       STD   <$1F      ;end of BASIC storage
8BCE 4F         CLRA
8BCF 301F       LEAX  -1,X      ;clear array
8BD1 A705       STA   5,X       ;
8BD3 9C0F       CMPX  <$0F      ;
8BD5 26F8       BNE   $8BCF     ;
8BD7 9E41       LDX   <$41      ;array header
8BD9 961F       LDA   <$1F      ;end of BASIC storage
8BDB 9341       SUBD  <$41
8BDD ED02       STD   2,X       ;offset to next array (when it's created)
8BDF 9605       LDA   <$05
8BE1 262D       BNE   $8C10     ;RTS
8BE3 E604       LDB   4,X
8BE5 D703       STB   <$03
8BE7 4F         CLRA
8BE8 5F         CLRB
8BE9 DD64       STD   <$64
8BEB 3506       PULS  A,B
8BED DD52       STD   <$52
8BEF 10A305     CMPD  5,X
8BF2 243A       BCC   $8C2E     ;?BS ERROR
8BF4 DE64       LDU   <$64
8BF6 2704       BEQ   $8BFC
8BF8 8D17       BSR   $8C11     ;D = word at 5,X * word at $64
8BFA D352       ADDD  <$52
8BFC 3002       LEAX  2,X
8BFE 0A03       DEC   <$03
8C00 26E7       BNE   $8BE9
8C02 EDE3       STD   ,--S      ;
8C04 58         ASLB            ;
8C05 49         ROLA            ;
8C06 58         ASLB            ;
8C07 49         ROLA            ;
8C08 E3E1       ADDD  ,S++      ; D = D * 5
8C0A 308B       LEAX  D,X
8C0C 3005       LEAX  5,X
8C0E 9F39       STX   <$39
8C10 39         RTS

*** D = word at 5,X * word at $64

8C11 8610       LDA   #$10
8C13 9745       STA   <$45
8C15 EC05       LDD   5,X
8C17 DD17       STD   <$17
8C19 4F         CLRA
8C1A 5F         CLRB
8C1B 58         ASLB
8C1C 49         ROLA
8C1D 250F       BCS   $8C2E     ;?BS ERROR
8C1F 0865       ASL   <$65
8C21 0964       ROL   <$64
8C23 2404       BCC   $8C29
8C25 D317       ADDD  <$17
8C27 2505       BCS   $8C2E     ;?BS ERROR
8C29 0A45       DEC   <$45
8C2B 26EE       BNE   $8C1B
8C2D 39         RTS

8C2E 7E8B8A     JMP   $8B8A     ;?BS ERROR

*** MEM

8C31 1F40       TFR   S,D
8C33 7E9FCE     JMP   $9FCE     ; ...continued

*** assign B to FPA1

8C36 4F         CLRA

*** assign D to FPA1 (signed)

8C37 0F06       CLR   <$06      ;numeric / string flag
8C39 DD50       STD   <$50
8C3B C690       LDB   #$90
8C3D 7E942D     JMP   $942D     ;signed assign!

*** STR$

8C40 BD8874     JSR   $8874     ;validate numeric expression
8C43 CE03D9     LDU   #$03D9
8C46 BD958A     JSR   $958A     ;convert FPA1 to string at U
8C49 3262       LEAS  2,S       ;lose return address
8C4B 8E03D8     LDX   #$03D8
8C4E 200B       BRA   $8C5B     ;compile literal string at X

*** reserve B bytes of string space
    returns X = $58 = start of requested block
            B = $56 = length of block

8C50 9F4D       STX   <$4D
8C52 8D5F       BSR   $8CB3     ;reserve B bytes of string space
8C54 9F58       STX   <$58
8C56 D756       STB   <$56
8C58 39         RTS

*** register a delimited string pointed to by X
    if string is in keyboard buffer, then copy it into free string space.
    stores string start, end & length in $62, $64 & $56
    string start also in $58
    if copied to string space, start & end also in $58 & $4d

8C59 301F       LEAX  -1,X
8C5B 8622       LDA   #$22   "
8C5D 9701       STA   <$01
8C5F 9702       STA   <$02
8C61 3001       LEAX  1,X
8C63 9F62       STX   <$62
8C65 9F58       STX   <$58
8C67 C6FF       LDB   #$FF
8C69 5C         INCB
8C6A A680       LDA   ,X+
8C6C 270C       BEQ   $8C7A
8C6E 9101       CMPA  <$01
8C70 2704       BEQ   $8C76
8C72 9102       CMPA  <$02
8C74 26F3       BNE   $8C69
8C76 8122       CMPA  #$22   "
8C78 2702       BEQ   $8C7C
8C7A 301F       LEAX  -1,X
8C7C 9F64       STX   <$64
8C7E D756       STB   <$56
8C80 BD0197     JSR   $0197     ;PATCH - reset BASIC memory
8C83 DE62       LDU   <$62
8C85 118303D9   CMPU  #$03D9
8C89 2207       BHI   $8C92     ;push temp string onto varptr stack
8C8B 8DC3       BSR   $8C50     ;reserve B bytes of string space
8C8D 9E62       LDX   <$62
8C8F BD8D8B     JSR   $8D8B     ;copy string of length B from X+ to ($25)+
8C92 9E0B       LDX   <$0B
8C94 8C01D1     CMPX  #$01D1
8C97 2605       BNE   $8C9E
8C99 C61E       LDB   #$1E      ;?ST ERROR
8C9B 7E8344     JMP   $8344     ;cause error
8C9E 9656       LDA   <$56
8CA0 A784       STA   ,X
8CA2 DC58       LDD   <$58
8CA4 ED02       STD   2,X
8CA6 86FF       LDA   #$FF
8CA8 9706       STA   <$06      ;numeric / string flag
8CAA 9F0D       STX   <$0D
8CAC 9F52       STX   <$52
8CAE 3005       LEAX  5,X
8CB0 9F0B       STX   <$0B
8CB2 39         RTS

*** reserve B bytes of string space
    returns X = pointer to requested block & B = length
    requested block also in $25

8CB3 0F07       CLR   <$07
8CB5 4F         CLRA
8CB6 3406       PSHS  A,B
8CB8 DC23       LDD   <$23      ;top of free string space
8CBA A3E0       SUBD  ,S+
8CBC 109321     CMPD  <$21      ;stack root / string storage start
8CBF 250A       BCS   $8CCB     ;not enough space
8CC1 DD23       STD   <$23      ;new free pointer
8CC3 9E23       LDX   <$23
8CC5 3001       LEAX  1,X
8CC7 9F25       STX   <$25      ;points to requested block
8CC9 3584       PULS  B,PC

8CCB C61A       LDB   #$1A      ;?OS ERROR
8CCD 0307       COM   <$07
8CCF 27CA       BEQ   $8C9B     ;already done garbage collect - give up
8CD1 8D04       BSR   $8CD7     ;string garbage collect
8CD3 3504       PULS  B
8CD5 20DE       BRA   $8CB5     ;try to reserve space again

*** string space garbage collect

8CD7 9E27       LDX   <$27      ;top of BASIC RAM
8CD9 9F23       STX   <$23      ;top of free string space
8CDB 4F         CLRA
8CDC 5F         CLRB
8CDD DD4B       STD   <$4B
8CDF 9E21       LDX   <$21      ;stack root / string storage start
8CE1 9F47       STX   <$47
8CE3 8E01A9     LDX   #$01A9
8CE6 9C0B       CMPX  <$0B
8CE8 2704       BEQ   $8CEE
8CEA 8D32       BSR   $8D1E
8CEC 20F8       BRA   $8CE6
8CEE 9E1B       LDX   <$1B      ;start of simple variables
8CF0 9C1D       CMPX  <$1D      ;start of array variables
8CF2 2704       BEQ   $8CF8
8CF4 8D22       BSR   $8D18
8CF6 20F8       BRA   $8CF0
8CF8 9F41       STX   <$41
8CFA 9E41       LDX   <$41
8CFC 9C1F       CMPX  <$1F      ;end of BASIC storage
8CFE 2735       BEQ   $8D35
8D00 EC02       LDD   2,X
8D02 D341       ADDD  <$41
8D04 DD41       STD   <$41
8D06 A601       LDA   1,X
8D08 2AF0       BPL   $8CFA
8D0A E604       LDB   4,X
8D0C 58         ASLB
8D0D CB05       ADDB  #$05
8D0F 3A         ABX
8D10 9C41       CMPX  <$41
8D12 27E8       BEQ   $8CFC
8D14 8D08       BSR   $8D1E
8D16 20F8       BRA   $8D10
8D18 A601       LDA   1,X
8D1A 3002       LEAX  2,X
8D1C 2A14       BPL   $8D32
8D1E E684       LDB   ,X
8D20 2710       BEQ   $8D32
8D22 EC02       LDD   2,X
8D24 109323     CMPD  <$23      ;top of free string space
8D27 2209       BHI   $8D32
8D29 109347     CMPD  <$47
8D2C 2304       BLS   $8D32
8D2E 9F4B       STX   <$4B
8D30 DD47       STD   <$47
8D32 3005       LEAX  5,X
8D34 39         RTS
8D35 9E4B       LDX   <$4B
8D37 27FB       BEQ   $8D34
8D39 4F         CLRA
8D3A E684       LDB   ,X
8D3C 5A         DECB
8D3D D347       ADDD  <$47
8D3F DD43       STD   <$43
8D41 9E23       LDX   <$23      ;top of free string space
8D43 9F41       STX   <$41
8D45 BD831E     JSR   $831E     ;move memory contents up (no memory check)
8D48 9E4B       LDX   <$4B
8D4A DC45       LDD   <$45
8D4C ED02       STD   2,X
8D4E 9E45       LDX   <$45
8D50 301F       LEAX  -1,X
8D52 7E8CD9     JMP   $8CD9

*** handle '+' in a string expression (concatenate)

8D55 DC52       LDD   <$52
8D57 3406       PSHS  A,B
8D59 BD8954     JSR   $8954     ;evaluate sub-expression
8D5C BD8877     JSR   $8877     ;validate string expression
8D5F 3510       PULS  X
8D61 9F62       STX   <$62
8D63 E684       LDB   ,X
8D65 9E52       LDX   <$52
8D67 EB84       ADDB  ,X        ;add string lengths
8D69 2405       BCC   $8D70     ;not too long
8D6B C61C       LDB   #$1C      ;?LS ERROR
8D6D 7E8344     JMP   $8344     ;cause error
8D70 BD8C50     JSR   $8C50     ;reserve B bytes of string space
8D73 9E62       LDX   <$62
8D75 E684       LDB   ,X
8D77 8D10       BSR   $8D89     ;copy string (len B) from varptr X to ($25)+
8D79 9E4D       LDX   <$4D
8D7B 8D22       BSR   $8D9F     ;point X to string & length in B
8D7D 8D0C       BSR   $8D8B     ;copy string of length B from X+ to ($25)+
8D7F 9E62       LDX   <$62
8D81 8D1C       BSR   $8D9F     ;point X to string & length in B
8D83 BD8C92     JSR   $8C92     ;push temp string onto varptr stack
8D86 7E8899     JMP   $8899     ;back to expression handler

*** copy string of length B from varptr X to ($25)+

8D89 AE02       LDX   2,X

*** copy string of length B from X+ to ($25)+

8D8B DE25       LDU   <$25
8D8D 5C         INCB
8D8E 2004       BRA   $8D94
8D90 A680       LDA   ,X+
8D92 A7C0       STA   ,U+
8D94 5A         DECB
8D95 26F9       BNE   $8D90
8D97 DF25       STU   <$25
8D99 39         RTS

*** validate result of string expression
    point X to 1st character & length in B
    (if it is the most recent temp string then delete it)

8D9A BD8877     JSR   $8877     ;validate string expression
8D9D 9E52       LDX   <$52
8D9F E684       LDB   ,X
8DA1 8D18       BSR   $8DBB     ;if X is top of string stack then pull it
8DA3 2613       BNE   $8DB8     ;normal varptr
8DA5 AE07       LDX   7,X
8DA7 301F       LEAX  -1,X
8DA9 9C23       CMPX  <$23      ;top of free string space
8DAB 2608       BNE   $8DB5
8DAD 3404       PSHS  B
8DAF D323       ADDD  <$23      ;top of free string space
8DB1 DD23       STD   <$23      ;top of free string space
8DB3 3504       PULS  B
8DB5 3001       LEAX  1,X
8DB7 39         RTS
8DB8 AE02       LDX   2,X
8DBA 39         RTS

*** if X is top of string stack then pull it

8DBB 9C0D       CMPX  <$0D
8DBD 2607       BNE   $8DC6
8DBF 9F0B       STX   <$0B
8DC1 301B       LEAX  -5,X
8DC3 9F0D       STX   <$0D
8DC5 4F         CLRA
8DC6 39         RTS

*** LEN

8DC7 8D03       BSR   $8DCC     ;validate string & test length
8DC9 7E8C36     JMP   $8C36     ;assign B to FPA1

*** validate string & test length

8DCC 8DCC       BSR   $8D9A     ;validate string & point X to it
8DCE 0F06       CLR   <$06      ;numeric / string flag
8DD0 5D         TSTB
8DD1 39         RTS

*** CHR$

8DD2 BD8E54     JSR   $8E54     ;read 8 bit value into B from FPA1
8DD5 C601       LDB   #$01
8DD7 BD8CB3     JSR   $8CB3     ;reserve B bytes of string space
8DDA 9653       LDA   <$53
8DDC BD8C54     JSR   $8C54     ;store string details as for temp string
8DDF A784       STA   ,X
8DE1 3262       LEAS  2,S
8DE3 7E8C92     JMP   $8C92     ;push temp string onto varptr stack

*** ASC

8DE6 8D02       BSR   $8DEA     ;get 1st character of string into B
8DE8 20DF       BRA   $8DC9     ;assign B to FPA1

*** get 1st character of string into B

8DEA 8DE0       BSR   $8DCC     ;validate string & test length
8DEC 275E       BEQ   $8E4C     ;?FC ERROR
8DEE E684       LDB   ,X
8DF0 39         RTS

*** LEFT$

8DF1 8D48       BSR   $8E3B     ;get str varptr in X & $4D, arg. in A & B
8DF3 4F         CLRA
8DF4 E184       CMPB  ,X
8DF6 2303       BLS   $8DFB     ;number of chrs <= string length
8DF8 E684       LDB   ,X
8DFA 4F         CLRA
8DFB 3406       PSHS  A,B
8DFD BD8C52     JSR   $8C52     ;reserve B bytes of string space
8E00 9E4D       LDX   <$4D
8E02 8D9B       BSR   $8D9F     ;point X to string & length in B
8E04 3504       PULS  B
8E06 3A         ABX             ;adjust string start for MID$ / RIGHT$
8E07 3504       PULS  B
8E09 BD8D8B     JSR   $8D8B     ;copy string of length B from X+ to ($25)+
8E0C 20D5       BRA   $8DE3     ;push temp string onto varptr stack

*** RIGHT$

8E0E 8D2B       BSR   $8E3B     ;get str varptr in X & $4D, arg. in A & B
8E10 A084       SUBA  ,X
8E12 40         NEGA            ;A = string length - argument
8E13 20DF       BRA   $8DF4     ;create new string

*** MID$

8E15 C6FF       LDB   #$FF      ;default length
8E17 D753       STB   <$53
8E19 9DA5       JSR   <$A5      ;get current character from BASIC source
8E1B 8129       CMPA  #$29   )
8E1D 2705       BEQ   $8E24     ;length not specified
8E1F BD89AA     JSR   $89AA     ;skip comma
8E22 8D2D       BSR   $8E51     ;get number into B (& $53)
8E24 8D15       BSR   $8E3B     ;get str varptr in X & $4D, arg. in A & B
8E26 2724       BEQ   $8E4C     ;?FC ERROR
8E28 5F         CLRB
8E29 4A         DECA            ;A = pos - 1
8E2A A184       CMPA  ,X
8E2C 24CD       BCC   $8DFB     ;pos past end - create empty string
8E2E 1F89       TFR   A,B
8E30 E084       SUBB  ,X
8E32 50         NEGB            ;B = string length - pos
8E33 D153       CMPB  <$53
8E35 23C4       BLS   $8DFB     ;no. of chrs available <= requested length
8E37 D653       LDB   <$53
8E39 20C0       BRA   $8DFB     ;use requested length

*** called by LEFT$, RIGHT$ & MID$
    get string varptr in X & $4D, argument in A & B

8E3B BD89A4     JSR   $89A4     ;skip close bracket
8E3E EEE4       LDU   ,S
8E40 AE65       LDX   5,S
8E42 9F4D       STX   <$4D
8E44 A664       LDA   4,S
8E46 E664       LDB   4,S
8E48 3267       LEAS  7,S
8E4A 1F35       TFR   U,PC

8E4C 7E8B8D     JMP   $8B8D     ;?FC ERROR

*** skip character & get 8 bit value into B

8E4F 9D9F       JSR   <$9F      ;get next character from BASIC source

*** read 8 bit value into B

8E51 BD8872     JSR   $8872     ;read numeric expression into FPA1

*** read 8 bit value into B from FPA1

8E54 BD8B26     JSR   $8B26     ;read unsigned number into $52 & D from FPA1
8E57 4D         TSTA
8E58 26F2       BNE   $8E4C     ;?FC ERROR
8E5A 0EA5       JMP   <$A5      ;get current character from BASIC source

*** VAL

8E5C BD8DCC     JSR   $8DCC     ;validate string & test length
8E5F 1027031F  LBEQ   $9182     ;clear exponents in FPA1 ($4f & $54)
8E63 DEA6       LDU   <$A6      ;save source pointer
8E65 9FA6       STX   <$A6      ;point source pointer to start of string
8E67 3A         ABX
8E68 A684       LDA   ,X        ;save byte at end of string
8E6A 3452       PSHS  A,X,U
8E6C 6F84       CLR   ,X        ;put a zero at end of string
8E6E 9DA5       JSR   <$A5      ;get current character from BASIC source
8E70 BD94BD     JSR   $94BD     ;read numeric expression into FPA1
8E73 3552       PULS  A,X,U
8E75 A784       STA   ,X        ;restore byte at end of string
8E77 DFA6       STU   <$A6      ;restore source pointer
8E79 39         RTS

*** read pair of numbers from command
    1st in $2b / $2c & 2nd in B

8E7A 8D07       BSR   $8E83     ;read 16 bit number into X
8E7C 9F2B       STX   <$2B
8E7E BD89AA     JSR   $89AA     ;skip comma
8E81 20CE       BRA   $8E51     ;get number into B

*** read 16 bit unsigned number into X

8E83 BD8872     JSR   $8872     ;read numeric expression into FPA1

*** read 16 bit unsigned number into X from FPA1

8E86 9654       LDA   <$54
8E88 2BC2       BMI   $8E4C     ;?FC ERROR
8E8A 964F       LDA   <$4F
8E8C 8190       CMPA  #$90
8E8E 22BC       BHI   $8E4C     ;?FC ERROR
8E90 BD9473     JSR   $9473     ;denormalize FPA1 to an integer
8E93 9E52       LDX   <$52
8E95 39         RTS

*** PEEK

8E96 8DEE       BSR   $8E86     ;read 16 bit number into X from FPA1
8E98 E684       LDB   ,X
8E9A 7E8C36     JMP   $8C36     ;assign B to FPA1

*** POKE

8E9D 8DDB       BSR   $8E7A     ;read pair of numbers into $2b/2c & B
8E9F 9E2B       LDX   <$2B
8EA1 E784       STB   ,X
8EA3 39         RTS

*** LLIST

8EA4 C6FE       LDB   #$FE
8EA6 D76F       STB   <$6F      ;DEVN
8EA8 9DA5       JSR   <$A5      ;get current character from BASIC source

*** LIST

8EAA 3401       PSHS  CC
8EAC BD869A     JSR   $869A     ;read line number & store in $2b
8EAF BD83FF     JSR   $83FF     ;search program for line number in <$2b
8EB2 9F66       STX   <$66
8EB4 3501       PULS  CC
8EB6 2712       BEQ   $8ECA
8EB8 9DA5       JSR   <$A5      ;get current character from BASIC source
8EBA 2713       BEQ   $8ECF
8EBC 81C4       CMPA  #$C4      ;token -
8EBE 2609       BNE   $8EC9
8EC0 9D9F       JSR   <$9F      ;get next character from BASIC source
8EC2 2706       BEQ   $8ECA
8EC4 BD869A     JSR   $869A     ;read line number & store in $2b
8EC7 2706       BEQ   $8ECF
8EC9 39         RTS
8ECA CEFFFF     LDU   #$FFFF
8ECD DF2B       STU   <$2B
8ECF 3262       LEAS  2,S
8ED1 9E66       LDX   <$66
8ED3 BD90A5     JSR   $90A5     ;initialise virtual DEVN device & new line
8ED6 BDB77B     JSR   $B77B     ;scan for BREAK & pause if DEVN is not -1
8ED9 EC84       LDD   ,X
8EDB 2608       BNE   $8EE5
8EDD BDB663     JSR   $B663     ;close DEVN stream
8EE0 0F6F       CLR   <$6F      ;DEVN
8EE2 7E8371     JMP   $8371     ;command mode
8EE5 9F66       STX   <$66
8EE7 EC02       LDD   2,X
8EE9 10932B     CMPD  <$2B
8EEC 22EF       BHI   $8EDD
8EEE BD957A     JSR   $957A     ;print unsigned number in D
8EF1 BD90F5     JSR   $90F5     ;print a space to DEVN
8EF4 9E66       LDX   <$66
8EF6 8D10       BSR   $8F08     ;detokenize BASIC line
8EF8 AE9F0066   LDX  ($0066)
8EFC CE02DD     LDU   #$02DD
8EFF A6C0       LDA   ,U+
8F01 27D0       BEQ   $8ED3
8F03 BD90FA     JSR   $90FA     ;output character to DEVN
8F06 20F7       BRA   $8EFF

*** detokenize BASIC line

8F08 BD01A6     JSR   $01A6     ;PATCH - detokenize
8F0B 3004       LEAX  4,X
8F0D 108E02DD   LDY   #$02DD
8F11 A680       LDA   ,X+
8F13 2751       BEQ   $8F66
8F15 2B15       BMI   $8F2C
8F17 813A       CMPA  #$3A   :
8F19 260D       BNE   $8F28
8F1B E684       LDB   ,X
8F1D C184       CMPB  #$84
8F1F 27F0       BEQ   $8F11
8F21 C183       CMPB  #$83
8F23 27EC       BEQ   $8F11
8F25 8C8621     CMPX  #$8621
8F28 8D30       BSR   $8F5A
8F2A 20E5       BRA   $8F11
8F2C CE0116     LDU   #$0116
8F2F 81FF       CMPA  #$FF
8F31 2604       BNE   $8F37
8F33 A680       LDA   ,X+
8F35 3345       LEAU  5,U
8F37 847F       ANDA  #$7F
8F39 334A       LEAU  10,U
8F3B 6DC4       TST   ,U
8F3D 27E7       BEQ   $8F26
8F3F A0C4       SUBA  ,U
8F41 2AF6       BPL   $8F39
8F43 ABC4       ADDA  ,U
8F45 EE41       LDU   1,U
8F47 4A         DECA
8F48 2B06       BMI   $8F50
8F4A 6DC0       TST   ,U+
8F4C 2AFC       BPL   $8F4A
8F4E 20F7       BRA   $8F47
8F50 A6C4       LDA   ,U
8F52 8D06       BSR   $8F5A
8F54 6DC0       TST   ,U+
8F56 2AF8       BPL   $8F50
8F58 20B7       BRA   $8F11
8F5A 108C03D6   CMPY  #$03D6
8F5E 2406       BCC   $8F66
8F60 847F       ANDA  #$7F
8F62 A7A0       STA   ,Y+
8F64 6FA4       CLR   ,Y
8F66 39         RTS

*** tokenize BASIC line

8F67 BD01A3     JSR   $01A3     ;PATCH - tokenize
8F6A 9EA6       LDX   <$A6      ;BASIC source pointer
8F6C CE02DC     LDU   #$02DC
8F6F 0F43       CLR   <$43
8F71 0F44       CLR   <$44
8F73 A680       LDA   ,X+
8F75 2721       BEQ   $8F98
8F77 0D43       TST   <$43
8F79 270F       BEQ   $8F8A
8F7B BD8ADF     JSR   $8ADF     ;carry clear if A-Z
8F7E 2418       BCC   $8F98
8F80 8130       CMPA  #$30   0
8F82 2504       BCS   $8F88
8F84 8139       CMPA  #$39   9
8F86 2310       BLS   $8F98
8F88 0F43       CLR   <$43
8F8A 8120       CMPA  #$20
8F8C 270A       BEQ   $8F98
8F8E 9742       STA   <$42
8F90 8122       CMPA  #$22   "
8F92 2738       BEQ   $8FCC
8F94 0D44       TST   <$44
8F96 2719       BEQ   $8FB1
8F98 A7C0       STA   ,U+
8F9A 2706       BEQ   $8FA2
8F9C 813A       CMPA  #$3A   :
8F9E 27CF       BEQ   $8F6F
8FA0 20D1       BRA   $8F73
8FA2 6FC0       CLR   ,U+
8FA4 6FC0       CLR   ,U+
8FA6 1F30       TFR   U,D
8FA8 8302DA     SUBD  #$02DA
8FAB 8E02DB     LDX   #$02DB
8FAE 9FA6       STX   <$A6      ;BASIC source pointer
8FB0 39         RTS
8FB1 813F       CMPA  #$3F   ?
8FB3 2604       BNE   $8FB9
8FB5 8687       LDA   #$87
8FB7 20DF       BRA   $8F98
8FB9 8127       CMPA  #$27   '
8FBB 2613       BNE   $8FD0
8FBD CC3A83     LDD   #$3A83
8FC0 EDC1       STD   ,U++
8FC2 0F42       CLR   <$42
8FC4 A680       LDA   ,X+
8FC6 27D0       BEQ   $8F98
8FC8 9142       CMPA  <$42
8FCA 27CC       BEQ   $8F98
8FCC A7C0       STA   ,U+
8FCE 20F4       BRA   $8FC4
8FD0 8130       CMPA  #$30   0
8FD2 2504       BCS   $8FD8
8FD4 813C       CMPA  #$3C   <
8FD6 25C0       BCS   $8F98
8FD8 301F       LEAX  -1,X
8FDA 3450       PSHS  X,U
8FDC 0F41       CLR   <$41
8FDE CE0116     LDU   #$0116
8FE1 0F42       CLR   <$42
8FE3 334A       LEAU  10,U
8FE5 A6C4       LDA   ,U
8FE7 2731       BEQ   $901A
8FE9 10AE41     LDY   1,U
8FEC AEE4       LDX   ,S
8FEE E6A0       LDB   ,Y+
8FF0 E080       SUBB  ,X+
8FF2 27FA       BEQ   $8FEE
8FF4 C180       CMPB  #$80
8FF6 2638       BNE   $9030
8FF8 3262       LEAS  2,S
8FFA 3540       PULS  U
8FFC DA42       ORB   <$42
8FFE 9641       LDA   <$41
9000 2606       BNE   $9008
9002 C184       CMPB  #$84
9004 2606       BNE   $900C
9006 863A       LDA   #$3A   :
9008 EDC1       STD   ,U++
900A 2094       BRA   $8FA0
900C E7C0       STB   ,U+
900E C186       CMPB  #$86
9010 2602       BNE   $9014
9012 0C44       INC   <$44
9014 C182       CMPB  #$82
9016 27AA       BEQ   $8FC2
9018 2086       BRA   $8FA0
901A CE011B     LDU   #$011B
901D 0341       COM   <$41
901F 26C0       BNE   $8FE1
9021 3550       PULS  X,U
9023 A680       LDA   ,X+
9025 A7C0       STA   ,U+
9027 BD8ADF     JSR   $8ADF     ;carry clear if A-Z
902A 25EC       BCS   $9018
902C 0343       COM   <$43
902E 20E8       BRA   $9018
9030 0C42       INC   <$42
9032 4A         DECA
9033 27AE       BEQ   $8FE3
9035 313F       LEAY  -1,Y
9037 E6A0       LDB   ,Y+
9039 2AFC       BPL   $9037
903B 20AF       BRA   $8FEC

*** PRINT

903D 2762       BEQ   $90A1     ;send CR to DEVN
903F 8D03       BSR   $9044
9041 0F6F       CLR   <$6F      ;DEVN
9043 39         RTS

9044 8140       CMPA  #$40   @
9046 2605       BNE   $904D
9048 BDB786     JSR   $B786     ;handle PRINT@
904B 200A       BRA   $9057
904D 8123       CMPA  #$23   #
904F 260D       BNE   $905E
9051 BDB7D7     JSR   $B7D7     ;read #-n & set up DEVN
9054 BDB63C     JSR   $B63C     ;if DEVN = -1, test cassette OK for output
9057 9DA5       JSR   <$A5      ;get current character from BASIC source
9059 2746       BEQ   $90A1     ;send CR to DEVN
905B BD89AA     JSR   $89AA     ;skip comma
905E 81CD       CMPA  #$CD      ;token USING
9060 102711C1  LBEQ   $A225
9064 2748       BEQ   $90AE     ;RTS
9066 81BB       CMPA  #$BB      ;token TAB(
9068 275D       BEQ   $90C7
906A 812C       CMPA  #$2C   ,
906C 2741       BEQ   $90AF
906E 813B       CMPA  #$3B   ;
9070 276E       BEQ   $90E0     ;skip semicolon
9072 BD8887     JSR   $8887     ;get expression
9075 9606       LDA   <$06      ;numeric / string flag
9077 3402       PSHS  A
9079 2606       BNE   $9081     ;string expression
907B BD9587     JSR   $9587     ;convert FPA1 to string at $3DA
907E BD8C59     JSR   $8C59     ;register string at X
9081 8D65       BSR   $90E8     ;print string just compiled
9083 3504       PULS  B
9085 BDB595     JSR   $B595     ;initialise virtual DEVN device
9088 0D6E       TST   <$6E      ;cassette IO flag
908A 2706       BEQ   $9092     ;no IO in progress
908C 8D13       BSR   $90A1     ;send CR to DEVN
908E 9DA5       JSR   <$A5      ;get current character from BASIC source
9090 20D2       BRA   $9064
9092 5D         TSTB
9093 2608       BNE   $909D     ;string just printed so no space
9095 9DA5       JSR   <$A5      ;get current character from BASIC source
9097 812C       CMPA  #$2C   ,
9099 2714       BEQ   $90AF
909B 8D58       BSR   $90F5     ;print a space to DEVN
909D 9DA5       JSR   <$A5      ;get current character from BASIC source
909F 26C5       BNE   $9066

*** send CR to DEVN

90A1 860D       LDA   #$0D
90A3 2055       BRA   $90FA     ;output character to DEVN

*** initialise virtual DEVN device & new line

90A5 BDB595     JSR   $B595     ;initialise virtual DEVN device
90A8 27F7       BEQ   $90A1     ;send CR to DEVN
90AA 966C       LDA   <$6C      ;device current column
90AC 26F3       BNE   $90A1     ;send CR to DEVN
90AE 39         RTS

*** called by PRINT to handle ,

90AF BDB595     JSR   $B595     ;initialise virtual DEVN device
90B2 270A       BEQ   $90BE
90B4 D66C       LDB   <$6C      ;device current column
90B6 D16B       CMPB  <$6B      ;device last comma field
90B8 2506       BCS   $90C0
90BA 8DE5       BSR   $90A1     ;send CR to DEVN
90BC 2022       BRA   $90E0
90BE D66C       LDB   <$6C      ;device current column
90C0 D06A       SUBB  <$6A      ;device comma field width
90C2 24FC       BCC   $90C0
90C4 50         NEGB
90C5 2010       BRA   $90D7

*** called by PRINT to handle TAB

90C7 BD8E4F     JSR   $8E4F     ;skip character & get number in B
90CA 8129       CMPA  #$29   )
90CC 1026F8E4  LBNE   $89B4     ;?SN ERROR
90D0 BDB595     JSR   $B595     ;initialise virtual DEVN device
90D3 D06C       SUBB  <$6C      ;device current column
90D5 2309       BLS   $90E0
90D7 0D6E       TST   <$6E      ;cassette IO flag
90D9 2605       BNE   $90E0     ;IO in progress
90DB 8D18       BSR   $90F5     ;print a space to DEVN
90DD 5A         DECB
90DE 26FB       BNE   $90DB
90E0 9D9F       JSR   <$9F      ;get next character from BASIC source
90E2 7E9064     JMP   $9064

*** print string to DEVN

90E5 BD8C5B     JSR   $8C5B     ;compile literal string at X
90E8 BD8D9D     JSR   $8D9D     ;point X to string just compiled & len in B
90EB 5C         INCB
90EC 5A         DECB
90ED 27BF       BEQ   $90AE     ;RTS
90EF A680       LDA   ,X+
90F1 8D07       BSR   $90FA     ;output character to DEVN
90F3 20F7       BRA   $90EC

*** print a space to DEVN

90F5 8620       LDA   #$20
90F7 8C         CMPX  #

*** print '?' to DEVN

(90F8 863F       LDA   #$3F)
90FA 7EB54A     JMP   $B54A     ;output character to DEVN

*** add 0.5 to FPA1

90FD 8E966E     LDX   #$966E    ;FP constant 0.5
9100 2009       BRA   $910B     ;add varptr X to FPA1

*** subtract FPA1 from varptr X

9102 BD92DA     JSR   $92DA     ;load FPA2 from varptr X
9105 0354       COM   <$54
9107 0362       COM   <$62
9109 2003       BRA   $910E

*** add varptr X to FPA1

910B BD92DA     JSR   $92DA     ;load FPA2 from varptr X
910E 5D         TSTB            ;FPA1 exponent
910F 102702E2  LBEQ   $93F5     ;copy FPA2 to FPA1 (because FPA1 zero)
9113 8E005C     LDX   #$005C    ;FPA2
9116 1F89       TFR   A,B       ;A = B = FPA2 exponent
9118 5D         TSTB
9119 276C       BEQ   $9187     ;RTS (FPA2 is zero)
911B D04F       SUBB  <$4F      ;B = FPA2 exponent - FPA1 exponent
911D 2769       BEQ   $9188     ;FPA1 & FPA2 same order
911F 250A       BCS   $912B     ;FPA1 higher order
9121 974F       STA   <$4F
9123 9661       LDA   <$61
9125 9754       STA   <$54
9127 8E004F     LDX   #$004F    ;FPA1
912A 50         NEGB
912B C1F8       CMPB  #$F8
912D 2F59       BLE   $9188     ;more than 8 bits to shift
912F 4F         CLRA
9130 6401       LSR   1,X
9132 BD9203     JSR   $9203     ;shift mantissa of varptr X right -B bits
9135 D662       LDB   <$62         ;(carries into A)
9137 2A0B       BPL   $9144     ;FPA1 & FPA2 same sign
9139 6301       COM   1,X       ;
913B 6302       COM   2,X       ;2's complement FPA1
913D 6303       COM   3,X       ;carry is picked up below
913F 6304       COM   4,X       ;
9141 43         COMA            ;
9142 8900       ADCA  #$00      ;
9144 9763       STA   <$63
9146 9653       LDA   <$53      ;
9148 9960       ADCA  <$60      ;add mantissa in FPA2 to FPA1
914A 9753       STA   <$53      ;
914C 9652       LDA   <$52      ;
914E 995F       ADCA  <$5F      ;
9150 9752       STA   <$52      ;
9152 9651       LDA   <$51      ;
9154 995E       ADCA  <$5E      ;
9156 9751       STA   <$51      ;
9158 9650       LDA   <$50      ;
915A 995D       ADCA  <$5D      ;
915C 9750       STA   <$50      ;
915E 5D         TSTB
915F 2A44       BPL   $91A5     ;signs were same
9161 2502       BCS   $9165     ;normalize FPA1
9163 8D5D       BSR   $91C2     ;2's complent mantissa in FPA1
9165 5F         CLRB
9166 9650       LDA   <$50
9168 262E       BNE   $9198     ;normalize bit-wise
916A 9651       LDA   <$51
916C 9750       STA   <$50
916E 9652       LDA   <$52
9170 9751       STA   <$51
9172 9653       LDA   <$53
9174 9752       STA   <$52
9176 9663       LDA   <$63
9178 9753       STA   <$53
917A 0F63       CLR   <$63
917C CB08       ADDB  #$08
917E C128       CMPB  #$28
9180 2DE4       BLT   $9166
9182 4F         CLRA
9183 974F       STA   <$4F
9185 9754       STA   <$54
9187 39         RTS
9188 8D6D       BSR   $91F7     ;shift mantissa of varptr X right -B bits
918A 5F         CLRB
918B 20A8       BRA   $9135

918D 5C         INCB
918E 0863       ASL   <$63
9190 0953       ROL   <$53
9192 0952       ROL   <$52
9194 0951       ROL   <$51
9196 0950       ROL   <$50
9198 2AF3       BPL   $918D
919A 964F       LDA   <$4F
919C 3404       PSHS  B
919E A0E0       SUBA  ,S+
91A0 974F       STA   <$4F
91A2 23DE       BLS   $9182     ;clear exponents in FPA1 ($4f & $54)
91A4 8C         CMPX  #
(91A5 2508       BCS   $91AF)
91A7 0863       ASL   <$63
91A9 8600       LDA   #$00
91AB 9763       STA   <$63
91AD 200C       BRA   $91BB
91AF 0C4F       INC   <$4F
91B1 2728       BEQ   $91DB     ;?OV ERROR
91B3 0650       ROR   <$50
91B5 0651       ROR   <$51
91B7 0652       ROR   <$52
91B9 0653       ROR   <$53
91BB 2404       BCC   $91C1
91BD 8D0D       BSR   $91CC     ;add the carry to mantissa in FPA1
91BF 27EE       BEQ   $91AF
91C1 39         RTS

*** 2's complement mantissa in FPA1

91C2 0354       COM   <$54
91C4 0350       COM   <$50
91C6 0351       COM   <$51
91C8 0352       COM   <$52
91CA 0353       COM   <$53
91CC 9E52       LDX   <$52
91CE 3001       LEAX  1,X
91D0 9F52       STX   <$52
91D2 2606       BNE   $91DA
91D4 9E50       LDX   <$50
91D6 3001       LEAX  1,X
91D8 9F50       STX   <$50
91DA 39         RTS

91DB C60A       LDB   #$0A      ;?OV ERROR
91DD 7E8344     JMP   $8344     ;cause error

*** shift $13 - $16 & $63 right -B bits
    (shifts 8 bits before testing B)

91E0 8E0012     LDX   #$0012
91E3 A604       LDA   4,X
91E5 9763       STA   <$63
91E7 A603       LDA   3,X
91E9 A704       STA   4,X
91EB A602       LDA   2,X
91ED A703       STA   3,X
91EF A601       LDA   1,X
91F1 A702       STA   2,X
91F3 965B       LDA   <$5B
91F5 A701       STA   1,X

*** shift mantissa of varptr X right -B bits

91F7 CB08       ADDB  #$08
91F9 2FE8       BLE   $91E3
91FB 9663       LDA   <$63
91FD C008       SUBB  #$08
91FF 270C       BEQ   $920D     ;RTS
9201 6701       ASR   1,X
9203 6602       ROR   2,X
9205 6603       ROR   3,X
9207 6604       ROR   4,X
9209 46         RORA
920A 5C         INCB
920B 26F4       BNE   $9201
920D 39         RTS

920E  8100000000     ;FP constant 1

*** log series coefficients

9213  03
9214  7F5E56CB79     ;FP constant .4342559419
9219  80139B0B64     ;FP constant .5765845412
921E  8076389316     ;FP constant .9618007592
9223  8238AA3B20     ;FP constant 2.885390073

9228  803504F334     ;FP constant root 2 / 2
922D  813504F334     ;FP constant root 2
9232  8080000000     ;FP constant -0.5
9237  80317217F8     ;FP constant ln2

*** LOG

923C BD9418     JSR   $9418     ;sets B to -1, 0 or 1 as per sign of FPA1
923F 102FF94A  LBLE   $8B8D     ;?FC ERROR
9243 8E9228     LDX   #$9228    ;FP constant root 2 / 2
9246 964F       LDA   <$4F
9248 8080       SUBA  #$80
924A 3402       PSHS  A
924C 8680       LDA   #$80
924E 974F       STA   <$4F
9250 BD910B     JSR   $910B     ;add varptr X to FPA1
9253 8E922D     LDX   #$922D    ;FP constant root 2
9256 BD933A     JSR   $933A     ;FPA1 = varptr X / FPA1
9259 8E920E     LDX   #$920E    ;FP constant 1
925C BD9102     JSR   $9102     ;FPA1 = varptr X - FPA1
925F 8E9213     LDX   #$9213    ;series coefficients
9262 BD9743     JSR   $9743     ;calculate odd power series
9265 8E9232     LDX   #$9232    ;FP constant -0.5
9268 BD910B     JSR   $910B     ;add varptr X to FPA1
926B 3504       PULS  B
926D BD9547     JSR   $9547     ;add B to FPA1
9270 8E9237     LDX   #$9237    ;FP constant ln2

*** multiply FPA1 by varptr X

9273 8D65       BSR   $92DA     ;load FPA2 from varptr X
9275 2762       BEQ   $92D9     ;RTS (FPA1 zero)
9277 8D7A       BSR   $92F3     ;add A to exponent in FPA1
9279 8600       LDA   #$00
927B 9713       STA   <$13
927D 9714       STA   <$14
927F 9715       STA   <$15
9281 9716       STA   <$16
9283 D653       LDB   <$53
9285 8D22       BSR   $92A9     ;multiply mantissa in FPA2 by B
9287 D663       LDB   <$63
9289 D7AE       STB   <$AE
928B D652       LDB   <$52
928D 8D1A       BSR   $92A9     ;multiply mantissa in FPA2 by B
928F D663       LDB   <$63
9291 D7AD       STB   <$AD
9293 D651       LDB   <$51
9295 8D12       BSR   $92A9     ;multiply mantissa in FPA2 by B
9297 D663       LDB   <$63
9299 D7AC       STB   <$AC
929B D650       LDB   <$50
929D 8D0E       BSR   $92AD
929F D663       LDB   <$63
92A1 D7AB       STB   <$AB
92A3 BD93B6     JSR   $93B6     ;copy mantissa from $13 - $16 to FPA1
92A6 7E9165     JMP   $9165     ;normalize FPA1

*** multiply mantissa in FPA2 by B
    accumulate result in $13 - $16 & $63 & shift result right 8 bits

92A9 1027FF33  LBEQ   $91E0     ;B=0 (shift $13 - $16 & $63 right 8 bits)
92AD 43         COMA
92AE 9613       LDA   <$13
92B0 56         RORB
92B1 2726       BEQ   $92D9     ;RTS
92B3 2416       BCC   $92CB
92B5 9616       LDA   <$16
92B7 9B60       ADDA  <$60
92B9 9716       STA   <$16
92BB 9615       LDA   <$15
92BD 995F       ADCA  <$5F
92BF 9715       STA   <$15
92C1 9614       LDA   <$14
92C3 995E       ADCA  <$5E
92C5 9714       STA   <$14
92C7 9613       LDA   <$13
92C9 995D       ADCA  <$5D
92CB 46         RORA
92CC 9713       STA   <$13
92CE 0614       ROR   <$14
92D0 0615       ROR   <$15
92D2 0616       ROR   <$16
92D4 0663       ROR   <$63
92D6 4F         CLRA
92D7 20D5       BRA   $92AE
92D9 39         RTS

*** load FPA2 from varptr X & set $62 with FPA1 / FPA2 sign difference 
    A = exponent from FPA2
    B = exponent from FPA1

92DA EC01       LDD   1,X
92DC 9761       STA   <$61
92DE 8A80       ORA   #$80
92E0 DD5D       STD   <$5D
92E2 D661       LDB   <$61
92E4 D854       EORB  <$54
92E6 D762       STB   <$62
92E8 EC03       LDD   3,X
92EA DD5F       STD   <$5F
92EC A684       LDA   ,X
92EE 975C       STA   <$5C
92F0 D64F       LDB   <$4F
92F2 39         RTS

*** add A to exponent in FPA1

92F3 4D         TSTA
92F4 2716       BEQ   $930C
92F6 9B4F       ADDA  <$4F
92F8 46         RORA
92F9 49         ROLA
92FA 2810       BVC   $930C
92FC 8B80       ADDA  #$80
92FE 974F       STA   <$4F
9300 270C       BEQ   $930E     ;clear exponents in FPA1 ($4f & $54)
9302 9662       LDA   <$62      ;sign difference FPA1 / FPA2
9304 9754       STA   <$54
9306 39         RTS

9307 9654       LDA   <$54
9309 43         COMA
930A 2002       BRA   $930E
930C 3262       LEAS  2,S
930E 102AFE70  LBPL   $9182     ;clear exponents in FPA1 ($4f & $54)
9312 7E91DB     JMP   $91DB     ;?OV ERROR

*** multiply FPA1 by 10

9315 BD940A     JSR   $940A     ;copy FPA1 to FPA2
9318 270D       BEQ   $9327
931A 8B02       ADDA  #$02      ; x4
931C 25F4       BCS   $9312     ;?OV ERROR
931E 0F62       CLR   <$62
9320 BD9116     JSR   $9116     ;add FPA2 to FPA1 (FPA1 exponent in A)
9323 0C4F       INC   <$4F      ;double result
9325 27EB       BEQ   $9312     ;?OV ERROR
9327 39         RTS

9328  8420000000     ;FP constant 10

*** divide FPA1 by 10

932D BD940A     JSR   $940A     ;copy FPA1 to FPA2
9330 8E9328     LDX   #$9328    ;FP constant 10
9333 5F         CLRB
9334 D762       STB   <$62
9336 BD93BF     JSR   $93BF     ;load variable into FPA1 (X is varptr)
9339 8C         CMPX  #

*** divide varptr X by FPA1

(933A 8D9E       BSR   $92DA)   ;load FPA2 from varptr X
933C 2773       BEQ   $93B1     ;?/0 ERROR (FPA1 zero)
933E 004F       NEG   <$4F
9340 8DB1       BSR   $92F3     ;add A to exponent in FPA1
9342 0C4F       INC   <$4F
9344 27CC       BEQ   $9312     ;?OV ERROR
9346 8E0013     LDX   #$0013
9349 C604       LDB   #$04
934B D703       STB   <$03
934D C601       LDB   #$01
934F 9650       LDA   <$50
9351 915D       CMPA  <$5D
9353 2613       BNE   $9368
9355 9651       LDA   <$51
9357 915E       CMPA  <$5E
9359 260D       BNE   $9368
935B 9652       LDA   <$52
935D 915F       CMPA  <$5F
935F 2607       BNE   $9368
9361 9653       LDA   <$53
9363 9160       CMPA  <$60
9365 2601       BNE   $9368
9367 43         COMA            ;identical mantissas - set carry
9368 1FA8       TFR   CC,A
936A 59         ROLB
936B 240A       BCC   $9377
936D E780       STB   ,X+
936F 0A03       DEC   <$03
9371 2B34       BMI   $93A7
9373 272E       BEQ   $93A3
9375 C601       LDB   #$01
9377 1F8A       TFR   A,CC
9379 250E       BCS   $9389
937B 0860       ASL   <$60
937D 095F       ROL   <$5F
937F 095E       ROL   <$5E
9381 095D       ROL   <$5D
9383 25E3       BCS   $9368
9385 2BC8       BMI   $934F
9387 20DF       BRA   $9368
9389 9660       LDA   <$60
938B 9053       SUBA  <$53
938D 9760       STA   <$60
938F 965F       LDA   <$5F
9391 9252       SBCA  <$52
9393 975F       STA   <$5F
9395 965E       LDA   <$5E
9397 9251       SBCA  <$51
9399 975E       STA   <$5E
939B 965D       LDA   <$5D
939D 9250       SBCA  <$50
939F 975D       STA   <$5D
93A1 20D8       BRA   $937B
93A3 C640       LDB   #$40   @
93A5 20D0       BRA   $9377
93A7 56         RORB
93A8 56         RORB
93A9 56         RORB
93AA D763       STB   <$63
93AC 8D08       BSR   $93B6     ;copy mantissa from $13 - $16 to FPA1
93AE 7E9165     JMP   $9165     ;normalize FPA1

93B1 C614       LDB   #$14      ;?/0 ERROR
93B3 7E8344     JMP   $8344     ;cause error

*** copy mantissa from $13 - $16 to FPA1

93B6 9E13       LDX   <$13
93B8 9F50       STX   <$50
93BA 9E15       LDX   <$15
93BC 9F52       STX   <$52
93BE 39         RTS

*** load variable into FPA1 (X is varptr)

93BF 3402       PSHS  A
93C1 EC01       LDD   1,X
93C3 9754       STA   <$54
93C5 8A80       ORA   #$80
93C7 DD50       STD   <$50
93C9 0F63       CLR   <$63
93CB E684       LDB   ,X
93CD AE03       LDX   3,X
93CF 9F52       STX   <$52
93D1 D74F       STB   <$4F
93D3 3582       PULS  A,PC

*** assign FPA1 to variable store $45 - $49

93D5 8E0045     LDX   #$0045
93D8 2006       BRA   $93E0     ;assign FPA1 to varptr in X

*** assign FPA1 to variable store $40 - $44

93DA 8E0040     LDX   #$0040
93DD 8C         CMPX  #

*** assign FPA1 to varptr in <$3b

(93DE 9E3B       LDX   <$3B)

*** assign FPA1 to varptr in X

93E0 964F       LDA   <$4F
93E2 A784       STA   ,X
93E4 9654       LDA   <$54
93E6 8A7F       ORA   #$7F
93E8 9450       ANDA  <$50
93EA A701       STA   1,X
93EC 9651       LDA   <$51
93EE A702       STA   2,X
93F0 DE52       LDU   <$52
93F2 EF03       STU   3,X
93F4 39         RTS

*** copy FPA2 to FPA1 (A = sign)

93F5 9661       LDA   <$61
93F7 9754       STA   <$54
93F9 9E5C       LDX   <$5C
93FB 9F4F       STX   <$4F
93FD 0F63       CLR   <$63
93FF 965E       LDA   <$5E
9401 9751       STA   <$51
9403 9654       LDA   <$54
9405 9E5F       LDX   <$5F
9407 9F52       STX   <$52
9409 39         RTS

*** copy FPA1 to FPA2 & test for exponent = 0

940A DC4F       LDD   <$4F
940C DD5C       STD   <$5C
940E 9E51       LDX   <$51
9410 9F5E       STX   <$5E
9412 9E53       LDX   <$53
9414 9F60       STX   <$60
9416 4D         TSTA
9417 39         RTS

*** sets B to -1, 0 or 1 according to sign of FPA1

9418 D64F       LDB   <$4F
941A 2708       BEQ   $9424
941C D654       LDB   <$54
941E 59         ROLB
941F C6FF       LDB   #$FF
9421 2501       BCS   $9424
9423 50         NEGB
9424 39         RTS

*** SGN

9425 8DF1       BSR   $9418     ;sets B to -1, 0 or 1 as per sign of FPA1
9427 D750       STB   <$50
9429 0F51       CLR   <$51
942B C688       LDB   #$88
942D 9650       LDA   <$50
942F 8080       SUBA  #$80      ;set carry according to sign
9431 D74F       STB   <$4F
9433 DC8A       LDD   <$8A      ;zero
9435 DD52       STD   <$52
9437 9763       STA   <$63
9439 9754       STA   <$54
943B 7E9161     JMP   $9161     ;normalize FPA1 (if carry clear, negate 1st)

*** ABS

943E 0F54       CLR   <$54      ;simply clear sign byte
9440 39         RTS

*** compare FPA1 - varptr X  (set B to -1, 0 or 1)

9441 E684       LDB   ,X
9443 27D3       BEQ   $9418     ;sets B to -1, 0 or 1 as per sign of FPA1
9445 E601       LDB   1,X
9447 D854       EORB  <$54
9449 2BD1       BMI   $941C     ;set B to -1 or 1 as per sign of FPA1

*** compare FPA1 - varptr X (of same sign)

944B D64F       LDB   <$4F
944D E184       CMPB  ,X
944F 261D       BNE   $946E
9451 E601       LDB   1,X
9453 CA7F       ORB   #$7F
9455 D450       ANDB  <$50
9457 E101       CMPB  1,X
9459 2613       BNE   $946E
945B D651       LDB   <$51
945D E102       CMPB  2,X
945F 260D       BNE   $946E
9461 D652       LDB   <$52
9463 E103       CMPB  3,X
9465 2607       BNE   $946E
9467 D653       LDB   <$53
9469 E004       SUBB  4,X
946B 2601       BNE   $946E
946D 39         RTS
946E 56         RORB            ;turn carry into sign
946F D854       EORB  <$54
9471 20AB       BRA   $941E     ;reduce B to +/- 1

*** denormalize FPA1 to an integer (but don't update exponent)

9473 D64F       LDB   <$4F
9475 273D       BEQ   $94B4     ;clear mantissa in FPA1
9477 C0A0       SUBB  #$A0
9479 9654       LDA   <$54
947B 2A05       BPL   $9482
947D 035B       COM   <$5B
947F BD91C4     JSR   $91C4     ;2's complement mantissa in FPA1 (not $54)
9482 8E004F     LDX   #$004F    ;FPA1
9485 C1F8       CMPB  #$F8
9487 2E06       BGT   $948F
9489 BD91F7     JSR   $91F7     ;shift mantissa of varptr X right -B bits
948C 0F5B       CLR   <$5B
948E 39         RTS
948F 0F5B       CLR   <$5B
9491 9654       LDA   <$54
9493 49         ROLA
9494 0650       ROR   <$50
9496 7E9203     JMP   $9203     ;shift mantissa of varptr X right -B bits

*** INT

9499 D64F       LDB   <$4F
949B C1A0       CMPB  #$A0      ;when exponent >= $A0, no fractional part
949D 241D       BCC   $94BC     ;RTS (already an integer)
949F 8DD2       BSR   $9473     ;denormalize FPA1 to an integer
94A1 D763       STB   <$63
94A3 9654       LDA   <$54
94A5 D754       STB   <$54
94A7 8080       SUBA  #$80
94A9 86A0       LDA   #$A0
94AB 974F       STA   <$4F
94AD 9653       LDA   <$53
94AF 9701       STA   <$01
94B1 7E9161     JMP   $9161     ;normalize FPA1 (if carry clear, negate 1st)

*** clear mantissa in FPA1

94B4 D750       STB   <$50
94B6 D751       STB   <$51
94B8 D752       STB   <$52
94BA D753       STB   <$53
94BC 39         RTS

*** read a numeric constant into FPA1

94BD 9E8A       LDX   <$8A      ;zero
94BF 9F54       STX   <$54
94C1 9F4F       STX   <$4F
94C3 9F51       STX   <$51
94C5 9F52       STX   <$52
94C7 9F47       STX   <$47      ;$47 & $48 = decimal exponent & sign 
94C9 9F45       STX   <$45      ;$45 & $46 decimal place counter & flag
94CB 2567       BCS   $9534     ;read sig. figs. into FPA1
94CD 8126       CMPA  #$26   &
94CF 10270748  LBEQ   $9C1B     ;read hex or octal
94D3 812D       CMPA  #$2D   -
94D5 2604       BNE   $94DB
94D7 0355       COM   <$55
94D9 2004       BRA   $94DF
94DB 812B       CMPA  #$2B   +
94DD 2604       BNE   $94E3
94DF 9D9F       JSR   <$9F      ;get next character from BASIC source
94E1 2551       BCS   $9534     ;read sig. figs. into FPA1
94E3 812E       CMPA  #$2E   .
94E5 2728       BEQ   $950F
94E7 8145       CMPA  #$45   E
94E9 2628       BNE   $9513     ;finished reading number, now finalise.
94EB 9D9F       JSR   <$9F      ;get next character from BASIC source
94ED 2564       BCS   $9553     ;read decimal exponent into $47
94EF 81C4       CMPA  #$C4      ;token -
94F1 270E       BEQ   $9501
94F3 812D       CMPA  #$2D   -
94F5 270A       BEQ   $9501
94F7 81C3       CMPA  #$C3      ;token +
94F9 2708       BEQ   $9503
94FB 812B       CMPA  #$2B   +
94FD 2704       BEQ   $9503
94FF 2006       BRA   $9507
9501 0348       COM   <$48
9503 9D9F       JSR   <$9F      ;get next character from BASIC source
9505 254C       BCS   $9553     ;read decimal exponent into $47
9507 0D48       TST   <$48
9509 2708       BEQ   $9513     ;finished reading number, now finalise.
950B 0047       NEG   <$47      ;-ve exponent
950D 2004       BRA   $9513     ;finished reading number, now finalise.
950F 0346       COM   <$46
9511 26CC       BNE   $94DF     ;1st decimal point encountered

*** finished reading number, now finalise.

9513 9647       LDA   <$47
9515 9045       SUBA  <$45
9517 9747       STA   <$47
9519 2712       BEQ   $952D
951B 2A09       BPL   $9526
951D BD932D     JSR   $932D     ;divide FPA1 by 10
9520 0C47       INC   <$47
9522 26F9       BNE   $951D
9524 2007       BRA   $952D
9526 BD9315     JSR   $9315     ;multiply FPA1 by 10
9529 0A47       DEC   <$47
952B 26F9       BNE   $9526
952D 9655       LDA   <$55
952F 2A8B       BPL   $94BC     ;RTS
9531 7E96DE     JMP   $96DE     ;COM $54 if FPA1 non zero

*** read sig. figs. into FPA1

9534 D645       LDB   <$45      ;increment decimal place counter
9536 D046       SUBB  <$46      ;if decimal point passed
9538 D745       STB   <$45      ;
953A 3402       PSHS  A
953C BD9315     JSR   $9315     ;multiply FPA1 by 10
953F 3504       PULS  B
9541 C030       SUBB  #$30   0
9543 8D02       BSR   $9547     ;add B to FPA1
9545 2098       BRA   $94DF

*** add B to FPA1

9547 BD93DA     JSR   $93DA     ;assign FPA1 to variable store $40 - $44
954A BD9427     JSR   $9427     ;assign B to FPA1
954D 8E0040     LDX   #$0040
9550 7E910B     JMP   $910B     ;add varptr X to FPA1

*** read decimal exponent into $47
    (note that it doesn't check for more than two digits)

9553 D647       LDB   <$47      ;
9555 58         ASLB            ;
9556 58         ASLB            ;
9557 DB47       ADDB  <$47      ;
9559 58         ASLB            ; B = 10 * $47
955A 8030       SUBA  #$30
955C 3404       PSHS  B
955E ABE0       ADDA  ,S+
9560 9747       STA   <$47
9562 209F       BRA   $9503

*** used by print number routine

9564  9B3EBC1FFD    ;FP constant 99999999.9
9569  9E6E6B27FD    ;FP constant 999999999
956E  9E6E6B2800    ;FP constant 1000000000

*** print 'IN xxxx' (current line number)

9573 8E82E5     LDX   #$82E5
9576 8D0C       BSR   $9584
9578 DC68       LDD   <$68      ;current line number

*** print unsigned number in D

957A DD50       STD   <$50
957C C690       LDB   #$90
957E 43         COMA            ;set carry for correct result
957F BD9431     JSR   $9431     ;normalize FPA1 using exponent in B
9582 8D03       BSR   $9587     ;convert FPA1 to string at $3DA
9584 7E90E5     JMP   $90E5     ;print string to DEVN

*** convert FPA1 to string at $3DA

9587 CE03DA     LDU   #$03DA
958A 8620       LDA   #$20
958C D654       LDB   <$54
958E 2A02       BPL   $9592
9590 862D       LDA   #$2D
9592 A7C0       STA   ,U+       ;print '-' for negative numbers else space
9594 DF64       STU   <$64
9596 9754       STA   <$54
9598 8630       LDA   #$30
959A D64F       LDB   <$4F
959C 102700C6  LBEQ   $9666     ;number is zero
95A0 4F         CLRA
95A1 C180       CMPB  #$80
95A3 2208       BHI   $95AD     ;number >= 1
95A5 8E956E     LDX   #$956E    ;FP constant 1000000000
95A8 BD9273     JSR   $9273     ;multiply varptr X & FPA1
95AB 86F7       LDA   #$F7      ;-9
95AD 9745       STA   <$45      ;decimal exponent
95AF 8E9569     LDX   #$9569    ;FP constant 999999999
95B2 BD944B     JSR   $944B     ;compare FPA1 - varptr X (of same sign)
95B5 2E0F       BGT   $95C6
95B7 8E9564     LDX   #$9564    ;FP constant 99999999.9
95BA BD944B     JSR   $944B     ;compare FPA1 - varptr X (of same sign)
95BD 2E0E       BGT   $95CD      ;(FPA1 is now 100000000 to 999999999)
95BF BD9315     JSR   $9315     ;multiply FPA1 by 10
95C2 0A45       DEC   <$45       ;correct exponent
95C4 20F1       BRA   $95B7
95C6 BD932D     JSR   $932D     ;divide FPA1 by 10
95C9 0C45       INC   <$45       ;correct exponent
95CB 20E2       BRA   $95AF
95CD BD90FD     JSR   $90FD     ;add 0.5 to FPA1 (round it up)
95D0 BD9473     JSR   $9473     ;denormalize FPA1 to an integer
95D3 C601       LDB   #$01      ;1 digit before point for sci. notation
95D5 9645       LDA   <$45
95D7 8B0A       ADDA  #$0A      ;exponent now 2 more than it should be
95D9 2B09       BMI   $95E4     ;actual exponent < -2 (use sci. notation)
95DB 810B       CMPA  #$0B
95DD 2405       BCC   $95E4     ;actual exponent >= 9 (use sci. notation)
95DF 4A         DECA
95E0 1F89       TFR   A,B       ;number of digits before point = exp + 1
95E2 8602       LDA   #$02
95E4 4A         DECA
95E5 4A         DECA
95E6 9747       STA   <$47      ;decimal exponent
95E8 D745       STB   <$45      ;number of digits before decimal point
95EA 2E0D       BGT   $95F9     ;no leading decimal point
95EC DE64       LDU   <$64
95EE 862E       LDA   #$2E
95F0 A7C0       STA   ,U+
95F2 5D         TSTB            ;can only be zero or -ve here
95F3 2704       BEQ   $95F9     ;no zero reqd after point & before 1st digit 
95F5 8630       LDA   #$30
95F7 A7C0       STA   ,U+
95F9 8E9673     LDX   #$9673
95FC C680       LDB   #$80      ;sign bit used for zero crossing logic
95FE 9653       LDA   <$53      ;resolves a decimal digit by adding powers
9600 AB03       ADDA  3,X       ;of 10 until zero is passed.
9602 9753       STA   <$53      ;
9604 9652       LDA   <$52      ;
9606 A902       ADCA  2,X       ;On 1st pass -ve values are used to get FPA1
9608 9752       STA   <$52      ;below zero. The digit is no. of loops - 1.
960A 9651       LDA   <$51      ;
960C A901       ADCA  1,X       ;On 2nd pass +ve values are used to get FPA1
960E 9751       STA   <$51      ;above zero. The digit is 10 - no. loops.
9610 9650       LDA   <$50      ;
9612 A984       ADCA  ,X        ;This continues with alternating signs.
9614 9750       STA   <$50
9616 5C         INCB            ;loop counter
9617 56         RORB            ;logic to test if zero passed
9618 59         ROLB            ;
9619 28E3       BVC   $95FE     ;
961B 2403       BCC   $9620     ;digit = loops - 1
961D C00B       SUBB  #$0B
961F 50         NEGB
9620 CB2F       ADDB  #$2F      ;1 less & ASCII conversion
9622 3004       LEAX  4,X
9624 1F98       TFR   B,A
9626 847F       ANDA  #$7F      ;lose sign bit
9628 A7C0       STA   ,U+
962A 0A45       DEC   <$45
962C 2604       BNE   $9632     ;haven't reached decimal point yet
962E 862E       LDA   #$2E
9630 A7C0       STA   ,U+
9632 53         COMB            ;alternates B between $00 & $80
9633 C480       ANDB  #$80      ;
9635 8C9697     CMPX  #$9697
9638 26C4       BNE   $95FE
963A A6C2       LDA   ,-U       ;backtrack over digits
963C 8130       CMPA  #$30      ;until non-zero found
963E 27FA       BEQ   $963A     ;
9640 812E       CMPA  #$2E
9642 2602       BNE   $9646     ;if no sig. figs. after decimal point
9644 335F       LEAU  -1,U      ;then lose it.
9646 862B       LDA   #$2B   +
9648 D647       LDB   <$47
964A 271C       BEQ   $9668     ;normal number (no decimal exponent)
964C 2A03       BPL   $9651     ;+ve exponent
964E 862D       LDA   #$2D   -
9650 50         NEGB
9651 A742       STA   2,U
9653 8645       LDA   #$45   E
9655 A741       STA   1,U
9657 862F       LDA   #$2F      ;convert B to ASCII number in D
9659 4C         INCA            ;
965A C00A       SUBB  #$0A      ;
965C 24FB       BCC   $9659     ;
965E CB3A       ADDB  #$3A      ;
9660 ED43       STD   3,U
9662 6F45       CLR   5,U       ;terminate string
9664 2004       BRA   $966A
9666 A7C4       STA   ,U
9668 6F41       CLR   1,U       ;terminate string
966A 8E03DA     LDX   #$03DA
966D 39         RTS

966E  8000000000    ;FP constant 0.5

*** table of 32 bit numbers used by convert number to string routine 
    (to resolve decimal digits)

9673  FA0A1F00      ; -100000000
9677  00989680      ;   10000000
967B  FFF0BDC0      ;   -1000000
967F  000186A0      ;     100000
9683  FFFFD8F0      ;     -10000
9687  000003E8      ;       1000
968B  FFFFFF9C      ;       -100
968F  0000000A      ;         10
9693  FFFFFFFF      ;         -1

*** SQR

9697 BD940A     JSR   $940A     ;copy FPA1 to FPA2
969A 8E966E     LDX   #$966E    ;FP constant 0.5

*** raise FPA2 to power varptr X

969D BD93BF     JSR   $93BF     ;load variable into FPA1 (X is varptr)
96A0 2771       BEQ   $9713     ;EXP
96A2 4D         TSTA
96A3 2609       BNE   $96AE
96A5 9654       LDA   <$54
96A7 102BFD06  LBMI   $93B1     ;?/0 ERROR
96AB 7E9183     JMP   $9183     ;clear FPA1 exponents
96AE 8E004A     LDX   #$004A
96B1 BD93E0     JSR   $93E0     ;assign FPA1 to varptr in X
96B4 5F         CLRB
96B5 9661       LDA   <$61
96B7 2A10       BPL   $96C9
96B9 BD9499     JSR   $9499     ;INT
96BC 8E004A     LDX   #$004A
96BF 9661       LDA   <$61
96C1 BD944B     JSR   $944B     ;compare FPA1 - varptr X (of same sign)
96C4 2603       BNE   $96C9
96C6 43         COMA
96C7 D601       LDB   <$01
96C9 BD93F7     JSR   $93F7     ;copy FPA2 to FPA1 & put A in $54
96CC 3404       PSHS  B
96CE BD923C     JSR   $923C     ;LOG
96D1 8E004A     LDX   #$004A
96D4 BD9273     JSR   $9273     ;multiply varptr X & FPA1
96D7 8D3A       BSR   $9713     ;EXP
96D9 3502       PULS  A
96DB 46         RORA
96DC 248F       BCC   $966D     ;RTS
96DE 964F       LDA   <$4F
96E0 2702       BEQ   $96E4
96E2 0354       COM   <$54
96E4 39         RTS

96E5  8138AA3B29    ;FP constant 1/ln 2

*** EXP series coefficient table
    values appear to be error compensated

96EA  07 
96EB  7134583E56    ;FP constant .0000214987637  (ln2)^7 / 7!
96F0  74167EB31B    ;FP constant .0001435231404  (ln2)^6 / 6!
96F5  772FEEE385    ;FP constant .001342263483   (ln2)^5 / 5!
96FA  7A1D841C2A    ;FP constant .009614017014   (ln2)^4 / 4!
96FF  7C6359580A    ;FP constant .05550512686    (ln2)^3 / 3!
9704  7E75FDE7C6    ;FP constant .2402263846     (ln2)^2 / 2!
9709  8031721810    ;FP constant .6931471862      ln2
970E  8100000000    ;FP constant 1

*** EXP

calculates exp(x) by first calculating q=x/ln2 such that exp(x) = 2^q
fractional part of q is used for good convergence
integer part of q is simply added to FPA1 exponent afterwards

9713 8E96E5     LDX   #$96E5    ;FP constant 1/ln 2
9716 8D37       BSR   $974F     ;multiply FPA1 by varptr X
9718 BD93DA     JSR   $93DA     ;assign FPA1 to variable store $40 - $44
971B 964F       LDA   <$4F
971D 8188       CMPA  #$88
971F 2503       BCS   $9724
9721 7E9307     JMP   $9307     ;?OV ERROR if FPA1 +ve else FPA1 = 0
9724 BD9499     JSR   $9499     ;INT
9727 9601       LDA   <$01      ;integer part of argument
9729 8B81       ADDA  #$81
972B 27F4       BEQ   $9721     ;?OV ERROR
972D 4A         DECA
972E 3402       PSHS  A
9730 8E0040     LDX   #$0040
9733 BD9102     JSR   $9102     ;FPA1 = varptr X - FPA1
9736 8E96EA     LDX   #$96EA    ;EXP coefficient table
9739 8D17       BSR   $9752     ;series calculation
973B 0F62       CLR   <$62
973D 3502       PULS  A
973F BD92F3     JSR   $92F3     ;add A to exponent in FPA1
9742 39         RTS

*** calculate odd power series
    
    X points to coefficient table (1st byte is n)
    x in FPA1
    result = (a0xx+a1)xx+a2)xx+a3 ...)xx+an) * x
    ( = a0*x^(2n+1) + a1*x^(2n-1) + ... + a(n-1)*x^3 + an*x )
    result in FPA1

9743 9F64       STX   <$64
9745 BD93DA     JSR   $93DA     ;assign FPA1 to variable store $40 - $44
9748 8D05       BSR   $974F     ;multiply varptr X & FPA1 (x squared)
974A 8D08       BSR   $9754     ;calculate series
974C 8E0040     LDX   #$0040
974F 7E9273     JMP   $9273     ;multiply varptr X & FPA1 (odd powers)

*** calculate power series (polynomial of nth order)
    
    X points to coefficient table (1st byte is n)
    x in FPA1
    result = (a0x+a1)x+a2)x+a3 ...)x+an
    ( = a0*x^n + a1*x^(n-1) + ... + a(n-1)*x + an )
    result in FPA1

9752 9F64       STX   <$64
9754 BD93D5     JSR   $93D5     ;assign FPA1 to variable store $45 - $49
9757 9E64       LDX   <$64
9759 E680       LDB   ,X+
975B D755       STB   <$55
975D 9F64       STX   <$64
975F 8DEE       BSR   $974F     ;multiply varptr X & FPA1
9761 9E64       LDX   <$64
9763 3005       LEAX  5,X
9765 9F64       STX   <$64
9767 BD910B     JSR   $910B     ;add varptr X to FPA1
976A 8E0045     LDX   #$0045
976D 0A55       DEC   <$55
976F 26EE       BNE   $975F
9771 39         RTS

*** RND

9772 BD9418     JSR   $9418     ;sets B to -1, 0 or 1 as per sign of FPA1
9775 2B21       BMI   $9798
9777 2715       BEQ   $978E
9779 8D10       BSR   $978B     ;INT
977B BD93DA     JSR   $93DA     ;assign FPA1 to variable store $40 - $44
977E 8D0E       BSR   $978E
9780 8E0040     LDX   #$0040
9783 8DCA       BSR   $974F     ;multiply varptr X & FPA1
9785 8E920E     LDX   #$920E    ;FP constant 1
9788 BD910B     JSR   $910B     ;add varptr X to FPA1
978B 7E9499     JMP   $9499     ;INT
978E BE0116     LDX   $0116
9791 9F50       STX   <$50
9793 BE0118     LDX   $0118
9796 9F52       STX   <$52
9798 BE97C7     LDX   $97C7
979B 9F5D       STX   <$5D
979D BE97C9     LDX   $97C9
97A0 9F5F       STX   <$5F
97A2 BD9279     JSR   $9279     ;multiply FPA1 by mantissa in FPA2
97A5 DCAD       LDD   <$AD
97A7 C3658B     ADDD  #$658B
97AA FD0118     STD   $0118
97AD DD52       STD   <$52
97AF DCAB       LDD   <$AB
97B1 C9B0       ADCB  #$B0
97B3 8905       ADCA  #$05
97B5 FD0116     STD   $0116
97B8 DD50       STD   <$50
97BA 0F54       CLR   <$54
97BC 8680       LDA   #$80
97BE 974F       STA   <$4F
97C0 9615       LDA   <$15
97C2 9763       STA   <$63
97C4 7E9165     JMP   $9165     ;normalize FPA1

*** RND multiplier

97C7 40E64DAB

*** COS ... cos x = sin (x+pi/2)

97CB 8E983F     LDX   #$983F    ;FP constant pi/2
97CE BD910B     JSR   $910B     ;add varptr X to FPA1

*** SIN

97D1 BD940A     JSR   $940A     ;copy FPA1 to FPA2
97D4 8E9844     LDX   #$9844    ;FP constant 2*pi
97D7 D661       LDB   <$61
97D9 BD9334     JSR   $9334     ;STB $62 & divide FPA2 by varptr X (result FPA1)
97DC BD940A     JSR   $940A     ;copy FPA1 to FPA2
97DF 8DAA       BSR   $978B     ;INT
97E1 0F62       CLR   <$62
97E3 965C       LDA   <$5C
97E5 D64F       LDB   <$4F
97E7 BD9105     JSR   $9105     ;subtract FPA1 from FPA2 (B=FPA1 exponent)
97EA 8E9849     LDX   #$9849    ;FP constant 0.25
97ED BD9102     JSR   $9102     ;FPA1 = varptr X - FPA1
97F0 9654       LDA   <$54
97F2 3402       PSHS  A
97F4 2A09       BPL   $97FF     ;angle is 1st quadrant
97F6 BD90FD     JSR   $90FD     ;add 0.5 to FPA1
97F9 9654       LDA   <$54
97FB 2B05       BMI   $9802
97FD 030A       COM   <$0A
97FF BD96DE     JSR   $96DE     ;COM $54 if FPA1 non zero
9802 8E9849     LDX   #$9849    ;FP constant 0.25
9805 BD910B     JSR   $910B     ;add varptr X to FPA1
9808 3502       PULS  A
980A 4D         TSTA
980B 2A03       BPL   $9810
980D BD96DE     JSR   $96DE     ;COM $54 if FPA1 non zero
9810 8E984E     LDX   #$984E    ;series coefficients
9813 7E9743     JMP   $9743     ;calculate odd power series

*** TAN ... tan x = sin x / cos x

9816 BD93DA     JSR   $93DA     ;assign FPA1 to variable store $40 - $44
9819 0F0A       CLR   <$0A
981B 8DB4       BSR   $97D1     ;SIN
981D 8E004A     LDX   #$004A
9820 BD93E0     JSR   $93E0     ;assign FPA1 to varptr in X
9823 8E0040     LDX   #$0040
9826 BD93BF     JSR   $93BF     ;load variable into FPA1 (X is varptr)
9829 0F54       CLR   <$54
982B 960A       LDA   <$0A
982D 8D0C       BSR   $983B     ;must calculate cos
982F 0D4F       TST   <$4F
9831 1027F9A6  LBEQ   $91DB     ;?OV ERROR
9835 8E004A     LDX   #$004A
9838 7E933A     JMP   $933A     ;FPA1 = varptr X / FPA1
983B 3402       PSHS  A
983D 20C0       BRA   $97FF

983F  81490FDAA2    ;FP constant pi/2
9844  83490FDAA2    ;FP constant 2*pi
9849  7F00000000    ;FP constant 0.25

*** sin series coefficient table
    values appear to be error compensated

984E  05
984F  84E61A2D1B    ;FP constant -14.38139067   -(2pi)^11 / 11!
9854  862807FBF8    ;FP constant  42.00779712    (2pi)^9 / 9!
9859  8799688901    ;FP constant -76.70417025   -(2pi)^7 / 7!
985E  872335DFE1    ;FP constant  81.60522368    (2pi)^5 / 5!
9863  86A55DE728    ;FP constant -41.34170211   -(2pi)^3 / 3!
9868  83490FDAA2    ;FP constant  2*pi

986D  A154468F13    ;FP constant  7324114470
9872  8F524389CD    ;FP constant  26913.76914

*** ATN

    calculates atn(x) or pi/2-atn(1/x)
    same result either way but series only works -1 < x <= 1

9877 9654       LDA   <$54
9879 3402       PSHS  A
987B 2A02       BPL   $987F
987D 8D23       BSR   $98A2     ;COM $54 if FPA1 non zero
987F 964F       LDA   <$4F
9881 3402       PSHS  A
9883 8181       CMPA  #$81
9885 2505       BCS   $988C
9887 8E920E     LDX   #$920E    ;FP constant 1
988A 8DAC       BSR   $9838     ;divide varptr X by FPA1
988C 8E98A6     LDX   #$98A6    ;series coefficients
988F 8D82       BSR   $9813     ;calculate odd power series
9891 3502       PULS  A
9893 8181       CMPA  #$81
9895 2506       BCS   $989D
9897 8E983F     LDX   #$983F    ;FP constant pi/2
989A BD9102     JSR   $9102     ;FPA1 = varptr X - FPA1
989D 3502       PULS  A
989F 4D         TSTA
98A0 2A03       BPL   $98A5
98A2 7E96DE     JMP   $96DE     ;COM $54 if FPA1 non zero
98A5 39         RTS

*** ATN series coefficients
    values appear to be error compensated

98A6  0B
98A7  76B383BDD3    ;FP constant -.0006847939119 
98AC  791EF4A6F5    ;FP constant  .004850942155
98B1  7B83FCB010    ;FP constant -.01611170184
98B6  7C0C1F67CA    ;FP constant  .03420963805
98BB  7CDE53CBC1    ;FP constant -.05427913276
98C0  7D1464704C    ;FP constant  .07245719654
98C5  7DB7EA517A    ;FP constant -.08980239538 
98CA  7D6330887E    ;FP constant  .1109324134
98CF  7E9244993A    ;FP constant -.1425398077
98D4  7E4CCC91C7    ;FP constant  .1999991205 
98D9  7FAAAAAA13    ;FP constant -.3333333157
98DE  8100000000    ;FP constant 1

*** part of reset routine: sets up sound & graphics variables

98E3 CCB844     LDD   #$B844
98E6 DDDF       STD   <$DF      ;PLAY volume data
98E8 8602       LDA   #$02
98EA 97E2       STA   <$E2      ;PLAY tempo
98EC 97DE       STA   <$DE      ;PLAY octave
98EE 48         ASLA
98EF 97E1       STA   <$E1      ;PLAY note length
98F1 0FE5       CLR   <$E5      ;PLAY duration
98F3 DC8A       LDD   <$8A      ;zero
98F5 DDE8       STD   <$E8      ;DRAW angle
98F7 C680       LDB   #$80
98F9 DDC7       STD   <$C7      ;graphics X
98FB C660       LDB   #$60
98FD DDC9       STD   <$C9      ;graphics Y
98FF 39         RTS

*** called by CSAVE to do CSAVEM

9900 9D9F       JSR   <$9F      ;get next character from BASIC source
9902 BDB7AA     JSR   $B7AA     ;get filename
9905 8D43       BSR   $994A     ;get start address
9907 BF01E7     STX   $01E7
990A 8D3E       BSR   $994A     ;get end address
990C AC62       CMPX  2,S
990E 1025F27B  LBCS   $8B8D     ;?FC ERROR
9912 8D36       BSR   $994A     ;get entry address
9914 BF01E5     STX   $01E5
9917 9DA5       JSR   <$A5      ;get current character from BASIC source
9919 26E4       BNE   $98FF
991B 8602       LDA   #$02      ;file type = 2 = binary
991D 9E8A       LDX   <$8A      ;non-ASCII & ungapped
991F BDB891     JSR   $B891     ;write filename block
9922 0F78       CLR   <$78      ;cassette status
9924 0C7C       INC   <$7C      ;block type
9926 BD801B     JSR   $801B     ;write leader
9929 AE64       LDX   4,S
992B 9F7E       STX   <$7E      ;IO buffer
992D 86FF       LDA   #$FF
992F 977D       STA   <$7D      ;block length
9931 EC62       LDD   2,S
9933 937E       SUBD  <$7E      ;IO buffer
9935 2405       BCC   $993C
9937 3266       LEAS  6,S
9939 7EB6CD     JMP   $B6CD     ;NEG $7c CLR $7d & write last block
993C 108300FF   CMPD  #$00FF
9940 2403       BCC   $9945
9942 5C         INCB
9943 D77D       STB   <$7D      ;block length
9945 BDB999     JSR   $B999     ;write block to tape
9948 20E1       BRA   $992B

*** get a number from command and leave it on stack

994A BD89AA     JSR   $89AA     ;skip comma
994D BD8E83     JSR   $8E83     ;read 16 bit number into X
9950 EEE4       LDU   ,S
9952 AFE4       STX   ,S
9954 1F35       TFR   U,PC

*** FIX

9956 BD9418     JSR   $9418     ;sets B to -1, 0 or 1 as per sign of FPA1
9959 2B03       BMI   $995E
995B 7E9499     JMP   $9499     ;INT
995E 0354       COM   <$54
9960 8DF9       BSR   $995B
9962 7E96DE     JMP   $96DE     ;COM $54 if FPA1 non zero

*** EDIT

9965 BD9D9F     JSR   $9D9F     ;get line number in $2b
9968 3262       LEAS  2,S       ;lose return address
996A 8601       LDA   #$01
996C 97D8       STA   <$D8
996E BD83FF     JSR   $83FF     ;search program for line number in <$2b
9971 1025EC90  LBCS   $8605     ;?UL ERROR
9975 BD8F08     JSR   $8F08     ;detokenize BASIC line
9978 1F20       TFR   Y,D
997A 8302DE     SUBD  #$02DE
997D D7D7       STB   <$D7      ;line length
997F DC2B       LDD   <$2B
9981 BD957A     JSR   $957A     ;print unsigned number in D
9984 BD90F5     JSR   $90F5     ;print a space to DEVN
9987 8E02DD     LDX   #$02DD
998A D6D8       LDB   <$D8
998C 2625       BNE   $99B3     ;print entire line
998E 5F         CLRB
998F BD9AB9     JSR   $9AB9     ;read keys (carry clear if control key)
9992 BDA438     JSR   $A438     ;set carry if A is non-numeric character
9995 250B       BCS   $99A2
9997 8030       SUBA  #$30      ;accumulate typed digits in B
9999 3402       PSHS  A         ;
999B 860A       LDA   #$0A      ;
999D 3D         MUL             ;
999E EBE0       ADDB  ,S+       ;
99A0 20ED       BRA   $998F     ;
99A2 C001       SUBB  #$01
99A4 C901       ADCB  #$01
99A6 8141       CMPA  #$41      ;(A = abandon changes & start again)
99A8 2605       BNE   $99AF
99AA BD90A1     JSR   $90A1     ;send CR to DEVN
99AD 20BB       BRA   $996A
99AF 814C       CMPA  #$4C      ;(L = show line in current state)
99B1 260B       BNE   $99BE
99B3 8D31       BSR   $99E6     ;output ASCIIZ string to DEVN (X is pointer)
99B5 0FD8       CLR   <$D8
99B7 BD90A1     JSR   $90A1     ;send CR to DEVN
99BA 20C3       BRA   $997F
99BC 3262       LEAS  2,S       ;lose return address
99BE 810D       CMPA  #$0D      ;(RETURN = save changes, show line & quit)
99C0 260D       BNE   $99CF
99C2 8D22       BSR   $99E6     ;output ASCIIZ string to DEVN (X is pointer)
99C4 BD90A1     JSR   $90A1     ;send CR to DEVN
99C7 8E02DD     LDX   #$02DD
99CA 9FA6       STX   <$A6      ;BASIC source pointer
99CC 7E83A6     JMP   $83A6     ;enter BASIC line
99CF 8145       CMPA  #$45      ;(E = save changes & quit)
99D1 27F1       BEQ   $99C4
99D3 8151       CMPA  #$51      ;(Q = discard changes & quit)
99D5 2606       BNE   $99DD
99D7 BD90A1     JSR   $90A1     ;send CR to DEVN
99DA 7E8371     JMP   $8371     ;command mode
99DD 8D02       BSR   $99E1
99DF 20AD       BRA   $998E
99E1 8120       CMPA  #$20      ;(SPACE = show more characters)
99E3 2610       BNE   $99F5
99E5 8C         CMPX  #

*** output ASCIIZ string to DEVN (stops at 249 characters)

(99E6 C6F9       LDB   #$F9)
99E8 A684       LDA   ,X
99EA 2708       BEQ   $99F4
99EC BDB54A     JSR   $B54A     ;output character to DEVN
99EF 3001       LEAX  1,X
99F1 5A         DECB
99F2 26F4       BNE   $99E8     ;show another (in EDIT context)
99F4 39         RTS

*** EDIT: test for Delete

99F5 8144       CMPA  #$44      ;(D = delete a number of characters)
99F7 2648       BNE   $9A41
99F9 6D84       TST   ,X
99FB 27F7       BEQ   $99F4
99FD 8D04       BSR   $9A03     ;close line up over removed character
99FF 5A         DECB
9A00 26F7       BNE   $99F9
9A02 39         RTS

*** EDIT: close line up over removed character

9A03 0AD7       DEC   <$D7
9A05 311F       LEAY  -1,X
9A07 3121       LEAY  1,Y
9A09 A621       LDA   1,Y
9A0B A7A4       STA   ,Y
9A0D 26F8       BNE   $9A07
9A0F 39         RTS

*** EDIT: test for insert mode functions

9A10 8149       CMPA  #$49      ;(I = insert mode)
9A12 2713       BEQ   $9A27
9A14 8158       CMPA  #$58      ;(X = insert mode at end of line)
9A16 270D       BEQ   $9A25
9A18 8148       CMPA  #$48      ;(H = wipe rest of line & insert)
9A1A 265C       BNE   $9A78
9A1C 6F84       CLR   ,X
9A1E 1F10       TFR   X,D
9A20 8302DE     SUBD  #$02DE
9A23 D7D7       STB   <$D7      ;updated line length
9A25 8DBF       BSR   $99E6     ;output ASCIIZ string to DEVN (X is pointer)
9A27 BD9AB9     JSR   $9AB9     ;read keys (carry clear if control key)
9A2A 810D       CMPA  #$0D
9A2C 278E       BEQ   $99BC     ;RETURN
9A2E 811B       CMPA  #$1B
9A30 2725       BEQ   $9A57     ;RTS (escape insert mode)
9A32 8108       CMPA  #$08
9A34 2622       BNE   $9A58     ;not backspace
9A36 8C02DD     CMPX  #$02DD
9A39 27EC       BEQ   $9A27     ;nothing to delete
9A3B 8D45       BSR   $9A82     ;delete it on screen
9A3D 8DC4       BSR   $9A03     ;delete it in memory
9A3F 20E6       BRA   $9A27

*** EDIT: test for Change

9A41 8143       CMPA  #$43      ;(C = change a number of characters)
9A43 26CB       BNE   $9A10
9A45 6D84       TST   ,X
9A47 270E       BEQ   $9A57     ;RTS
9A49 BD9AB9     JSR   $9AB9     ;read keys (carry clear if control key)
9A4C 2502       BCS   $9A50
9A4E 20F5       BRA   $9A45
9A50 A780       STA   ,X+
9A52 8D37       BSR   $9A8B     ;output character to DEVN
9A54 5A         DECB
9A55 26EE       BNE   $9A45     ;change another
9A57 39         RTS

*** EDIT: typed characters in insert mode

9A58 D6D7       LDB   <$D7
9A5A C1F9       CMPB  #$F9
9A5C 2602       BNE   $9A60
9A5E 20C7       BRA   $9A27     ;line full
9A60 3410       PSHS  X         
9A62 6D80       TST   ,X+       ;create a space for character
9A64 26FC       BNE   $9A62     ;
9A66 E682       LDB   ,-X       ;
9A68 E701       STB   1,X       ;
9A6A ACE4       CMPX  ,S        ;
9A6C 26F8       BNE   $9A66     ;
9A6E 3262       LEAS  2,S       
9A70 A780       STA   ,X+
9A72 8D17       BSR   $9A8B     ;output character to DEVN
9A74 0CD7       INC   <$D7
9A76 20AF       BRA   $9A27

*** EDIT: backspace over a number of characters

9A78 8108       CMPA  #$08
9A7A 2612       BNE   $9A8E
9A7C 8D04       BSR   $9A82
9A7E 5A         DECB
9A7F 26FB       BNE   $9A7C     ;backspace again
9A81 39         RTS

*** EDIT: backspace

9A82 8C02DD     CMPX  #$02DD
9A85 27D0       BEQ   $9A57     ;RTS
9A87 301F       LEAX  -1,X
9A89 8608       LDA   #$08
9A8B 7EB54A     JMP   $B54A     ;output character to DEVN

*** EDIT: test for search functions

9A8E 814B       CMPA  #$4B      ;(K = wipe chrs until nth occurrence of chr)
9A90 2705       BEQ   $9A97
9A92 8053       SUBA  #$53      ;(S = search for nth occurrence of chr)
9A94 2701       BEQ   $9A97
9A96 39         RTS

*** EDIT: search functions

9A97 3402       PSHS  A
9A99 8D1E       BSR   $9AB9     ;read keys (carry clear if control key)
9A9B 3402       PSHS  A
9A9D A684       LDA   ,X
9A9F 2716       BEQ   $9AB7     ;PULS Y,PC
9AA1 6D61       TST   1,S
9AA3 2606       BNE   $9AAB     ;Kill (not Search)
9AA5 8DE4       BSR   $9A8B     ;output character to DEVN
9AA7 3001       LEAX  1,X
9AA9 2003       BRA   $9AAE
9AAB BD9A03     JSR   $9A03     ;close line up over removed character
9AAE A684       LDA   ,X
9AB0 A1E4       CMPA  ,S
9AB2 26E9       BNE   $9A9D     ;not found
9AB4 5A         DECB
9AB5 26E6       BNE   $9A9D     ;find next occurrence
9AB7 35A0       PULS  Y,PC

*** read keys (carry clear if control key)

9AB9 BDB505     JSR   $B505     ;read character from DEVN & strip MSB
9ABC 817F       CMPA  #$7F      ;
9ABE 24F9       BCC   $9AB9     ;pointless test!
9AC0 815F       CMPA  #$5F
9AC2 2602       BNE   $9AC6     ;not shift + CU
9AC4 861B       LDA   #$1B
9AC6 810D       CMPA  #$0D
9AC8 270E       BEQ   $9AD8     ;return
9ACA 811B       CMPA  #$1B
9ACC 270A       BEQ   $9AD8     ;escape
9ACE 8108       CMPA  #$08
9AD0 2706       BEQ   $9AD8     ;backspace
9AD2 8120       CMPA  #$20
9AD4 25E3       BCS   $9AB9     ;illegal
9AD6 1A01       ORCC  #$01
9AD8 39         RTS

*** TRON

9AD9 86         LDA #

*** TROFF

(9ADA 4F         CLRA)
9ADB 97AF       STA   <$AF
9ADD 39         RTS

*** POS

9ADE 966F       LDA   <$6F      ;DEVN
9AE0 3402       PSHS  A
9AE2 BDB7E0     JSR   $B7E0     ;load DEVN from FPA1
9AE5 BDB63C     JSR   $B63C     ;if DEVN = -1, test cassette OK for output
9AE8 BDB595     JSR   $B595     ;initialise virtual DEVN device
9AEB D66C       LDB   <$6C      ;device current column
9AED 3502       PULS  A
9AEF 976F       STA   <$6F      ;DEVN
9AF1 7E8C36     JMP   $8C36     ;assign B to FPA1

*** VARPTR

9AF4 BD89A7     JSR   $89A7     ;skip open bracket
9AF7 DC1F       LDD   <$1F      ;end of BASIC storage
9AF9 3406       PSHS  A,B
9AFB BD8A94     JSR   $8A94     ;get varptr of variable in X
9AFE BD89A4     JSR   $89A4     ;skip close bracket
9B01 3506       PULS  A,B
9B03 1E10       EXG   X,D
9B05 9C1F       CMPX  <$1F      ;not allowed to create new variable
9B07 2651       BNE   $9B5A     ;?FC ERROR
9B09 7E9FD0     JMP   $9FD0     ;assign D to FPA1

*** MID$ on LHS

9B0C 9D9F       JSR   <$9F      ;get next character from BASIC source
9B0E BD89A7     JSR   $89A7     ;skip open bracket
9B11 BD8A94     JSR   $8A94     ;get varptr of variable in X
9B14 3410       PSHS  X
9B16 EC02       LDD   2,X
9B18 109321     CMPD  <$21      ;stack root / string storage start
9B1B 2304       BLS   $9B21
9B1D 9327       SUBD  <$27      ;top of BASIC RAM
9B1F 2312       BLS   $9B33
9B21 E684       LDB   ,X
9B23 BD8CB3     JSR   $8CB3     ;reserve B bytes of string space
9B26 3410       PSHS  X
9B28 AE62       LDX   2,S
9B2A BD8D89     JSR   $8D89     ;copy string (len B) from varptr X to ($25)+
9B2D 3550       PULS  X,U
9B2F AF42       STX   2,U
9B31 3440       PSHS  U
9B33 BD8E7E     JSR   $8E7E
9B36 3404       PSHS  B
9B38 5D         TSTB
9B39 271F       BEQ   $9B5A     ;?FC ERROR
9B3B C6FF       LDB   #$FF
9B3D 8129       CMPA  #$29   )
9B3F 2703       BEQ   $9B44
9B41 BD8E7E     JSR   $8E7E
9B44 3404       PSHS  B
9B46 BD89A4     JSR   $89A4     ;skip close bracket
9B49 C6CB       LDB   #$CB
9B4B BD89AC     JSR   $89AC     ;skip character in B
9B4E 8D2E       BSR   $9B7E     ;get string expression & point X to it
9B50 1F13       TFR   X,U
9B52 AE62       LDX   2,S
9B54 A684       LDA   ,X
9B56 A061       SUBA  1,S
9B58 2403       BCC   $9B5D
9B5A 7E8B8D     JMP   $8B8D     ;?FC ERROR
9B5D 4C         INCA
9B5E A1E4       CMPA  ,S
9B60 2402       BCC   $9B64
9B62 A7E4       STA   ,S
9B64 A661       LDA   1,S
9B66 1E89       EXG   A,B
9B68 AE02       LDX   2,X
9B6A 5A         DECB
9B6B 3A         ABX
9B6C 4D         TSTA
9B6D 270D       BEQ   $9B7C
9B6F A1E4       CMPA  ,S
9B71 2302       BLS   $9B75
9B73 A6E4       LDA   ,S
9B75 1F89       TFR   A,B
9B77 1E31       EXG   U,X
9B79 BDB7CC     JSR   $B7CC     ;copy B bytes from X to U
9B7C 3596       PULS  A,B,X,PC

*** get string expression & point X to it (B=len)

9B7E BD8887     JSR   $8887     ;get expression
9B81 7E8D9A     JMP   $8D9A     ;validate string & point X to it (B=len)

*** STRING$

9B84 BD89A7     JSR   $89A7     ;skip open bracket
9B87 BD8E51     JSR   $8E51     ;get number into B
9B8A 3404       PSHS  B
9B8C BD89AA     JSR   $89AA     ;skip comma
9B8F BD8887     JSR   $8887     ;get expression
9B92 BD89A4     JSR   $89A4     ;skip close bracket
9B95 9606       LDA   <$06      ;numeric / string flag
9B97 2605       BNE   $9B9E
9B99 BD8E54     JSR   $8E54     ;read 8 bit value into B from FPA1
9B9C 2003       BRA   $9BA1
9B9E BD8DEA     JSR   $8DEA     ;get 1st character of string into B
9BA1 3404       PSHS  B
9BA3 E661       LDB   1,S       ;number of copies
9BA5 BD8C52     JSR   $8C52     ;reserve B bytes of string space
9BA8 3506       PULS  A,B
9BAA 2705       BEQ   $9BB1
9BAC A780       STA   ,X+
9BAE 5A         DECB
9BAF 26FB       BNE   $9BAC
9BB1 7E8DE1     JMP   $8DE1

*** INSTR

9BB4 BD89A7     JSR   $89A7     ;skip open bracket
9BB7 BD8887     JSR   $8887     ;get expression
9BBA C601       LDB   #$01      ;default start position
9BBC 3404       PSHS  B
9BBE 9606       LDA   <$06      ;numeric / string flag
9BC0 2610       BNE   $9BD2     ;start pos not specified
9BC2 BD8E54     JSR   $8E54     ;read 8 bit value into B from FPA1
9BC5 E7E4       STB   ,S
9BC7 2791       BEQ   $9B5A     ;?FC ERROR
9BC9 BD89AA     JSR   $89AA     ;skip comma
9BCC BD8887     JSR   $8887     ;get expression
9BCF BD8877     JSR   $8877     ;validate string expression
9BD2 9E52       LDX   <$52
9BD4 3410       PSHS  X
9BD6 BD89AA     JSR   $89AA     ;skip comma
9BD9 BD9B7E     JSR   $9B7E     ;get string expression & point X to it
9BDC 3414       PSHS  B,X
9BDE BD89A4     JSR   $89A4     ;skip close bracket
9BE1 AE63       LDX   3,S       ;varptr of main string
9BE3 BD8D9F     JSR   $8D9F     ;point X to string & length in B
9BE6 3404       PSHS  B
9BE8 E166       CMPB  6,S
9BEA 2523       BCS   $9C0F     ;main string is shorter than start pos
9BEC A661       LDA   1,S       ;target string length
9BEE 271C       BEQ   $9C0C
9BF0 E666       LDB   6,S       ;start pos
9BF2 5A         DECB
9BF3 3A         ABX
9BF4 3184       LEAY  ,X        ;Y = X = position to start search
9BF6 EE62       LDU   2,S       ;U -> target characters
9BF8 E661       LDB   1,S       ;B = target length
9BFA A6E4       LDA   ,S        ;A = main string length
9BFC A066       SUBA  6,S       ;
9BFE 4C         INCA            ;A = A - start pos + 1
9BFF A161       CMPA  1,S
9C01 250C       BCS   $9C0F     ;remaining length is shorter than target
9C03 A680       LDA   ,X+
9C05 A1C0       CMPA  ,U+
9C07 260C       BNE   $9C15     ;didn't match
9C09 5A         DECB
9C0A 26F7       BNE   $9C03     ;test next character in target
9C0C E666       LDB   6,S       ;found it
9C0E 21         BRN   $
(9C0F 5F         CLRB)
9C10 3267       LEAS  7,S
9C12 7E8C36     JMP   $8C36     ;assign B to FPA1
9C15 6C66       INC   6,S       ;
9C17 3021       LEAX  1,Y       ;advance start pos & try again
9C19 20D9       BRA   $9BF4     ;

*** read octal or hex number from command into $52 / $53

9C1B 0F52       CLR   <$52
9C1D 0F53       CLR   <$53
9C1F 8E0052     LDX   #$0052
9C22 9D9F       JSR   <$9F      ;get next character from BASIC source
9C24 814F       CMPA  #$4F   O
9C26 2712       BEQ   $9C3A
9C28 8148       CMPA  #$48   H
9C2A 2723       BEQ   $9C4F
9C2C 9DA5       JSR   <$A5      ;get current character from BASIC source
9C2E 200C       BRA   $9C3C
9C30 8138       CMPA  #$38   8
9C32 1022ED7E  LBHI   $89B4     ;?SN ERROR
9C36 C603       LDB   #$03
9C38 8D2A       BSR   $9C64     ;shift word at ,X left B bits
9C3A 9D9F       JSR   <$9F      ;get next character from BASIC source
9C3C 25F2       BCS   $9C30

*** assign contents of $52 / $53 to FPA1

9C3E 0F50       CLR   <$50
9C40 0F51       CLR   <$51
9C42 0F06       CLR   <$06      ;numeric / string flag
9C44 0F63       CLR   <$63
9C46 0F54       CLR   <$54
9C48 C6A0       LDB   #$A0
9C4A D74F       STB   <$4F
9C4C 7E9165     JMP   $9165     ;normalize FPA1

*** read hex digits from command into ,X

9C4F 9D9F       JSR   <$9F      ;get next character from BASIC source
9C51 250B       BCS   $9C5E
9C53 BD8ADF     JSR   $8ADF     ;carry clear if A-Z
9C56 25E6       BCS   $9C3E     ;assign contents of $52 / $53 to FPA1
9C58 8147       CMPA  #$47   G
9C5A 24E2       BCC   $9C3E     ;assign contents of $52 / $53 to FPA1
9C5C 8007       SUBA  #$07
9C5E C604       LDB   #$04
9C60 8D02       BSR   $9C64     ;shift word at ,X left B bits
9C62 20EB       BRA   $9C4F

*** shift word at ,X left B bits

9C64 6801       ASL   1,X
9C66 6984       ROL   ,X
9C68 1025F56F  LBCS   $91DB     ;?OV ERROR
9C6C 5A         DECB
9C6D 26F5       BNE   $9C64
9C6F 8030       SUBA  #$30   0
9C71 AB01       ADDA  1,X
9C73 A701       STA   1,X
9C75 39         RTS

*** cause error if in command mode

9C76 9E68       LDX   <$68      ;current line number
9C78 3001       LEAX  1,X
9C7A 26F9       BNE   $9C75     ;not in command mode
9C7C C616       LDB   #$16      ;?ID ERROR
9C7E 7E8344     JMP   $8344     ;cause error

*** DEF

9C81 AE9F00A6   LDX  ($00A6)
9C85 8CFFA1     CMPX  #$FFA1    ;DEF USR
9C88 10270074  LBEQ   $9D00
9C8C 8D23       BSR   $9CB1     
9C8E 8DE6       BSR   $9C76     ;test for command mode
9C90 BD89A7     JSR   $89A7     ;skip open bracket
9C93 C680       LDB   #$80
9C95 D708       STB   <$08      ;array illegal flag
9C97 BD8A94     JSR   $8A94     ;get varptr of variable in X
9C9A 8D25       BSR   $9CC1
9C9C BD89A4     JSR   $89A4     ;skip close bracket
9C9F C6CB       LDB   #$CB
9CA1 BD89AC     JSR   $89AC     ;skip character in B
9CA4 9E4B       LDX   <$4B
9CA6 DCA6       LDD   <$A6      ;BASIC source pointer
9CA8 ED84       STD   ,X
9CAA DC39       LDD   <$39
9CAC ED02       STD   2,X
9CAE 7E8613     JMP   $8613     ;skip to start of next statement

9CB1 C6BE       LDB   #$BE      ;token FN
9CB3 BD89AC     JSR   $89AC     ;skip character in B
9CB6 C680       LDB   #$80
9CB8 D708       STB   <$08      ;array illegal flag
9CBA 8A80       ORA   #$80
9CBC BD8A99     JSR   $8A99
9CBF 9F4B       STX   <$4B
9CC1 7E8874     JMP   $8874     ;validate numeric expression
9CC4 8DEB       BSR   $9CB1
9CC6 3410       PSHS  X
9CC8 BD899F     JSR   $899F     ;get expression inside brackets
9CCB 8DF4       BSR   $9CC1
9CCD 3540       PULS  U
9CCF C622       LDB   #$22      ;?UF ERROR
9CD1 AE42       LDX   2,U
9CD3 27A9       BEQ   $9C7E     ;cause error
9CD5 109EA6     LDY   <$A6      ;BASIC source pointer
9CD8 EEC4       LDU   ,U
9CDA DFA6       STU   <$A6      ;BASIC source pointer
9CDC A604       LDA   4,X
9CDE 3402       PSHS  A
9CE0 EC84       LDD   ,X
9CE2 EE02       LDU   2,X
9CE4 3476       PSHS  A,B,X,Y,U
9CE6 BD93E0     JSR   $93E0     ;assign FPA1 to varptr in X
9CE9 BD8872     JSR   $8872     ;read numeric expression into FPA1
9CEC 3576       PULS  A,B,X,Y,U
9CEE ED84       STD   ,X
9CF0 EF02       STU   2,X
9CF2 3502       PULS  A
9CF4 A704       STA   4,X
9CF6 9DA5       JSR   <$A5      ;get current character from BASIC source
9CF8 1026ECB8  LBNE   $89B4     ;?SN ERROR
9CFC 109FA6     STY   <$A6      ;BASIC source pointer
9CFF 39         RTS

*** DEF USRx = address

9D00 9D9F       JSR   <$9F      ;get next character from BASIC source
9D02 9D9F       JSR   <$9F      ;get next character from BASIC source
9D04 8D07       BSR   $9D0D
9D06 3410       PSHS  X
9D08 8D2B       BSR   $9D35
9D0A AFF1       STX  (,S++)
9D0C 39         RTS

*** called by USR: converts following digit into USR table pointer

9D0D 5F         CLRB
9D0E 9DA5       JSR   <$A5      ;get current character from BASIC source
9D10 2406       BCC   $9D18
9D12 8030       SUBA  #$30   0
9D14 1F89       TFR   A,B
9D16 9D9F       JSR   <$9F      ;get next character from BASIC source
9D18 9EB0       LDX   <$B0      ;address of USR table
9D1A 58         ASLB
9D1B 3A         ABX
9D1C 39         RTS

*** USRx

9D1D 8DEE       BSR   $9D0D
9D1F AE84       LDX   ,X
9D21 3410       PSHS  X
9D23 BD899F     JSR   $899F     ;get expression inside brackets
9D26 8E004F     LDX   #$004F    ;FPA1
9D29 9606       LDA   <$06      ;numeric / string flag
9D2B 2707       BEQ   $9D34
9D2D BD8D9D     JSR   $8D9D     ;point X to string just compiled & len in B
9D30 9E52       LDX   <$52
9D32 9606       LDA   <$06      ;numeric / string flag
9D34 39         RTS

*** skips = sign & reads 16 bit number into X

9D35 C6CB       LDB   #$CB      ;token =
9D37 BD89AC     JSR   $89AC     ;skip character in B
9D3A 7E8E83     JMP   $8E83     ;read 16 bit number into X

*** IRQ service routine

9D3D B6FF03     LDA   $FF03
9D40 2B01       BMI   $9D43     ;vsync
9D42 3B         RTI
9D43 B6FF02     LDA   $FF02
9D46 BE0112     LDX   $0112     ;TIMER value
9D49 3001       LEAX  1,X
9D4B BF0112     STX   $0112
9D4E 7EAFD9     JMP   $AFD9     ;...continued

*** TIMER on LHS

9D51 9D9F       JSR   <$9F      ;get next character from BASIC source
9D53 8DE0       BSR   $9D35
9D55 BF0112     STX   $0112     ;TIMER value
9D58 39         RTS

*** TIMER

9D59 BE0112     LDX   $0112     ;TIMER value
9D5C 9F52       STX   <$52
9D5E 7E9C3E     JMP   $9C3E     ;assign contents of $52 / $53 to FPA1

*** DEL

9D61 1027EE28  LBEQ   $8B8D     ;?FC ERROR
9D65 BD869A     JSR   $869A     ;read line number & store in $2b
9D68 BD83FF     JSR   $83FF     ;search program for line number in <$2b
9D6B 9FD3       STX   <$D3
9D6D 9DA5       JSR   <$A5      ;get current character from BASIC source
9D6F 2710       BEQ   $9D81
9D71 81C4       CMPA  #$C4      ;token -
9D73 263B       BNE   $9DB0
9D75 9D9F       JSR   <$9F      ;get next character from BASIC source
9D77 2704       BEQ   $9D7D
9D79 8D24       BSR   $9D9F
9D7B 2004       BRA   $9D81
9D7D 86FF       LDA   #$FF
9D7F 972B       STA   <$2B
9D81 DED3       LDU   <$D3
9D83 8C         CMPX  #
(9D84 EEC4       LDU   ,U)
9D86 ECC4       LDD   ,U
9D88 2706       BEQ   $9D90
9D8A EC42       LDD   2,U
9D8C 932B       SUBD  <$2B
9D8E 23F4       BLS   $9D84
9D90 9ED3       LDX   <$D3
9D92 8D15       BSR   $9DA9     ;move program down from U to X
9D94 BD841F     JSR   $841F     ;clear variables and reset stack & cmd ptr
9D97 9ED3       LDX   <$D3
9D99 BD83EF     JSR   $83EF     ;set up next line pointers from X onwards
9D9C 7E8371     JMP   $8371     ;command mode

9D9F BD869A     JSR   $869A     ;read line number & store in $2b
9DA2 7EB7F9     JMP   $B7F9     ;cause error if next byte is not zero

9DA5 A6C0       LDA   ,U+
9DA7 A780       STA   ,X+
9DA9 11931B     CMPU  <$1B      ;start of simple variables
9DAC 26F7       BNE   $9DA5
9DAE 9F1B       STX   <$1B      ;start of simple variables
9DB0 39         RTS

*** LINE INPUT

9DB1 BD9C76     JSR   $9C76     ;test for command mode
9DB4 9D9F       JSR   <$9F      ;get next character from BASIC source
9DB6 8123       CMPA  #$23   #
9DB8 2609       BNE   $9DC3
9DBA BDB7D7     JSR   $B7D7     ;read #-n & set up DEVN
9DBD BDB623     JSR   $B623     ;test cassette status OK for input
9DC0 BD89AA     JSR   $89AA     ;skip comma
9DC3 8122       CMPA  #$22   "
9DC5 260B       BNE   $9DD2     ;no prompt
9DC7 BD8975     JSR   $8975     ;read literal string
9DCA C63B       LDB   #$3B   ;
9DCC BD89AC     JSR   $89AC     ;skip character in B
9DCF BD90E8     JSR   $90E8     ;print string just compiled
9DD2 327E       LEAS  -2,S
9DD4 BD8766     JSR   $8766
9DD7 3262       LEAS  2,S
9DD9 0F6F       CLR   <$6F      ;DEVN
9DDB BD8A94     JSR   $8A94     ;get varptr of variable in X
9DDE 9F3B       STX   <$3B
9DE0 BD8877     JSR   $8877     ;validate string expression
9DE3 8E02DC     LDX   #$02DC
9DE6 4F         CLRA
9DE7 BD8C5D     JSR   $8C5D     ;compile literal string at X
9DEA 7E86D7     JMP   $86D7     ;assign string variable

*** read line number into X & $2b

9DED BD869A     JSR   $869A     ;read line number & store in $2b
9DF0 9E2B       LDX   <$2B
9DF2 39         RTS

*** RENUM: search for start line

9DF3 9ED1       LDX   <$D1
9DF5 9F2B       STX   <$2B
9DF7 7E83FF     JMP   $83FF     ;search program for line number in <$2b

*** RENUM

9DFA BD8424     JSR   $8424     ;clear variables & reset stack
9DFD CC000A     LDD   #$000A    ;
9E00 DDD5       STD   <$D5      ;default RENUM 10,0,10
9E02 DDCF       STD   <$CF      ;
9E04 5F         CLRB            ;
9E05 DDD1       STD   <$D1      ;
9E07 9DA5       JSR   <$A5      ;get current character from BASIC source
9E09 2406       BCC   $9E11
9E0B 8DE0       BSR   $9DED     ;read line number into X & $2b
9E0D 9FD5       STX   <$D5      ;new start line
9E0F 9DA5       JSR   <$A5      ;get current character from BASIC source
9E11 271B       BEQ   $9E2E
9E13 BD89AA     JSR   $89AA     ;skip comma
9E16 2406       BCC   $9E1E
9E18 8DD3       BSR   $9DED     ;read line number into X & $2b
9E1A 9FD1       STX   <$D1      ;line to start renumbering at
9E1C 9DA5       JSR   <$A5      ;get current character from BASIC source
9E1E 270E       BEQ   $9E2E
9E20 BD89AA     JSR   $89AA     ;skip comma
9E23 2406       BCC   $9E2B
9E25 8DC6       BSR   $9DED     ;read line number into X & $2b
9E27 9FCF       STX   <$CF      ;line increment
9E29 2749       BEQ   $9E74     ;?FC ERROR
9E2B BDB7F9     JSR   $B7F9     ;cause error if next byte is not zero
9E2E 8DC3       BSR   $9DF3     ;search for start line
9E30 9FD3       STX   <$D3      ;save address
9E32 9ED5       LDX   <$D5
9E34 8DBF       BSR   $9DF5     ;search for new start line
9E36 9CD3       CMPX  <$D3      ;not allowed to be lower than start line
9E38 253A       BCS   $9E74     ;?FC ERROR
9E3A 8D1C       BSR   $9E58     ;dry run - check lines don't get too high
9E3C BD9ECE     JSR   $9ECE     ;prepare line numbers in statements
9E3F BD83ED     JSR   $83ED     ;set up next line pointers in BASIC program
9E42 8DAF       BSR   $9DF3     ;search for start line
9E44 9FD3       STX   <$D3      ;save address
9E46 8D3A       BSR   $9E82     ;convert line numbers to addresses
9E48 8D0F       BSR   $9E59     ;do the actual renumbering
9E4A 8D36       BSR   $9E82     ;convert addresses to line numbers
9E4C BD9F6C     JSR   $9F6C     ;convert line numbers back to ASCII
9E4F BD8424     JSR   $8424     ;clear variables & reset stack
9E52 BD83ED     JSR   $83ED     ;set up next line pointers in BASIC program
9E55 7E8371     JMP   $8371     ;command mode

*** RENUM: dry run to check that line numbers don't get too high

9E58 86         LDA   #

*** RENUM: renumber!

(9E59 4F         CLRA)
9E5A 97D8       STA   <$D8
9E5C 9ED3       LDX   <$D3      ;start address
9E5E DCD5       LDD   <$D5      ;new start number
9E60 8D15       BSR   $9E77     ;test for end of program 
9E62 0DD8       TST   <$D8      ;dry run flag
9E64 2602       BNE   $9E68
9E66 ED02       STD   2,X       ;store new line number
9E68 AE84       LDX   ,X        ;point X to next line
9E6A 8D0B       BSR   $9E77     ;test for end of program 
9E6C D3CF       ADDD  <$CF      ;increment line number
9E6E 2504       BCS   $9E74     ;?FC ERROR
9E70 81FA       CMPA  #$FA
9E72 25EE       BCS   $9E62
9E74 7E8B8D     JMP   $8B8D     ;?FC ERROR

*** RENUM: test for end of program 

9E77 3406       PSHS  A,B
9E79 EC84       LDD   ,X
9E7B 3506       PULS  A,B
9E7D 2602       BNE   $9E81
9E7F 3262       LEAS  2,S       ;return 2 levels if at end of program
9E81 39         RTS

*** RENUM: on 1st call converts the line numbers in each info block
           into line addresses. On 2nd call converts them back into
           line numbers.

9E82 9E19       LDX   <$19      ;start of BASIC program
9E84 301F       LEAX  -1,X
9E86 3001       LEAX  1,X
9E88 8DED       BSR   $9E77     ;test for end of program 
9E8A 3003       LEAX  3,X
9E8C 3001       LEAX  1,X
9E8E A684       LDA   ,X
9E90 27F4       BEQ   $9E86     ;end of line
9E92 9F0F       STX   <$0F
9E94 4A         DECA
9E95 270C       BEQ   $9EA3     ;1st pass - convert line number to address
9E97 4A         DECA
9E98 272A       BEQ   $9EC4     ;2nd pass - convert address to line number
9E9A 4A         DECA
9E9B 26EF       BNE   $9E8C
9E9D 8603       LDA   #$03
9E9F A780       STA   ,X+
9EA1 20E7       BRA   $9E8A
9EA3 EC01       LDD   1,X       ;reconstruct line number coded in block
9EA5 6A02       DEC   2,X       ;
9EA7 2701       BEQ   $9EAA     ;
9EA9 4F         CLRA            ;
9EAA E603       LDB   3,X       ;
9EAC 6A04       DEC   4,X       ;
9EAE 2701       BEQ   $9EB1     ;
9EB0 5F         CLRB            ;
9EB1 ED01       STD   1,X       ;
9EB3 DD2B       STD   <$2B
9EB5 BD83FF     JSR   $83FF     ;search program for line number in <$2b
9EB8 9E0F       LDX   <$0F
9EBA 25E1       BCS   $9E9D     ;line not found - store a 3 for 'UL'
9EBC DC47       LDD   <$47      ;address of line
9EBE 6C80       INC   ,X+
9EC0 ED84       STD   ,X
9EC2 20C6       BRA   $9E8A
9EC4 6F84       CLR   ,X        ;becomes a 1 in a moment
9EC6 AE01       LDX   1,X       ;address of line
9EC8 AE02       LDX   2,X       ;actual line number
9ECA 9F47       STX   <$47
9ECC 20EA       BRA   $9EB8     ;store it in info block

*** RENUM: prepare line numbers in statements
    (replaces line number digits with 5 byte info block)

9ECE 9E19       LDX   <$19      ;start of BASIC program
9ED0 2004       BRA   $9ED6
9ED2 9EA6       LDX   <$A6      ;BASIC source pointer
9ED4 3001       LEAX  1,X
9ED6 8D9F       BSR   $9E77     ;test for end of program 
9ED8 3002       LEAX  2,X
9EDA 3001       LEAX  1,X
9EDC 9FA6       STX   <$A6      ;BASIC source pointer
9EDE 9D9F       JSR   <$9F      ;get next character from BASIC source
9EE0 4D         TSTA
9EE1 27EF       BEQ   $9ED2     ;end of line
9EE3 2AF9       BPL   $9EDE     ;non-token
9EE5 9EA6       LDX   <$A6      ;BASIC source pointer
9EE7 81FF       CMPA  #$FF
9EE9 27EF       BEQ   $9EDA     ;skip function token
9EEB BD01A0     JSR   $01A0     ;PATCH - CLS GET PUT ???
9EEE 81BF       CMPA  #$BF      ;token THEN
9EF0 2712       BEQ   $9F04
9EF2 8184       CMPA  #$84      ;token ELSE
9EF4 270E       BEQ   $9F04
9EF6 8181       CMPA  #$81      ;token GO
9EF8 26E4       BNE   $9EDE
9EFA 9D9F       JSR   <$9F      ;get next character from BASIC source
9EFC 81BC       CMPA  #$BC      ;token TO
9EFE 2704       BEQ   $9F04
9F00 81BD       CMPA  #$BD      ;token SUB
9F02 26D8       BNE   $9EDC     ;keep looking for interesting stuff
9F04 9D9F       JSR   <$9F      ;get next character from BASIC source
9F06 2504       BCS   $9F0C     ;found digit
9F08 9DA5       JSR   <$A5      ;get current character from BASIC source
9F0A 20D4       BRA   $9EE0
9F0C 9EA6       LDX   <$A6      ;BASIC source pointer
9F0E 3410       PSHS  X         ;start of digits
9F10 BD869A     JSR   $869A     ;read line number & store in $2b
9F13 9EA6       LDX   <$A6      ;BASIC source pointer
9F15 A682       LDA   ,-X
9F17 BDA438     JSR   $A438     ;set carry if A is non-numeric character
9F1A 25F9       BCS   $9F15
9F1C 3001       LEAX  1,X       ;end of digits
9F1E 1F10       TFR   X,D
9F20 E061       SUBB  1,S
9F22 C005       SUBB  #$05 
9F24 2720       BEQ   $9F46     ;exactly 5 digits
9F26 250A       BCS   $9F32     ;less than 5 digits
9F28 3384       LEAU  ,X
9F2A 50         NEGB
9F2B 3085       LEAX  B,X
9F2D BD9DA9     JSR   $9DA9     ;move program down from U to X
9F30 2014       BRA   $9F46
9F32 9F47       STX   <$47
9F34 9E1B       LDX   <$1B      ;start of simple variables
9F36 9F43       STX   <$43
9F38 50         NEGB
9F39 3085       LEAX  B,X
9F3B 9F41       STX   <$41
9F3D 9F1B       STX   <$1B      ;start of simple variables
9F3F BD831C     JSR   $831C     ;move memory contents up
9F42 9E45       LDX   <$45
9F44 9FA6       STX   <$A6      ;BASIC source pointer
9F46 3510       PULS  X         ;start of digits
9F48 8601       LDA   #$01      ;
9F4A A784       STA   ,X        ;replace line number with 5 byte info block
9F4C A702       STA   2,X       ;line number coded to avoid zeros
9F4E A704       STA   4,X       ;otherwise world would fall apart
9F50 D62B       LDB   <$2B      ;
9F52 2604       BNE   $9F58     ;
9F54 C601       LDB   #$01      ;
9F56 6C02       INC   2,X       ;
9F58 E701       STB   1,X       ;
9F5A D62C       LDB   <$2C      ;
9F5C 2604       BNE   $9F62     ;
9F5E C601       LDB   #$01      ;
9F60 6C04       INC   4,X       ;
9F62 E703       STB   3,X       ;
9F64 9DA5       JSR   <$A5      ;get current character from BASIC source
9F66 812C       CMPA  #$2C
9F68 279A       BEQ   $9F04     ;comma - look for another line number
9F6A 209C       BRA   $9F08

*** RENUM: convert line numbers into ASCII again (also flags UL errors)

9F6C 9E19       LDX   <$19      ;start of BASIC program
9F6E 301F       LEAX  -1,X
9F70 3001       LEAX  1,X
9F72 EC02       LDD   2,X
9F74 DD68       STD   <$68      ;current line number
9F76 BD9E77     JSR   $9E77     ;test for end of program 
9F79 3003       LEAX  3,X
9F7B 3001       LEAX  1,X
9F7D A684       LDA   ,X
9F7F 27EF       BEQ   $9F70     ;end of line
9F81 4A         DECA
9F82 271B       BEQ   $9F9F     ;found an info block
9F84 8002       SUBA  #$02
9F86 26F3       BNE   $9F7B
9F88 3410       PSHS  X
9F8A 8E9FC9     LDX   #$9FC9    ;/UL /
9F8D BD90E5     JSR   $90E5     ;print string to DEVN
9F90 AEE4       LDX   ,S
9F92 EC01       LDD   1,X
9F94 BD957A     JSR   $957A     ;print unsigned number in D
9F97 BD9573     JSR   $9573     ;print 'IN xxxx' (current line number)
9F9A BD90A1     JSR   $90A1     ;send CR to DEVN
9F9D 3510       PULS  X
9F9F 3410       PSHS  X
9FA1 EC01       LDD   1,X       ;adjusted line number
9FA3 DD52       STD   <$52
9FA5 BD9C3E     JSR   $9C3E     ;assign contents of $52 / $53 to FPA1
9FA8 BD9587     JSR   $9587     ;convert FPA1 to string at $3DA
9FAB 3540       PULS  U
9FAD C605       LDB   #$05
9FAF 3001       LEAX  1,X       ;write line number into program
9FB1 A684       LDA   ,X        ;
9FB3 2705       BEQ   $9FBA     ;
9FB5 5A         DECB            ;
9FB6 A7C0       STA   ,U+       ;
9FB8 20F5       BRA   $9FAF     ;
9FBA 30C4       LEAX  ,U
9FBC 5D         TSTB
9FBD 27BE       BEQ   $9F7D     ;exactly 5 digits - no problem
9FBF 31C4       LEAY  ,U
9FC1 33C5       LEAU  B,U
9FC3 BD9DA9     JSR   $9DA9     ;move program down from U to X
9FC6 30A4       LEAX  ,Y
9FC8 20B3       BRA   $9F7D

9FCA  554C2000      ;/UL /

*** MEM continued

9FCE 931F       SUBD  <$1F      ;end of BASIC storage
9FD0 0F06       CLR   <$06      ;numeric / string flag
9FD2 DD52       STD   <$52
9FD4 C690       LDB   #$90      ;meaningless
9FD6 7E9C3E     JMP   $9C3E     ;assign contents of $52 / $53 to FPA1

*** unused

9FD9 to
9FFF

