(back to project page)

IntegerBASIC Disassembly

                   * Integer BASIC for the Apple II                                               *
                   * By Steve Wozniak                                                             *
                   * Copyright 1977 by Apple Computer, Inc.                                       *
                   * Disassembly by Paul R. Santa-Maria.                                          *
                   *                                                                              *
                   * "Ported" to SourceGen format by Andy McFadden, using 6502bench SourceGen     *
                   * v1.8.  The listing here generally follows the original, except for a few     *
                   * places where SourceGen's limited expressions make it awkward.  I added a few *
                   * additional labels, mostly on loops.                                          *
                   *                                                                              *
                   * Last updated 2021/10/17                                                      *
                   * The binary was extracted from the INTBASIC file on the DOS 3.3 system        *
                   * master, for the region spanning $e000-f7ff.  That file also includes PA#1    *
                   * from $d000-dfff, and the original F8 monitor ROM from $f800-ffff.            *
                   *                                                                              *
                   * As noted in Paul R. Santa-Maria's article, there is no original assembly     *
                   * file for Integer BASIC.  The entire program was written out by hand.         *
                   ETX             .eq     $03    {const}    ;Ctrl+C
                   CR              .eq     $0d    {const}    ;carriage return
                   BLANK           .eq     $20    {const}    ;space
                   DQT             .eq     $22    {const}    ;double quote
                   MON_WNDWDTH     .eq     $21               ;width of scroll window
                   MON_CH          .eq     $24               ;cursor horizontal displacement
                   MON_CV          .eq     $25               ;cursor vertical displacement
                   MON_GBASL       .eq     $26               ;base address for lo-res drawing (lo)
                   MON_H2          .eq     $2c               ;right end of horizontal line drawn by HLINE
                   MON_V2          .eq     $2d               ;bottom of vertical line drawn by VLINE
                   MON_PROMPT      .eq     $33               ;prompt character
                   MON_A1L         .eq     $3c               ;general purpose
                   MON_A1H         .eq     $3d               ;general purpose
                   MON_A2L         .eq     $3e               ;general purpose
                   MON_A2H         .eq     $3f               ;general purpose
                   LOMEM           .eq     $4a    {addr/2}   ;pointer to start of variables
                   HIMEM           .eq     $4c    {addr/2}   ;pointer to end of program
                   MON_RNDL        .eq     $4e               ;low byte of KEYIN "random" value
                   MON_RNDH        .eq     $4f               ;high byte of KEYIN "random" value
                   NOUNSTKL        .eq     $50    {addr/8}   ;noun stack low bytes
                   SYNSTKH         .eq     $58               ;syntax stack high byte
                   NOUNSTKH        .eq     $78    {addr/32}  ;noun stack high bytes
                   SYNSTKL         .eq     $80    {addr/32}  ;syntax stack low bytes
                   NOUNSTKC        .eq     $a0    {addr/32}  ;noun stack counter
                   TXTNDXSTK       .eq     $a8    {addr/32}  ;text index stack
                   TXTNDX          .eq     $c8               ;text index val (OUTVAL)
                   LEADBL          .eq     $c9               ;leading blanks index (YTEMP)
                   PP              .eq     $ca    {addr/2}   ;pointer to start of program
                   PV              .eq     $cc    {addr/2}   ;pointer to end of vars
                   ACC             .eq     $ce    {addr/2}   ;main accumulator
                   SRCH            .eq     $d0    {addr/2}   ;pointer to search var table
                   TOKNDXSTK       .eq     $d1    {addr/32}  ;token index stack
                   SRCH2           .eq     $d2    {addr/2}   ;second var search pointer
                   IFFLAG          .eq     $d4               ;IF/THEN fail flag
                   CRFLAG          .eq     $d5               ;carriage return flag
                   VERBNOW         .eq     $d6               ;verb currently in use
                   PRFLAG          .eq     $d7               ;print it now flag
                   XSAVE           .eq     $d8               ;temp X-reg save
                   RUNFLAG         .eq     $d9               ;run mode flag
                   AUX             .eq     $da    {addr/2}   ;aux counter
                   PR              .eq     $dc    {addr/2}   ;current line value
                   PX              .eq     $e0    {addr/2}   ;pointer to current verb
                   P1              .eq     $e2    {addr/2}   ;aux pointer 1 (delete line ptr)
                   P2              .eq     $e4    {addr/2}   ;aux pointer 2 (line num , next num, ...)
                   P3              .eq     $e6    {addr/2}   ;aux pointer 3 (next ptr)
                   TOKNDX          .eq     $f1               ;token index val
                   PCON            .eq     $f2    {addr/2}   ;continue pointer (PRDEC low/hi)
                   AUTOINC         .eq     $f4    {addr/2}   ;auto line increment
                   AUTOLN          .eq     $f6    {addr/2}   ;current auto line
                   AUTOFLAG        .eq     $f8               ;auto line mode flag ($ff=on)
                   CHAR            .eq     $f9               ;current char
                   LEADZR          .eq     $fa               ;leading zeroes index ($00,$a0,$b0)
                   FORNDX          .eq     $fb               ;FOR-NEXT loop index
                   GOSUBNDX        .eq     $fc               ;GOSUB index
                   SYNSTKDX        .eq     $fd               ;syntax stack index val
                   SYNPAG          .eq     $fe    {addr/2}   ;pointer to syntax page
                   STK_00          .eq     $0100  {addr/15}
                   STK_10          .eq     $0110  {addr/15}
                   STK_20          .eq     $0120  {addr/15}
                   STK_30          .eq     $0130  {addr/15}
                   STK_40          .eq     $0140  {addr/15}
                   STK_50          .eq     $0150  {addr/15}
                   STK_60          .eq     $0160  {addr/15}
                   STK_70          .eq     $0170  {addr/15}
                   STK_80          .eq     $0180  {addr/15}
                   STK_90          .eq     $0190  {addr/15}
                   STK_A0          .eq     $01a0  {addr/15}
                   STK_B0          .eq     $01b0  {addr/15}
                   STK_C0          .eq     $01c0  {addr/15}
                   STK_D0          .eq     $01d0  {addr/15}
                   IN              .eq     $0200  {addr/256} ;input buffer
                   KBD             .eq     $c000             ;R last key pressed + 128
                   KBDSTRB         .eq     $c010             ;RW keyboard strobe
                   MON_PLOT        .eq     $f800             ;lo-res plot at X=Y-reg, Y=Acc
                   MON_HLINE       .eq     $f819             ;lo-res horiz line at Y=Acc with X from $2c
                   MON_VLINE       .eq     $f828             ;lo-res vert line at X=Y-reg and Y from Acc to $2b
                   MON_GBASCALC    .eq     $f847             ;compute gfx base addr for line in Acc
                   MON_SETCOL      .eq     $f864             ;set lo-res color to Acc
                   MON_PREAD       .eq     $fb1e             ;read paddle specifed by X-reg, return in Y-reg
                   MON_SETTXT      .eq     $fb39             ;set screen to text mode
                   MON_SETGR       .eq     $fb40             ;set screen to graphics mode
                   MON_VTAB        .eq     $fc22             ;tab to row specified in Acc
                   MON_NXTCHAR     .eq     $fd75
                   MON_CROUT       .eq     $fd8e             ;print a carriage return
                   MON_COUT        .eq     $fded             ;print Acc to output device via $36-37
                   MON_INPORT      .eq     $fe8b
                   MON_OUTPORT     .eq     $fe95
                   MON_WRITE       .eq     $fecd             ;write data to cassette
                   MON_WRITE0      .eq     $fecf
                   MON_READ        .eq     $fefd             ;read data from cassette
                   MON_BELL        .eq     $ff3a             ;sound bell

                                   .addrs  $e000
e000: 20 00 f0     BASIC           jsr     COLD
e003: 4c b3 e2     BASIC2          jmp     WARM

e006: 85 33        SetPrompt       sta     MON_PROMPT
e008: 4c ed fd                     jmp     MON_COUT

e00b: 60                           .dd1    $60

e00c: 8a           LE00C           txa                       ;print a trailing blank?
e00d: 29 20                        and     #$20
e00f: f0 23                        beq     :Return
e011: a9 a0        LE011           lda     #BLANK+128
e013: 85 e4                        sta     P2
e015: 4c ed fd                     jmp     MON_COUT

e018: a9 20        LE018           lda     #32
e01a: c5 24        LE01A           cmp     MON_CH            ;check line length
e01c: b0 0c                        bcs     NextByte          ;line too short
e01e: a9 8d                        lda     #CR+128           ;print CR, then 7 blanks
e020: a0 07                        ldy     #$07
e022: 20 ed fd     :Loop           jsr     MON_COUT
e025: a9 a0                        lda     #BLANK+128
e027: 88                           dey
e028: d0 f8                        bne     :Loop
e02a: a0 00        NextByte        ldy     #$00              ;get next byte 16-bit ptr
e02c: b1 e2                        lda     (P1),y
e02e: e6 e2                        inc     P1
e030: d0 02                        bne     :Return
e032: e6 e3                        inc     P1+1
e034: 60           :Return         rts

                   ; Token $75 , (with token $74 LIST)
                   ;  LIST 5,30
e035: 20 15 e7     COMMA_LIST      jsr     GET16BIT
e038: 20 76 e5                     jsr     LE576
e03b: a5 e2        LE03B           lda     P1
e03d: c5 e6                        cmp     P3
e03f: a5 e3                        lda     P1+1
e041: e5 e7                        sbc     P3+1
e043: b0 ef                        bcs     :Return
e045: 20 6d e0                     jsr     UNPACK
e048: 4c 3b e0                     jmp     LE03B

                   ; Token $76 LIST
                   ;  list entire program
e04b: a5 ca        LIST            lda     PP                ;P1 = PP
e04d: 85 e2                        sta     P1
e04f: a5 cb                        lda     PP+1
e051: 85 e3                        sta     P1+1
e053: a5 4c                        lda     HIMEM             ;P3 = HIMEM
e055: 85 e6                        sta     P3
e057: a5 4d                        lda     HIMEM+1
e059: 85 e7                        sta     P3+1
e05b: d0 de                        bne     LE03B             ;(always)
                   ; Token $74 LIST
                   ;  specific line number or range of numbers
                   ;  LIST 10: LIST 5,30
e05d: 20 15 e7     LISTNUM         jsr     GET16BIT
e060: 20 6d e5                     jsr     LE56D
e063: a5 e4                        lda     P2                ;P1 = P2
e065: 85 e2                        sta     P1
e067: a5 e5                        lda     P2+1
e069: 85 e3                        sta     P1+1
e06b: b0 c7                        bcs     :Return
                   ; Unpack tokens to mnemonics.
e06d: 86 d8        UNPACK          stx     XSAVE
e06f: a9 a0                        lda     #BLANK+128
e071: 85 fa                        sta     LEADZR
e073: 20 2a e0                     jsr     NextByte
e076: 98                           tya
e077: 85 e4        LE077           sta     P2
e079: 20 2a e0                     jsr     NextByte
e07c: aa                           tax
e07d: 20 2a e0                     jsr     NextByte
e080: 20 1b e5                     jsr     PRDEC
e083: 20 18 e0     :Loop           jsr     LE018
e086: 84 fa                        sty     LEADZR
e088: aa                           tax
e089: 10 18                        bpl     LE0A3
e08b: 0a                           asl     A
e08c: 10 e9                        bpl     LE077
e08e: a5 e4                        lda     P2
e090: d0 03                        bne     :NotEq
e092: 20 11 e0                     jsr     LE011
e095: 8a           :NotEq          txa
e096: 20 ed fd     :Loop           jsr     MON_COUT
e099: a9 25        LE099           lda     #$25
e09b: 20 1a e0                     jsr     LE01A
e09e: aa                           tax
e09f: 30 f5                        bmi     :Loop
e0a1: 85 e4                        sta     P2
e0a3: c9 01        LE0A3           cmp     #$01
e0a5: d0 05                        bne     :NotEq
e0a7: a6 d8                        ldx     XSAVE
e0a9: 4c 8e fd                     jmp     MON_CROUT

e0ac: 48           :NotEq          pha
e0ad: 84 ce                        sty     ACC
e0af: a2 ed                        ldx     #>SYNTABL2
e0b1: 86 cf                        stx     ACC+1
e0b3: c9 51                        cmp     #$51              ;END token
e0b5: 90 04                        bcc     :Loop1
e0b7: c6 cf                        dec     ACC+1             ;in SYNTABL
e0b9: e9 50                        sbc     #$50              ;TAB tkn
e0bb: 48           :Loop1          pha
e0bc: b1 ce                        lda     (ACC),y
e0be: aa           :Loop2          tax
e0bf: 88                           dey
e0c0: b1 ce                        lda     (ACC),y
e0c2: 10 fa                        bpl     :Loop2
e0c4: e0 c0                        cpx     #$c0
e0c6: b0 04                        bcs     LE0CC
e0c8: e0 00                        cpx     #$00
e0ca: 30 f2                        bmi     :Loop2
e0cc: aa           LE0CC           tax
e0cd: 68                           pla
e0ce: e9 01                        sbc     #$01              ;carry is set
e0d0: d0 e9                        bne     :Loop1
e0d2: 24 e4                        bit     P2
e0d4: 30 03                        bmi     :Loop
e0d6: 20 f8 ef                     jsr     LEFF8
e0d9: b1 ce        :Loop           lda     (ACC),y
e0db: 10 10                        bpl     LE0ED
e0dd: aa                           tax
e0de: 29 3f                        and     #$3f
e0e0: 85 e4                        sta     P2
e0e2: 18                           clc
e0e3: 69 a0                        adc     #BLANK+128
e0e5: 20 ed fd                     jsr     MON_COUT
e0e8: 88                           dey
e0e9: e0 c0                        cpx     #$c0
e0eb: 90 ec                        bcc     :Loop
e0ed: 20 0c e0     LE0ED           jsr     LE00C
e0f0: 68                           pla
e0f1: c9 5d                        cmp     #‘]’
e0f3: f0 a4                        beq     LE099
e0f5: c9 28                        cmp     #‘(’
e0f7: d0 8a                        bne     :Loop
e0f9: f0 9e                        beq     LE099             ;(always)

                   ; Token $2a (
                   ;   substring
                   ;   PRINT A$(12,14)
e0fb: 20 18 e1     PAREN_SUBSTR    jsr     LE118
e0fe: 95 50                        sta     NOUNSTKL,x
e100: d5 78                        cmp     NOUNSTKH,x
e102: 90 11        LE102           bcc     LE115
e104: a0 2b        PrintErr05      ldy     #<ErrMsg05        ;"STRING"
e106: 4c e0 e3     LE106           jmp     ERRMESS

                   ; Token $23 ,
                   ;   substring
                   ;   PRINT A$(3,3)
e109: 20 34 ee     COMMA_SUBSTR    jsr     GETBYTE
e10c: d5 50                        cmp     NOUNSTKL,x
e10e: 90 f4                        bcc     PrintErr05        ;"STRING"
e110: 20 e4 ef                     jsr     LEFE4
e113: 95 78                        sta     NOUNSTKH,x
e115: 4c 23 e8     LE115           jmp     TE823

e118: 20 34 ee     LE118           jsr     GETBYTE
e11b: f0 e7                        beq     PrintErr05        ;"STRING"
e11d: 38                           sec
e11e: e9 01                        sbc     #$01
e120: 60                           rts

                   ; Token $42 (
                   ;   string array is destination of the data
                   ;   A$(1)="HELLO"
e121: 20 18 e1     TE121           jsr     LE118
e124: 95 50                        sta     NOUNSTKL,x
e126: 18                           clc
e127: f5 78                        sbc     NOUNSTKH,x
e129: 4c 02 e1                     jmp     LE102

e12c: a0 14        PrintErr03      ldy     #<ErrMsg03        ;"MEM FULL"
e12e: d0 d6                        bne     LE106             ;(always)

                   ; Token $43 ,
                   ;   next var in DIM statement is string
                   ;   DIM X(5),A$(5)
                   ; token $4e DIM
                   ;   string var uses token $22 (
                   ;   DIM A$(5)
e130: 20 18 e1     DIMSTR          jsr     LE118
e133: e8                           inx
e134: b5 50        LE134           lda     NOUNSTKL,x
e136: 85 da                        sta     AUX
e138: 65 ce                        adc     ACC
e13a: 48                           pha
e13b: a8                           tay
e13c: b5 78                        lda     NOUNSTKH,x
e13e: 85 db                        sta     AUX+1
e140: 65 cf                        adc     ACC+1
e142: 48                           pha
e143: c4 ca                        cpy     PP
e145: e5 cb                        sbc     PP+1
e147: b0 e3                        bcs     PrintErr03        ;"MEM FULL"
e149: a5 da                        lda     AUX               ;AUX = AUX - 2
e14b: 69 fe                        adc     #$fe
e14d: 85 da                        sta     AUX
e14f: a9 ff                        lda     #$ff
e151: a8                           tay
e152: 65 db                        adc     AUX+1
e154: 85 db                        sta     AUX+1
e156: c8           :Loop1          iny
e157: b1 da                        lda     (AUX),y
e159: d9 cc 00                     cmp     PV,y
e15c: d0 0f                        bne     DimErr
e15e: 98                           tya
e15f: f0 f5                        beq     :Loop1
e161: 68           :Loop2          pla
e162: 91 da                        sta     (AUX),y
e164: 99 cc 00                     sta     PV,y
e167: 88                           dey
e168: 10 f7                        bpl     :Loop2
e16a: e8                           inx
e16b: 60                           rts

e16c: ea                           .dd1    $ea

e16d: a0 80        DimErr          ldy     #<ErrMsg17        ;"DIM"
e16f: d0 95        LE16F           bne     LE106             ;(always)

                   ; Input a string.
e171: a9 00        INPUTSTR        lda     #$00
e173: 20 0a e7                     jsr     LE70A
e176: a0 02                        ldy     #$02
e178: 94 78                        sty     NOUNSTKH,x
e17a: 20 0a e7                     jsr     LE70A
e17d: 86 d8                        stx     XSAVE
e17f: aa                           tax
e180: e6 33                        inc     MON_PROMPT        ;change '>' to '?'
e182: 20 51 f3                     jsr     RDKEY
e185: c6 33                        dec     MON_PROMPT        ;change '?' to '>'
e187: 8a                           txa
e188: a6 d8                        ldx     XSAVE
e18a: 95 78                        sta     NOUNSTKH,x
                   ; Token $70 =
                   ;   string - non-conditional
                   ;   A$ = "HELLO"
e18c: b5 51        TE18C           lda     NOUNSTKL+1,x
e18e: 85 ce                        sta     ACC
e190: b5 79                        lda     NOUNSTKH+1,x
e192: 85 cf                        sta     ACC+1
e194: e8                           inx
e195: e8                           inx
e196: 20 bc e1                     jsr     LE1BC
e199: b5 4e        :Loop           lda     NOUNSTKL-2,x
e19b: d5 76                        cmp     NOUNSTKH-2,x
e19d: b0 15                        bcs     LE1B4
e19f: f6 4e                        inc     NOUNSTKL-2,x
e1a1: a8                           tay
e1a2: b1 ce                        lda     (ACC),y
e1a4: b4 50                        ldy     NOUNSTKL,x
e1a6: c4 e4                        cpy     P2
e1a8: 90 04                        bcc     LE1AE
e1aa: a0 83                        ldy     #<ErrMsg18        ;"STR OVFL"
e1ac: d0 c1                        bne     LE16F             ;(always)

e1ae: 91 da        LE1AE           sta     (AUX),y
e1b0: f6 50                        inc     NOUNSTKL,x
e1b2: 90 e5                        bcc     :Loop

e1b4: b4 50        LE1B4           ldy     NOUNSTKL,x
e1b6: 8a                           txa
e1b7: 91 da                        sta     (AUX),y
e1b9: 4c 23 f2                     jmp     LF223

e1bc: b5 51        LE1BC           lda     NOUNSTKL+1,x
e1be: 85 da                        sta     AUX
e1c0: 38                           sec
e1c1: e9 02                        sbc     #$02
e1c3: 85 e4                        sta     P2
e1c5: b5 79                        lda     NOUNSTKH+1,x
e1c7: 85 db                        sta     AUX+1
e1c9: e9 00                        sbc     #$00
e1cb: 85 e5                        sta     P2+1
e1cd: a0 00                        ldy     #$00
e1cf: b1 e4                        lda     (P2),y
e1d1: 18                           clc
e1d2: e5 da                        sbc     AUX
e1d4: 85 e4                        sta     P2
e1d6: 60                           rts

                   ; Token $39 =
                   ;   string logic op
                   ;   IF A$ = "CAT" THEN END
e1d7: b5 53        TE1D7           lda     NOUNSTKL+3,x
e1d9: 85 ce                        sta     ACC
e1db: b5 7b                        lda     NOUNSTKH+3,x
e1dd: 85 cf                        sta     ACC+1
e1df: b5 51                        lda     NOUNSTKL+1,x
e1e1: 85 da                        sta     AUX
e1e3: b5 79                        lda     NOUNSTKH+1,x
e1e5: 85 db                        sta     AUX+1
e1e7: e8                           inx
e1e8: e8                           inx
e1e9: e8                           inx
e1ea: a0 00                        ldy     #$00
e1ec: 94 78                        sty     NOUNSTKH,x
e1ee: 94 a0                        sty     NOUNSTKC,x
e1f0: c8                           iny
e1f1: 94 50                        sty     NOUNSTKL,x
e1f3: b5 4d        LE1F3           lda     HIMEM+1,x
e1f5: d5 75                        cmp     NOUNSTKH-3,x
e1f7: 08                           php
e1f8: 48                           pha
e1f9: b5 4f                        lda     NOUNSTKL-1,x
e1fb: d5 77                        cmp     NOUNSTKH-1,x
e1fd: 90 07                        bcc     LE206
e1ff: 68                           pla
e200: 28                           plp
e201: b0 02                        bcs     :Return
e203: 56 50        :LoopExit       lsr     NOUNSTKL,x
e205: 60           :Return         rts

e206: a8           LE206           tay
e207: b1 ce                        lda     (ACC),y
e209: 85 e4                        sta     P2
e20b: 68                           pla
e20c: a8                           tay
e20d: 28                           plp
e20e: b0 f3                        bcs     :LoopExit
e210: b1 da                        lda     (AUX),y
e212: c5 e4                        cmp     P2
e214: d0 ed                        bne     :LoopExit
e216: f6 4f                        inc     NOUNSTKL-1,x
e218: f6 4d                        inc     HIMEM+1,x
e21a: b0 d7                        bcs     LE1F3             ;(always)
                   ; Token $3a #
                   ;   string logic op
                   ;   IF A$ # "CAT" THEN END
e21c: 20 d7 e1     TE21C           jsr     TE1D7
e21f: 4c 36 e7                     jmp     NOT

                   ; Token $14 *
                   ;   num math op
                   ;   A = 27 * 2
e222: 20 54 e2     MULT            jsr     LE254
e225: 06 ce        :Loop           asl     ACC
e227: 26 cf                        rol     ACC+1             ;add partial product if C flag set
e229: 90 0d                        bcc     LE238
e22b: 18                           clc
e22c: a5 e6                        lda     P3
e22e: 65 da                        adc     AUX
e230: 85 e6                        sta     P3
e232: a5 e7                        lda     P3+1
e234: 65 db                        adc     AUX+1
e236: 85 e7                        sta     P3+1
e238: 88           LE238           dey
e239: f0 09                        beq     MultEnd           ;exit loop
e23b: 06 e6                        asl     P3
e23d: 26 e7                        rol     P3+1
e23f: 10 e4                        bpl     :Loop
e241: 4c 7e e7                     jmp     Err32767

e244: a5 e6        MultEnd         lda     P3
e246: 20 08 e7                     jsr     LE708
e249: a5 e7                        lda     P3+1
e24b: 95 a0                        sta     NOUNSTKC,x
e24d: 06 e5                        asl     P2+1
e24f: 90 28                        bcc     :Return
e251: 4c 6f e7                     jmp     NEGATE

e254: a9 55        LE254           lda     #$55
e256: 85 e5                        sta     P2+1
e258: 20 5b e2                     jsr     LE25B
e25b: a5 ce        LE25B           lda     ACC               ;AUX = ACC
e25d: 85 da                        sta     AUX
e25f: a5 cf                        lda     ACC+1
e261: 85 db                        sta     AUX+1
e263: 20 15 e7                     jsr     GET16BIT
e266: 84 e6                        sty     P3
e268: 84 e7                        sty     P3+1
e26a: a5 cf                        lda     ACC+1
e26c: 10 09                        bpl     LE277
e26e: ca                           dex
e26f: 06 e5                        asl     P2+1
e271: 20 6f e7                     jsr     NEGATE
e274: 20 15 e7                     jsr     GET16BIT
e277: a0 10        LE277           ldy     #$10
e279: 60           :Return         rts

                   ; Token $1f MOD
                   ;   num op
                   ;   IF X MOD 13 THEN END
e27a: 20 6c ee     MOD             jsr     LEE6C
e27d: f0 c5                        beq     MultEnd           ;(always)
e27f: ff                           .dd1    $ff

e280: e6 33        LE280           inc     MON_PROMPT        ;change '>' to '?'
e282: a0 00                        ldy     #$00
e284: 20 ce e3                     jsr     GETCMD
e287: c6 33                        dec     MON_PROMPT        ;change '?' to '>'
e289: 60                           rts

                   ; Token $3d SCRN(
                   ;   PRINT SCRN(X,Y)
e28a: 20 34 ee     SCRN            jsr     GETBYTE
e28d: 4a                           lsr     A                 ;A-reg = A-reg / 2
e28e: 08                           php                       ;stash carry (lsb)
e28f: 20 47 f8                     jsr     MON_GBASCALC
e292: 20 34 ee                     jsr     GETBYTE
e295: a8                           tay
e296: b1 26                        lda     (MON_GBASL),y     ;get screen byte
e298: 28                           plp                       ;retrieve carry
e299: 90 04                        bcc     LE29F
e29b: 4a                           lsr     A                 ;odd; upper half
e29c: 4a                           lsr     A
e29d: 4a                           lsr     A
e29e: 4a                           lsr     A
e29f: 29 0f        LE29F           and     #$0f              ;A-reg = color number
e2a1: a0 00                        ldy     #$00
e2a3: 20 08 e7                     jsr     LE708
e2a6: 94 a0                        sty     NOUNSTKC,x
e2a8: 88                           dey
e2a9: 84 d7                        sty     PRFLAG            ;PRFLAG = $ff
                   ; Token $3e ,
                   ;   PRINT SCRN(X,Y)
e2ab: 60           COMMA_SCRN      rts

e2ac: ff ff ff ff                  .bulk   $ff,$ff,$ff,$ff

e2b0: 20 d3 ef     unref_e2b0      jsr     LEFD3             ;old 4K cold start
                   ; Warm start.  Main compile / execute code.
e2b3: 20 8e fd     WARM            jsr     MON_CROUT         ;emit blank line
e2b6: 46 d9        LE2B6           lsr     RUNFLAG           ;not running
e2b8: a9 be                        lda     #“>”
e2ba: 20 06 e0                     jsr     SetPrompt         ;set and print prompt char
e2bd: a0 00                        ldy     #$00
e2bf: 84 fa                        sty     LEADZR            ;no leading zeroes for AUTOLN
e2c1: 24 f8                        bit     AUTOFLAG          ;AUTO?
e2c3: 10 0c                        bpl     LE2D1
e2c5: a6 f6                        ldx     AUTOLN            ;yes, print line number
e2c7: a5 f7                        lda     AUTOLN+1
e2c9: 20 1b e5                     jsr     PRDEC
e2cc: a9 a0                        lda     #BLANK+128
e2ce: 20 ed fd                     jsr     MON_COUT
e2d1: a2 ff        LE2D1           ldx     #$ff              ;init S-reg
e2d3: 9a                           txs
e2d4: 20 ce e3                     jsr     GETCMD
e2d7: 84 f1                        sty     TOKNDX
e2d9: 8a                           txa
e2da: 85 c8                        sta     TXTNDX
e2dc: a2 20                        ldx     #$20
e2de: 20 91 e4                     jsr     LE491
e2e1: a5 c8                        lda     TXTNDX            ;PX = TXTNDX + $0200 + C-flag
e2e3: 69 00                        adc     #$00
e2e5: 85 e0                        sta     PX
e2e7: a9 00                        lda     #$00
e2e9: aa                           tax
e2ea: 69 02                        adc     #$02
e2ec: 85 e1                        sta     PX+1
e2ee: a1 e0                        lda     (PX,x)
e2f0: 29 f0                        and     #$f0
e2f2: c9 b0                        cmp     #“0”
e2f4: f0 03                        beq     LE2F9
e2f6: 4c 83 e8                     jmp     LE883

e2f9: a0 02        LE2F9           ldy     #$02              ;move two bytes
e2fb: b1 e0        LE2FB           lda     (PX),y
e2fd: 99 cd 00                     sta     ACC-1,y
e300: 88                           dey
e301: d0 f8                        bne     LE2FB
e303: 20 8a e3                     jsr     LE38A
e306: a5 f1                        lda     TOKNDX
e308: e5 c8                        sbc     TXTNDX
e30a: c9 04                        cmp     #$04
e30c: f0 a8                        beq     LE2B6
e30e: 91 e0                        sta     (PX),y
e310: a5 ca                        lda     PP                ;P2 = PP - (PX),Y
e312: f1 e0                        sbc     (PX),y
e314: 85 e4                        sta     P2
e316: a5 cb                        lda     PP+1
e318: e9 00                        sbc     #$00
e31a: 85 e5                        sta     P2+1
e31c: a5 e4                        lda     P2
e31e: c5 cc                        cmp     PV
e320: a5 e5                        lda     P2+1
e322: e5 cd                        sbc     PV+1
e324: 90 45                        bcc     MEMFULL
e326: a5 ca        LE326           lda     PP                ;P3 = PP - (PX),Y
e328: f1 e0                        sbc     (PX),y
e32a: 85 e6                        sta     P3
e32c: a5 cb                        lda     PP+1
e32e: e9 00                        sbc     #$00
e330: 85 e7                        sta     P3+1
e332: b1 ca                        lda     (PP),y
e334: 91 e6                        sta     (P3),y
e336: e6 ca                        inc     PP
e338: d0 02                        bne     LE33C
e33a: e6 cb                        inc     PP+1
e33c: a5 e2        LE33C           lda     P1
e33e: c5 ca                        cmp     PP
e340: a5 e3                        lda     P1+1
e342: e5 cb                        sbc     PP+1
e344: b0 e0                        bcs     LE326
e346: b5 e4        LE346           lda     P2,x
e348: 95 ca                        sta     PP,x
e34a: ca                           dex
e34b: 10 f9                        bpl     LE346
e34d: b1 e0                        lda     (PX),y
e34f: a8                           tay
e350: 88           LE350           dey
e351: b1 e0                        lda     (PX),y
e353: 91 e6                        sta     (P3),y
e355: 98                           tya
e356: d0 f8                        bne     LE350
e358: 24 f8                        bit     AUTOFLAG          ;auto line?
e35a: 10 09                        bpl     LE365             ;no, branch
e35c: b5 f7        :Loop           lda     AUTOLN+1,x        ;AUTOLN = AUTOLN + AUTOINC
e35e: 75 f5                        adc     AUTOINC+1,x
e360: 95 f7                        sta     AUTOLN+1,x
e362: e8                           inx
e363: f0 f7                        beq     :Loop
e365: 10 7e        LE365           bpl     LE3E5
e367: 00                           brk

e368: 00 00 00                     .bulk   $00,$00,$00

e36b: a0 14        MEMFULL         ldy     #<ErrMsg03        ;"MEM FULL"
e36d: d0 71                        bne     ERRMESS           ;(always)

                   ; Token $0a ,
                   ;   DEL 0,10
e36f: 20 15 e7     COMMA_DEL       jsr     GET16BIT
e372: a5 e2                        lda     P1                ;P3 = P1
e374: 85 e6                        sta     P3
e376: a5 e3                        lda     P1+1
e378: 85 e7                        sta     P3+1
e37a: 20 75 e5                     jsr     LE575
e37d: a5 e2                        lda     P1                ;P2 = P1
e37f: 85 e4                        sta     P2
e381: a5 e3                        lda     P1+1
e383: 85 e5                        sta     P2+1
e385: d0 0e                        bne     LE395             ;(always?)
                   ; Token $09 DEL
e387: 20 15 e7     DEL             jsr     GET16BIT
e38a: 20 6d e5     LE38A           jsr     LE56D
e38d: a5 e6                        lda     P3                ;P1 = P3
e38f: 85 e2                        sta     P1
e391: a5 e7                        lda     P3+1
e393: 85 e3                        sta     P1+1
                   ; Memory move: P3 < PP.P2 backwards.
e395: a0 00        LE395           ldy     #$00
e397: a5 ca        :Loop           lda     PP
e399: c5 e4                        cmp     P2
e39b: a5 cb                        lda     PP+1
e39d: e5 e5                        sbc     P2+1
e39f: b0 16                        bcs     LE3B7
e3a1: a5 e4                        lda     P2
e3a3: d0 02                        bne     LE3A7
e3a5: c6 e5                        dec     P2+1
e3a7: c6 e4        LE3A7           dec     P2
e3a9: a5 e6                        lda     P3
e3ab: d0 02                        bne     LE3AF
e3ad: c6 e7                        dec     P3+1
e3af: c6 e6        LE3AF           dec     P3
e3b1: b1 e4                        lda     (P2),y
e3b3: 91 e6                        sta     (P3),y
e3b5: 90 e0                        bcc     :Loop

e3b7: a5 e6        LE3B7           lda     P3                ;PP = P3
e3b9: 85 ca                        sta     PP
e3bb: a5 e7                        lda     P3+1
e3bd: 85 cb                        sta     PP+1
e3bf: 60                           rts

e3c0: 20 ed fd     :Loop           jsr     MON_COUT          ;print error message
e3c3: c8                           iny
                   ; Print error message routine entry point.
e3c4: b9 00 eb     ERRORMESS       lda     ErrMsg00,y
e3c7: 30 f7                        bmi     :Loop
e3c9: 09 80                        ora     #$80
e3cb: 4c ed fd                     jmp     MON_COUT

e3ce: 98           GETCMD          tya
e3cf: aa                           tax
e3d0: 20 75 fd                     jsr     MON_NXTCHAR
e3d3: 8a                           txa
e3d4: a8                           tay
e3d5: a9 df                        lda     #“_”              ;underline problem?
e3d7: 99 00 02                     sta     IN,y
e3da: a2 ff                        ldx     #$ff
e3dc: 60                           rts

e3dd: 60                           .dd1    $60

e3de: a0 06        ErrTooLong      ldy     #<ErrMsg01        ;"TOO LONG"
                   ; Print error message and goto mainline.
e3e0: 20 d3 ee     ERRMESS         jsr     PRINTERR
                   ; DOS 3.3 chains here when processing errors.
e3e3: 24 d9                        bit     RUNFLAG
e3e5: 30 03        LE3E5           bmi     LE3EA
e3e7: 4c b6 e2                     jmp     LE2B6

e3ea: 4c 9a eb     LE3EA           jmp     LEB9A

e3ed: 2a           LE3ED           rol     A
e3ee: 69 a0                        adc     #$a0
e3f0: dd 00 02                     cmp     IN,x
e3f3: d0 53                        bne     LE448
e3f5: b1 fe                        lda     (SYNPAG),y
e3f7: 0a                           asl     A
e3f8: 30 06                        bmi     LE400
e3fa: 88                           dey
e3fb: b1 fe                        lda     (SYNPAG),y
e3fd: 30 29                        bmi     LE428
e3ff: c8                           iny
e400: 86 c8        LE400           stx     TXTNDX
e402: 98                           tya
e403: 48                           pha
e404: a2 00                        ldx     #$00
e406: a1 fe                        lda     (SYNPAG,x)
e408: aa                           tax
e409: 4a           :Loop           lsr     A
e40a: 49 40                        eor     #$40
e40c: 11 fe                        ora     (SYNPAG),y
e40e: c9 c0                        cmp     #$c0
e410: 90 01                        bcc     LE413
e412: e8                           inx
e413: c8           LE413           iny
e414: d0 f3                        bne     :Loop
e416: 68                           pla
e417: a8                           tay
e418: 8a                           txa
e419: 4c f8 f2                     jmp     LF2F8

e41c: e6 f1        LE41C           inc     TOKNDX
e41e: a6 f1                        ldx     TOKNDX
e420: f0 bc                        beq     ErrTooLong
e422: 9d 00 02                     sta     IN,x
e425: 60           :Return         rts

e426: a6 c8        LE426           ldx     TXTNDX
e428: a9 a0        LE428           lda     #BLANK+128
e42a: e8           LE42A           inx
e42b: dd 00 02                     cmp     IN,x
e42e: b0 fa                        bcs     LE42A
e430: b1 fe                        lda     (SYNPAG),y
e432: 29 3f                        and     #$3f
e434: 4a                           lsr     A
e435: d0 b6                        bne     LE3ED
e437: bd 00 02                     lda     IN,x
e43a: b0 06                        bcs     LE442
e43c: 69 3f                        adc     #$3f
e43e: c9 1a                        cmp     #$1a
e440: 90 6f                        bcc     LE4B1
e442: 69 4f        LE442           adc     #$4f
e444: c9 0a                        cmp     #$0a
e446: 90 69                        bcc     LE4B1
e448: a6 fd        LE448           ldx     SYNSTKDX
e44a: c8           :Loop1          iny
e44b: b1 fe                        lda     (SYNPAG),y
e44d: 29 e0                        and     #$e0
e44f: c9 20                        cmp     #$20
e451: f0 7a                        beq     LE4CD
e453: b5 a8                        lda     TXTNDXSTK,x
e455: 85 c8                        sta     TXTNDX
e457: b5 d1                        lda     TOKNDXSTK,x
e459: 85 f1                        sta     TOKNDX
e45b: 88           :Loop2          dey
e45c: b1 fe                        lda     (SYNPAG),y
e45e: 0a                           asl     A                 ;double
e45f: 10 fa                        bpl     :Loop2
e461: 88                           dey
e462: b0 38                        bcs     LE49C
e464: 0a                           asl     A
e465: 30 35                        bmi     LE49C
e467: b4 58                        ldy     SYNSTKH,x
e469: 84 ff                        sty     SYNPAG+1
e46b: b4 80                        ldy     SYNSTKL,x
e46d: e8                           inx
e46e: 10 da                        bpl     :Loop1
e470: f0 b3        LE470           beq     :Return
e472: c9 7e                        cmp     #$7e
e474: b0 22                        bcs     LE498
e476: ca                           dex
e477: 10 04                        bpl     LE47D
e479: a0 06                        ldy     #<ErrMsg01        ;"TOO LONG"
                   ; BUG: above line should be ErrMsg04, "TOO MANY PARENS".  See Call-A.P.P.L.E.
                   ; Mar 1983 p.114.
e47b: 10 29                        bpl     LE4A6             ;(always)

e47d: 94 80        LE47D           sty     SYNSTKL,x
e47f: a4 ff                        ldy     SYNPAG+1
e481: 94 58                        sty     SYNSTKH,x
e483: a4 c8                        ldy     TXTNDX
e485: 94 a8                        sty     TXTNDXSTK,x
e487: a4 f1                        ldy     TOKNDX
e489: 94 d1                        sty     TOKNDXSTK,x
e48b: 29 1f                        and     #$1f
e48d: a8                           tay
e48e: b9 97 f1                     lda     SYNTABLNDX,y
e491: 0a           LE491           asl     A                 ;double
e492: a8                           tay
e493: a9 76                        lda     #>SYNTABL-$7600   ;[#>SYNTABL/2]
e495: 2a                           rol     A
e496: 85 ff                        sta     SYNPAG+1
e498: d0 01        LE498           bne     LE49B
e49a: c8                           iny
e49b: c8           LE49B           iny
e49c: 86 fd        LE49C           stx     SYNSTKDX
e49e: b1 fe                        lda     (SYNPAG),y
e4a0: 30 84                        bmi     LE426
e4a2: d0 05                        bne     LE4A9
e4a4: a0 0e                        ldy     #<ErrMsg02        ;"SYNTAX"
e4a6: 4c e0 e3     LE4A6           jmp     ERRMESS

e4a9: c9 03        LE4A9           cmp     #$03
e4ab: b0 c3                        bcs     LE470
e4ad: 4a                           lsr     A                 ;halve
e4ae: a6 c8                        ldx     TXTNDX
e4b0: e8                           inx
e4b1: bd 00 02     LE4B1           lda     IN,x
e4b4: 90 04                        bcc     LE4BA
e4b6: c9 a2                        cmp     #DQT+128
e4b8: f0 0a                        beq     LE4C4
e4ba: c9 df        LE4BA           cmp     #“_”              ;underline problem?
e4bc: f0 06                        beq     LE4C4
e4be: 86 c8                        stx     TXTNDX
e4c0: 20 1c e4     LE4C0           jsr     LE41C
e4c3: c8                           iny
e4c4: 88           LE4C4           dey
e4c5: a6 fd                        ldx     SYNSTKDX
e4c7: b1 fe        :Loop           lda     (SYNPAG),y
e4c9: 88                           dey
e4ca: 0a                           asl     A
e4cb: 10 cf                        bpl     LE49C
e4cd: b4 58        LE4CD           ldy     SYNSTKH,x
e4cf: 84 ff                        sty     SYNPAG+1
e4d1: b4 80                        ldy     SYNSTKL,x
e4d3: e8                           inx
e4d4: b1 fe                        lda     (SYNPAG),y
e4d6: 29 9f                        and     #%10011111
e4d8: d0 ed                        bne     :Loop
e4da: 85 f2                        sta     PCON
e4dc: 85 f3                        sta     PCON+1
e4de: 98                           tya
e4df: 48                           pha
e4e0: 86 fd                        stx     SYNSTKDX
e4e2: b4 d0                        ldy     TOKNDXSTK-1,x
e4e4: 84 c9                        sty     LEADBL
e4e6: 18                           clc
e4e7: a9 0a        :Loop1          lda     #$0a
e4e9: 85 f9                        sta     CHAR
e4eb: a2 00                        ldx     #$00
e4ed: c8                           iny
e4ee: b9 00 02                     lda     IN,y
e4f1: 29 0f                        and     #$0f
e4f3: 65 f2        :Loop2          adc     PCON
e4f5: 48                           pha
e4f6: 8a                           txa
e4f7: 65 f3                        adc     PCON+1
e4f9: 30 1c                        bmi     LE517
e4fb: aa                           tax
e4fc: 68                           pla
e4fd: c6 f9                        dec     CHAR
e4ff: d0 f2                        bne     :Loop2
e501: 85 f2                        sta     PCON
e503: 86 f3                        stx     PCON+1
e505: c4 f1                        cpy     TOKNDX
e507: d0 de                        bne     :Loop1
e509: a4 c9                        ldy     LEADBL
e50b: c8                           iny
e50c: 84 f1                        sty     TOKNDX
e50e: 20 1c e4                     jsr     LE41C
e511: 68                           pla
e512: a8                           tay
e513: a5 f3                        lda     PCON+1
e515: b0 a9                        bcs     LE4C0
e517: a0 00        LE517           ldy     #<ErrMsg00        ;">32767"
e519: 10 8b                        bpl     LE4A6             ;(always)

                   ; Prints a 16-bit number in decimal.
                   ; On entry:
                   ;   A-reg: high byte
                   ;   X-reg: low byte
e51b: 85 f3        PRDEC           sta     PCON+1
e51d: 86 f2                        stx     PCON
e51f: a2 04                        ldx     #$04
e521: 86 c9                        stx     LEADBL
e523: a9 b0        :Loop1          lda     #“0”
e525: 85 f9                        sta     CHAR
e527: a5 f2        :Loop2          lda     PCON
e529: dd 63 e5                     cmp     NUMLOW,x
e52c: a5 f3                        lda     PCON+1
e52e: fd 68 e5                     sbc     NUMHI,x
e531: 90 0d                        bcc     LE540
e533: 85 f3                        sta     PCON+1
e535: a5 f2                        lda     PCON
e537: fd 63 e5                     sbc     NUMLOW,x
e53a: 85 f2                        sta     PCON
e53c: e6 f9                        inc     CHAR
e53e: d0 e7                        bne     :Loop2
e540: a5 f9        LE540           lda     CHAR
e542: e8                           inx
e543: ca                           dex
e544: f0 0e                        beq     PRDEC5
e546: c9 b0                        cmp     #“0”
e548: f0 02                        beq     LE54C
e54a: 85 c9                        sta     LEADBL
e54c: 24 c9        LE54C           bit     LEADBL
e54e: 30 04                        bmi     PRDEC5
e550: a5 fa                        lda     LEADZR
e552: f0 0b                        beq     PRDEC6
                   ; PRINT
e554: 20 ed fd     PRDEC5          jsr     MON_COUT
e557: 24 f8                        bit     AUTOFLAG          ;auto line?
e559: 10 04                        bpl     PRDEC6
e55b: 99 00 02                     sta     IN,y
e55e: c8                           iny
                   ; NXTX
e55f: ca           PRDEC6          dex
e560: 10 c1                        bpl     :Loop1
e562: 60                           rts

e563: 01           NUMLOW          .dd1    1                 ;1
e564: 0a                           .dd1    10                ;10
e565: 64                           .dd1    100               ;100
e566: e8                           .dd1    $e8               ;1000 ($3e8)
e567: 10                           .dd1    $10               ;10000 ($2710
e568: 00           NUMHI           .dd1    0                 ;1
e569: 00                           .dd1    0                 ;10
e56a: 00                           .dd1    0                 ;100
e56b: 03                           .dd1    $03               ;1000 ($03e8)
e56c: 27                           .dd1    $27               ;10000 ($2710)

e56d: a5 ca        LE56D           lda     PP                ;P3 = PP
e56f: 85 e6                        sta     P3
e571: a5 cb                        lda     PP+1
e573: 85 e7                        sta     P3+1
e575: e8           LE575           inx
e576: a5 e7        LE576           lda     P3+1              ;P2 = P3
e578: 85 e5                        sta     P2+1
e57a: a5 e6                        lda     P3
e57c: 85 e4                        sta     P2
e57e: c5 4c                        cmp     HIMEM             ;compare P2 and HIMEM
e580: a5 e5                        lda     P2+1
e582: e5 4d                        sbc     HIMEM+1
e584: b0 26                        bcs     :Return
e586: a0 01                        ldy     #$01
e588: b1 e4                        lda     (P2),y
e58a: e5 ce                        sbc     ACC
e58c: c8                           iny
e58d: b1 e4                        lda     (P2),y
e58f: e5 cf                        sbc     ACC+1
e591: b0 19                        bcs     :Return
e593: a0 00                        ldy     #$00
e595: a5 e6                        lda     P3                ;P3 = P3.W + (P2).B
e597: 71 e4                        adc     (P2),y
e599: 85 e6                        sta     P3
e59b: 90 03                        bcc     LE5A0
e59d: e6 e7                        inc     P3+1
e59f: 18                           clc
e5a0: c8           LE5A0           iny
e5a1: a5 ce                        lda     ACC               ;is ACC+1 <HS> (P2),Y?
e5a3: f1 e4                        sbc     (P2),y
e5a5: c8                           iny
e5a6: a5 cf                        lda     ACC+1
e5a8: f1 e4                        sbc     (P2),y
e5aa: b0 ca                        bcs     LE576
e5ac: 60           :Return         rts

                   ; Token $0b NEW
                   ;   turn off AUTO
                   ;   remove program
                   ;   fall into CLR
e5ad: 46 f8        NEW             lsr     AUTOFLAG          ;manual
e5af: a5 4c                        lda     HIMEM             ;PP = HIMEM
e5b1: 85 ca                        sta     PP
e5b3: a5 4d                        lda     HIMEM+1
e5b5: 85 cb                        sta     PP+1
                   ; Token $0c CLR
                   ;   remove variables
                   ;   remove FOR loops and GOSUBs
e5b7: a5 4a        CLR             lda     LOMEM             ;PV = LOMEM
e5b9: 85 cc                        sta     PV
e5bb: a5 4b                        lda     LOMEM+1
e5bd: 85 cd                        sta     PV+1
e5bf: a9 00                        lda     #$00
e5c1: 85 fb                        sta     FORNDX            ;no FORs
e5c3: 85 fc                        sta     GOSUBNDX          ;no GOSUBs
e5c5: 85 fe                        sta     SYNPAG
e5c7: a9 00                        lda     #$00              ;?
e5c9: 85 1d                        sta     $1d               ;?
e5cb: 60                           rts

e5cc: a5 d0        unref_e5cc      lda     SRCH
e5ce: 4c 6b e3     ErrMemFull      jmp     MEMFULL

e5d1: a0 ff        :Loop1          ldy     #$ff
e5d3: 84 d8        :Loop2          sty     XSAVE
e5d5: c8           :Loop3          iny
e5d6: b1 e0                        lda     (PX),y
e5d8: 30 06                        bmi     LE5E0
e5da: c9 40                        cmp     #$40
e5dc: d0 68                        bne     LE646             ;exit loop
e5de: 85 d8                        sta     XSAVE
e5e0: d1 d0        LE5E0           cmp     (SRCH),y
e5e2: f0 f1                        beq     :Loop3
e5e4: b1 d0        LE5E4           lda     (SRCH),y
e5e6: c8           LE5E6           iny
e5e7: 4a                           lsr     A
e5e8: d0 fa                        bne     LE5E4
e5ea: b1 d0                        lda     (SRCH),y
e5ec: 48                           pha
e5ed: c8                           iny
e5ee: b1 d0                        lda     (SRCH),y
e5f0: a8                           tay
e5f1: 68                           pla
e5f2: 85 d0        LE5F2           sta     SRCH
e5f4: 84 d1                        sty     SRCH+1
e5f6: c5 cc                        cmp     PV
e5f8: d0 d7                        bne     :Loop1
e5fa: c4 cd                        cpy     PV+1
e5fc: d0 d3                        bne     :Loop1
e5fe: a0 00                        ldy     #$00
e600: c8           :Loop           iny
e601: b1 e0                        lda     (PX),y
e603: 30 fb                        bmi     :Loop
e605: 49 40                        eor     #$40
e607: f0 f7                        beq     :Loop
e609: 98                           tya
e60a: 69 04                        adc     #$04
e60c: 48                           pha
e60d: 65 d0                        adc     SRCH
e60f: a8                           tay
e610: a5 d1                        lda     SRCH+1
e612: 69 00                        adc     #$00
e614: 48                           pha
e615: c4 ca                        cpy     PP
e617: e5 cb                        sbc     PP+1
e619: b0 b3                        bcs     ErrMemFull        ;"MEM FULL"
e61b: 84 cc                        sty     PV
e61d: 68                           pla
e61e: 85 cd                        sta     PV+1
e620: 68                           pla
e621: a8                           tay
e622: a9 00                        lda     #$00
e624: 88                           dey
e625: 91 d0                        sta     (SRCH),y
e627: 88                           dey
e628: 91 d0                        sta     (SRCH),y
e62a: 88                           dey
e62b: a5 cd                        lda     PV+1
e62d: 91 d0                        sta     (SRCH),y
e62f: 88                           dey
e630: a5 cc                        lda     PV
e632: 91 d0                        sta     (SRCH),y
e634: 88                           dey
e635: a9 00                        lda     #$00
e637: 91 d0        :Loop           sta     (SRCH),y
e639: 88                           dey
e63a: 30 97                        bmi     :Loop2
e63c: b1 e0                        lda     (PX),y
e63e: d0 f7                        bne     :Loop             ;(always)

e640: a5 4a        LE640           lda     LOMEM
e642: a4 4b                        ldy     LOMEM+1
e644: d0 ac                        bne     LE5F2             ;(always)

e646: b1 d0        LE646           lda     (SRCH),y
e648: c9 40                        cmp     #$40
e64a: b0 9a                        bcs     LE5E6
e64c: 95 9f                        sta     NOUNSTKC-1,x
e64e: 98                           tya
e64f: 69 03                        adc     #$03
e651: 48                           pha
e652: 65 d0                        adc     SRCH
e654: 20 0a e7                     jsr     LE70A
e657: 20 ff e6     :Loop           jsr     GETVERB
e65a: 88                           dey
e65b: d0 fa                        bne     :Loop
e65d: 98                           tya
e65e: 65 d1                        adc     SRCH+1
e660: 95 78                        sta     NOUNSTKH,x
e662: 68                           pla
e663: 24 d8                        bit     XSAVE
e665: 30 1d                        bmi     LE684
e667: a8                           tay
e668: a9 00                        lda     #$00
e66a: 20 0a e7                     jsr     LE70A
e66d: 95 78                        sta     NOUNSTKH,x
e66f: b1 d0        LE66F           lda     (SRCH),y
e671: 10 0f                        bpl     LE682             ;exit loop
e673: f6 78                        inc     NOUNSTKH,x
e675: c8                           iny
e676: d0 f7                        bne     LE66F             ;(always)

e678: 09                           .dd1    $09

e679: a9 00        LE679           lda     #$00
e67b: 85 d4                        sta     IFFLAG
e67d: 85 d5                        sta     CRFLAG
e67f: a2 20                        ldx     #$20
e681: 48           LE681           pha
e682: a0 00        LE682           ldy     #$00
e684: b1 e0        LE684           lda     (PX),y
e686: 10 18        LE686           bpl     LE6A0             ;exit loop
e688: 0a                           asl     A
e689: 30 b5                        bmi     LE640
e68b: 20 ff e6                     jsr     GETVERB
e68e: 20 08 e7                     jsr     LE708
e691: 20 ff e6                     jsr     GETVERB
e694: 95 a0                        sta     NOUNSTKC,x
e696: 24 d4        LE696           bit     IFFLAG
e698: 10 01                        bpl     LE69B
e69a: ca                           dex
e69b: 20 ff e6     LE69B           jsr     GETVERB
e69e: b0 e6                        bcs     LE686
e6a0: c9 28        LE6A0           cmp     #$28
e6a2: d0 1f                        bne     LE6C3
e6a4: a5 e0                        lda     PX
e6a6: 20 0a e7                     jsr     LE70A
e6a9: a5 e1                        lda     PX+1
e6ab: 95 78                        sta     NOUNSTKH,x
e6ad: 24 d4                        bit     IFFLAG
e6af: 30 0b                        bmi     LE6BC
e6b1: a9 01                        lda     #$01
e6b3: 20 0a e7                     jsr     LE70A
e6b6: a9 00                        lda     #$00
e6b8: 95 78                        sta     NOUNSTKH,x
e6ba: f6 78        :Loop           inc     NOUNSTKH,x
e6bc: 20 ff e6     LE6BC           jsr     GETVERB
e6bf: 30 f9                        bmi     :Loop
e6c1: b0 d3                        bcs     LE696
e6c3: 24 d4        LE6C3           bit     IFFLAG
e6c5: 10 06                        bpl     LE6CD
e6c7: c9 04                        cmp     #$04
e6c9: b0 d0                        bcs     LE69B
e6cb: 46 d4                        lsr     IFFLAG
e6cd: a8           LE6CD           tay
e6ce: 85 d6                        sta     VERBNOW
e6d0: b9 80 e9                     lda     TABLE1,y
e6d3: 29 55                        and     #%01010101        ;even bits only
e6d5: 0a                           asl     A
e6d6: 85 d7                        sta     PRFLAG            ;temp
e6d8: 68           LE6D8           pla
e6d9: a8                           tay
e6da: b9 80 e9                     lda     TABLE1,y
e6dd: 29 aa                        and     #%10101010        ;odd bits only
e6df: c5 d7                        cmp     PRFLAG
e6e1: b0 09                        bcs     LE6EC
e6e3: 98                           tya
e6e4: 48                           pha
e6e5: 20 eb f3                     jsr     LF3EB
e6e8: a5 d6                        lda     VERBNOW
e6ea: 90 95                        bcc     LE681             ;(always)
                   ; BRANCH: get high/low then JSR.
e6ec: b9 00 ea     LE6EC           lda     VERBADRL,y
e6ef: 85 ce                        sta     ACC
e6f1: b9 80 ea                     lda     VERBADRH,y
e6f4: 85 cf                        sta     ACC+1
e6f6: 20 fc e6                     jsr     LE6FC
e6f9: 4c d8 e6                     jmp     LE6D8

e6fc: 6c ce 00     LE6FC           jmp     (ACC)

                   ; Get next verb to use.
e6ff: e6 e0        GETVERB         inc     PX
e701: d0 02                        bne     :NoInc
e703: e6 e1                        inc     PX+1
e705: b1 e0        :NoInc          lda     (PX),y
e707: 60                           rts

e708: 94 77        LE708           sty     NOUNSTKH-1,x
e70a: ca           LE70A           dex
e70b: 30 03                        bmi     LE710
e70d: 95 50                        sta     NOUNSTKL,x
e70f: 60                           rts

e710: a0 66        LE710           ldy     #<ErrMsg12+3      ;"PPED AT"
e712: 4c e0 e3     LE712           jmp     ERRMESS

                   ; Get a 16-bit value.
e715: a0 00        GET16BIT        ldy     #$00
e717: b5 50                        lda     NOUNSTKL,x
e719: 85 ce                        sta     ACC
e71b: b5 a0                        lda     NOUNSTKC,x
e71d: 85 cf                        sta     ACC+1
e71f: b5 78                        lda     NOUNSTKH,x
e721: f0 0e                        beq     LE731
e723: 85 cf                        sta     ACC+1
e725: b1 ce                        lda     (ACC),y           ;ACC = (ACC),Y
e727: 48                           pha                       ;save low byte
e728: c8                           iny                       ;Y-reg = 1
e729: b1 ce                        lda     (ACC),y
e72b: 85 cf                        sta     ACC+1
e72d: 68                           pla                       ;restore low byte
e72e: 85 ce                        sta     ACC
e730: 88                           dey                       ;Y-reg = 0
e731: e8           LE731           inx
e732: 60                           rts

                   ; Token $16 =
                   ;   num var logic op
                   ;   IF X = 13 THEN END
e733: 20 4a e7     TE733           jsr     TE74A
                   ; Token $37 NOT
                   ;   numeric
                   ;   IF NOT X THEN END
e736: 20 15 e7     NOT             jsr     GET16BIT
e739: 98                           tya                       ;A-reg = 0
e73a: 20 08 e7                     jsr     LE708
e73d: 95 a0                        sta     NOUNSTKC,x
e73f: c5 ce                        cmp     ACC
e741: d0 06                        bne     :Return
e743: c5 cf                        cmp     ACC+1
e745: d0 02                        bne     :Return
e747: f6 50                        inc     NOUNSTKL,x
e749: 60           :Return         rts

                   ; Token $17 #
                   ;   num var logic op
                   ;   IF X # 13 THEN END
                   ; Token $1b <>
                   ;   num var logic op
                   ;   IF X <> 13 THEN END
e74a: 20 82 e7     TE74A           jsr     SUBTRACT
e74d: 20 59 e7                     jsr     SGN
                   ; Token $31 ABS
e750: 20 15 e7     ABS             jsr     GET16BIT
e753: 24 cf                        bit     ACC+1
e755: 30 1b                        bmi     LE772
e757: ca           LE757           dex
e758: 60           :Return         rts

                   ; Token $30 SGN
e759: 20 15 e7     SGN             jsr     GET16BIT
e75c: a5 cf                        lda     ACC+1             ;is ACC zero?
e75e: d0 04                        bne     LE764
e760: a5 ce                        lda     ACC
e762: f0 f3                        beq     LE757             ;yes
e764: a9 ff        LE764           lda     #$ff
e766: 20 08 e7                     jsr     LE708
e769: 95 a0                        sta     NOUNSTKC,x
e76b: 24 cf                        bit     ACC+1
e76d: 30 e9                        bmi     :Return
                   ; Token $36 -
                   ;   unary sign of number
                   ;   X = -5
e76f: 20 15 e7     NEGATE          jsr     GET16BIT
e772: 98           LE772           tya                       ;A-reg = 0
e773: 38                           sec
e774: e5 ce                        sbc     ACC
e776: 20 08 e7                     jsr     LE708
e779: 98                           tya
e77a: e5 cf                        sbc     ACC+1
e77c: 50 23                        bvc     LE7A1
e77e: a0 00        Err32767        ldy     #<ErrMsg00        ;">32767"
e780: 10 90                        bpl     LE712             ;(always)

                   ; Token $13 -
                   ;   num op
                   ;   X = 27 - 2
e782: 20 6f e7     SUBTRACT        jsr     NEGATE            ;negate, then add
                   ; Token $12 +
                   ;   num op
                   ;   X = 27 + 2
e785: 20 15 e7     TE785           jsr     GET16BIT
e788: a5 ce                        lda     ACC               ;AUX = ACC
e78a: 85 da                        sta     AUX
e78c: a5 cf                        lda     ACC+1
e78e: 85 db                        sta     AUX+1
e790: 20 15 e7                     jsr     GET16BIT
e793: 18           LE793           clc
e794: a5 ce                        lda     ACC
e796: 65 da                        adc     AUX
e798: 20 08 e7                     jsr     LE708
e79b: a5 cf                        lda     ACC+1
e79d: 65 db                        adc     AUX+1
e79f: 70 dd                        bvs     Err32767
e7a1: 95 a0        LE7A1           sta     NOUNSTKC,x
                   ; Token $35 +
                   ;   unary sign of number
                   ;   X = +5
e7a3: 60           POSITIVE        rts

                   ; Token $50 TAB
e7a4: 20 34 ee     TAB             jsr     GETBYTE
e7a7: a8                           tay
e7a8: d0 03                        bne     LE7AD
e7aa: 4c cb ee                     jmp     BcsRANGERR        ;range error?

e7ad: 88           LE7AD           dey
e7ae: 4c f4 f3     LE7AE           jmp     LF3F4

                   ; Comma tab to next tab posn (every 8 spaces).
e7b1: a5 24        LE7B1           lda     MON_CH            ;get horiz posn
e7b3: 09 07                        ora     #$07              ;set bits 0-2
e7b5: a8                           tay
e7b6: c8                           iny                       ;incr, is it zero? [only if CH=$f8-ff (invalid)]
e7b7: d0 f5        :unref_branch   bne     LE7AE             ;no, adjust CH [always?]
e7b9: c8                           iny                       ;yes, go to next tab posn [sets Y-reg=1]
e7ba: d0 f5                        bne     LE7B1             ;(always)

e7bc: b0 f9        unref_e7bc      bcs     :unref_branch
e7be: 60                           rts

e7bf: 00 00                        .bulk   $00,$00

                   ; Token $49 ,
                   ;   num print follows
                   ;   PRINT A$,X
e7c1: 20 b1 e7     TE7C1           jsr     LE7B1
                   ; Token $46 ;
                   ;   num print follows
                   ;   PRINT A$ ; X
                   ; Token $62 PRINT
                   ;   num value
                   ;   PRINT 123: PRINT X: PRINT ASC(A$)
e7c4: 20 15 e7     PRINTNUM        jsr     GET16BIT
e7c7: a5 cf        LE7C7           lda     ACC+1             ;is it positive?
e7c9: 10 0a                        bpl     LE7D5
e7cb: a9 ad                        lda     #“-”              ;no, print minus sign
e7cd: 20 ed fd                     jsr     MON_COUT
e7d0: 20 72 e7                     jsr     LE772
e7d3: 50 ef                        bvc     PRINTNUM          ;(always)

e7d5: 88           LE7D5           dey                       ;Y-reg = $ff
e7d6: 84 d5                        sty     CRFLAG            ;CRFLAG = $ff
e7d8: 86 cf                        stx     ACC+1             ;save X-reg
e7da: a6 ce                        ldx     ACC
e7dc: 20 1b e5                     jsr     PRDEC
e7df: a6 cf                        ldx     ACC+1             ;restore X-reg
e7e1: 60                           rts

                   ; Token $0d AUTO
e7e2: 20 15 e7     AUTO            jsr     GET16BIT
e7e5: a5 ce                        lda     ACC               ;AUTOLN = ACC
e7e7: 85 f6                        sta     AUTOLN
e7e9: a5 cf                        lda     ACC+1
e7eb: 85 f7                        sta     AUTOLN+1
e7ed: 88                           dey
e7ee: 84 f8                        sty     AUTOFLAG          ;AUTOFLAG = $ff
e7f0: c8                           iny
e7f1: a9 0a                        lda     #10               ;default increment
e7f3: 85 f4        LE7F3           sta     AUTOINC
e7f5: 84 f5                        sty     AUTOINC+1
e7f7: 60                           rts

                   ; Token $0e ,
                   ;   AUTO 10,20
e7f8: 20 15 e7     COMMA_AUTO      jsr     GET16BIT
e7fb: a5 ce                        lda     ACC
e7fd: a4 cf                        ldy     ACC+1
e7ff: 10 f2                        bpl     LE7F3             ;(always)

                   ; Token $56 =
                   ;   FOR X = 5 TO 10
                   ; Token $71 =
                   ;   num - non-conditional
                   ;   X = 5
e801: 20 15 e7     TE801           jsr     GET16BIT
e804: b5 50                        lda     NOUNSTKL,x
e806: 85 da                        sta     AUX
e808: b5 78                        lda     NOUNSTKH,x
e80a: 85 db                        sta     AUX+1
e80c: a5 ce                        lda     ACC
e80e: 91 da                        sta     (AUX),y
e810: c8                           iny
e811: a5 cf                        lda     ACC+1
e813: 4c 07 f2                     jmp     LF207

                   ; Token $25 THEN
                   ;   IF X = 3 THEN Y = 5
                   ; Token $5e LET
e816: 60           LET             rts

                   ; Token $00
                   ;   internal begin-of-line
e817: 68           BEGIN_LINE      pla
e818: 68                           pla
                   ; Token $03 :
                   ;   statement separation
                   ;   X = 5: A$ = "HELLO"
e819: 24 d5        COLON           bit     CRFLAG
e81b: 10 05                        bpl     :Return
                   ; Token $63 PRINT
                   ;   dummy print
                   ;   PRINT: PRINT
e81d: 20 8e fd     PRINT_CR        jsr     MON_CROUT
                   ; Token $47 ;
                   ;   end of print statement
                   ;   PRINT A$;
e820: 46 d5        TE820           lsr     CRFLAG
e822: 60           :Return         rts

                   ; Token $22 (
                   ;   string DIM
                   ;   DIM A$(X)
                   ; Token $34 (
                   ;   num DIM
                   ;   DIM X(5)
                   ; Token $38 (
                   ;   logic statements and num operations
                   ;   IF C and (A=14 OR B=12) THEN X=(27+3)/13
                   ; Token $3f (
                   ;   used after PEEK, RND, SGN, ABS, and PDL
e823: a0 ff        TE823           ldy     #$ff
e825: 84 d7                        sty     PRFLAG            ;PRFLAG = $ff
                   ; Token $72 )
                   ;   the only right parenthesis token
e827: 60           RIGHT_PAREN     rts

                   ; Token $60 IF
e828: 20 cd ef     IF              jsr     LEFCD
e82b: f0 07                        beq     LE834
e82d: a9 25                        lda     #$25              ;THEN token?
e82f: 85 d6                        sta     VERBNOW
e831: 88                           dey
e832: 84 d4                        sty     IFFLAG
e834: e8           LE834           inx
e835: 60                           rts

                   ; Run without CLR
                   ;   DOS 3.3 chains here to run a program
e836: a5 ca        RUNWARM         lda     PP
e838: a4 cb                        ldy     PP+1
e83a: d0 5a                        bne     LE896             ;(always)

                   ; Token $5c GOSUB
e83c: a0 41        GOSUB           ldy     #<ErrMsg08        ;"16 GOSUBS"
e83e: a5 fc                        lda     GOSUBNDX
e840: c9 10                        cmp     #16               ;sixteen GOSUBs?
e842: b0 5e                        bcs     JmpERRMESS1       ;yes, error
e844: a8                           tay
e845: e6 fc                        inc     GOSUBNDX
e847: a5 e0                        lda     PX
e849: 99 00 01                     sta     STK_00,y
e84c: a5 e1                        lda     PX+1
e84e: 99 10 01                     sta     STK_10,y
e851: a5 dc                        lda     PR
e853: 99 20 01                     sta     STK_20,y
e856: a5 dd                        lda     PR+1
e858: 99 30 01                     sta     STK_30,y
                   ; Token $24 THEN
                   ;   followed by a line number
                   ;   IF X=3 THEN 10
                   ; Token $5f GOTO
e85b: 20 15 e7     GOTO            jsr     GET16BIT
e85e: 20 6d e5                     jsr     LE56D
e861: 90 04                        bcc     LE867
e863: a0 37                        ldy     #<ErrMsg07        ;"BAD BRANCH"
e865: d0 3b                        bne     JmpERRMESS1

e867: a5 e4        LE867           lda     P2
e869: a4 e5                        ldy     P2+1
                   ; Main loop for running Integer BASIC programs.
e86b: 85 dc        LE86B           sta     PR
e86d: 84 dd                        sty     PR+1
e86f: 18                           clc
e870: 69 03                        adc     #$03
e872: 90 01                        bcc     GETNEXT
e874: c8                           iny
                   ; Fetch next statement from text source.
e875: a2 ff        GETNEXT         ldx     #$ff
e877: 86 d9                        stx     RUNFLAG
e879: 9a                           txs
e87a: 85 e0                        sta     PX
e87c: 84 e1                        sty     PX+1
e87e: 20 2e f0                     jsr     LF02E             ;test for Ctrl+C and TRACE mode
e881: a0 00                        ldy     #$00
e883: 20 79 e6     LE883           jsr     LE679             ;execute statement
e886: 24 d9                        bit     RUNFLAG
e888: 10 49                        bpl     END
e88a: 18                           clc
e88b: a0 00                        ldy     #$00
e88d: a5 dc                        lda     PR
e88f: 71 dc                        adc     (PR),y
e891: a4 dd                        ldy     PR+1
e893: 90 01                        bcc     LE896
e895: c8                           iny
e896: c5 4c        LE896           cmp     HIMEM
e898: d0 d1                        bne     LE86B
e89a: c4 4d                        cpy     HIMEM+1
e89c: d0 cd                        bne     LE86B
e89e: a0 31                        ldy     #<ErrMsg06        ;"NO END"
e8a0: 46 d9                        lsr     RUNFLAG           ;pos
e8a2: 4c e0 e3     JmpERRMESS1     jmp     ERRMESS

                   ; Token $5b RETURN
e8a5: a0 4a        RETURN          ldy     #<ErrMsg09        ;"BAD RETURN"
e8a7: a5 fc                        lda     GOSUBNDX
e8a9: f0 f7                        beq     JmpERRMESS1
e8ab: c6 fc                        dec     GOSUBNDX
e8ad: a8                           tay
e8ae: b9 1f 01                     lda     STK_20-1,y
e8b1: 85 dc                        sta     PR
e8b3: b9 2f 01                     lda     STK_30-1,y
e8b6: 85 dd                        sta     PR+1
e8b8: be ff 00                     ldx:    STK_00-1,y
e8bb: b9 0f 01                     lda     STK_10-1,y
e8be: a8           LE8BE           tay
e8bf: 8a                           txa
e8c0: 4c 75 e8                     jmp     GETNEXT

e8c3: a0 63        STOPPED_AT      ldy     #<ErrMsg12        ;"STOPPED AT"
e8c5: 20 c4 e3                     jsr     ERRORMESS
e8c8: a0 01                        ldy     #$01
e8ca: b1 dc                        lda     (PR),y
e8cc: aa                           tax
e8cd: c8                           iny
e8ce: b1 dc                        lda     (PR),y
e8d0: 20 1b e5                     jsr     PRDEC
                   ; Token $51 END
e8d3: 4c b3 e2     END             jmp     WARM

e8d6: c6 fb        LE8D6           dec     FORNDX
                   ; Token $59 NEXT
                   ; Token $5a ,
                   ;   NEXT X,Y
e8d8: a0 5b        NEXT            ldy     #<ErrMsg11        ;"BAD NEXT"
e8da: a5 fb                        lda     FORNDX
e8dc: f0 c4        JmpERRMESS2     beq     JmpERRMESS1       ;no more FORs
e8de: a8                           tay
e8df: b5 50                        lda     NOUNSTKL,x
e8e1: d9 3f 01                     cmp     STK_40-1,y
e8e4: d0 f0                        bne     LE8D6
e8e6: b5 78                        lda     NOUNSTKH,x
e8e8: d9 4f 01                     cmp     STK_50-1,y
e8eb: d0 e9                        bne     LE8D6
e8ed: b9 5f 01                     lda     STK_60-1,y
e8f0: 85 da                        sta     AUX
e8f2: b9 6f 01                     lda     STK_70-1,y
e8f5: 85 db                        sta     AUX+1
e8f7: 20 15 e7                     jsr     GET16BIT
e8fa: ca                           dex
e8fb: 20 93 e7                     jsr     LE793
e8fe: 20 01 e8                     jsr     TE801
e901: ca                           dex
e902: a4 fb                        ldy     FORNDX
e904: b9 cf 01                     lda     STK_D0-1,y
e907: 95 9f                        sta     NOUNSTKC-1,x
e909: b9 bf 01                     lda     STK_C0-1,y
e90c: a0 00                        ldy     #$00
e90e: 20 08 e7                     jsr     LE708
e911: 20 82 e7                     jsr     SUBTRACT
e914: 20 59 e7                     jsr     SGN
e917: 20 15 e7                     jsr     GET16BIT
e91a: a4 fb                        ldy     FORNDX
e91c: a5 ce                        lda     ACC
e91e: f0 05                        beq     LE925
e920: 59 6f 01                     eor     STK_70-1,y
e923: 10 12                        bpl     LE937
e925: b9 7f 01     LE925           lda     STK_80-1,y
e928: 85 dc                        sta     PR
e92a: b9 8f 01                     lda     STK_90-1,y
e92d: 85 dd                        sta     PR+1
e92f: be 9f 01                     ldx     STK_A0-1,y
e932: b9 af 01                     lda     STK_B0-1,y
e935: d0 87                        bne     LE8BE
e937: c6 fb        LE937           dec     FORNDX
e939: 60                           rts

                   ; Token $55 FOR
e93a: a0 54        FOR             ldy     #<ErrMsg10        ;"16 FORS"
e93c: a5 fb                        lda     FORNDX
e93e: c9 10                        cmp     #16               ;sixteen FORs?
e940: f0 9a                        beq     JmpERRMESS2       ;yes, error
e942: e6 fb                        inc     FORNDX
e944: a8                           tay
e945: b5 50                        lda     NOUNSTKL,x
e947: 99 40 01                     sta     STK_40,y
e94a: b5 78                        lda     NOUNSTKH,x
e94c: 4c 88 f2                     jmp     LF288

e94f: 60                           .dd1    $60

                   ; Token $57 TO
e950: 20 15 e7     TO              jsr     GET16BIT
e953: a4 fb                        ldy     FORNDX
e955: a5 ce                        lda     ACC
e957: 99 bf 01                     sta     STK_C0-1,y
e95a: a5 cf                        lda     ACC+1
e95c: 99 cf 01                     sta     STK_D0-1,y
e95f: a9 01                        lda     #$01
e961: 99 5f 01                     sta     STK_60-1,y
e964: a9 00                        lda     #$00
e966: 99 6f 01     LE966           sta     STK_70-1,y
e969: a5 dc                        lda     PR
e96b: 99 7f 01                     sta     STK_80-1,y
e96e: a5 dd                        lda     PR+1
e970: 99 8f 01                     sta     STK_90-1,y
e973: a5 e0                        lda     PX
e975: 99 9f 01                     sta     STK_A0-1,y
e978: a5 e1                        lda     PX+1
e97a: 99 af 01                     sta     STK_B0-1,y
e97d: 60                           rts

e97e: 20                           .dd1    $20
e97f: 15                           .dd1    $15
e980: 00 00 00 ab+ TABLE1          .bulk   $00,$00,$00,$ab,$03,$03,$03,$03
e988: 03 03 03 03+                 .bulk   $03,$03,$03,$03,$03,$03,$03,$03
e990: 03 03 3f 3f+                 .bulk   $03,$03,$3f,$3f,$c0,$c0,$3c,$3c
e998: 3c 3c 3c 3c+                 .bulk   $3c,$3c,$3c,$3c,$3c,$30,$0f,$c0
e9a0: c3 ff 55 00+                 .bulk   $c3,$ff,$55,$00,$ab,$ab,$03,$03
e9a8: ff ff 55 ff+                 .bulk   $ff,$ff,$55,$ff,$ff,$55,$cf,$cf
e9b0: cf cf cf ff+                 .bulk   $cf,$cf,$cf,$ff,$55,$c6,$c6,$c6
e9b8: 55 f0 f0 cf+                 .bulk   $55,$f0,$f0,$cf,$cf,$55,$01,$55
e9c0: ff ff 55 03+                 .bulk   $ff,$ff,$55,$03,$03,$03,$03,$03
e9c8: 03 03 03 03+                 .bulk   $03,$03,$03,$03,$03,$03,$03,$03
e9d0: 03 03 03 03+                 .bulk   $03,$03,$03,$03,$03,$03,$03,$03
e9d8: 03 03 03 03+                 .bulk   $03,$03,$03,$03,$03,$00,$ab,$03
e9e0: 57 03 03 03+                 .bulk   $57,$03,$03,$03,$03,$07,$03,$03
e9e8: 03 03 03 03+                 .bulk   $03,$03,$03,$03,$03,$03,$03,$03
e9f0: 03 03 aa ff+                 .bulk   $03,$03,$aa,$ff,$03,$03,$03,$03
e9f8: 03 03 03 03+                 .bulk   $03,$03,$03,$03,$03,$03,$03,$03
                   ; Token address tables (verb dispatch tables).
ea00: 17           VERBADRL        .dd1    <BEGIN_LINE
ea01: ff                           .dd1    $ff
ea02: ff                           .dd1    $ff
ea03: 19                           .dd1    <COLON
ea04: df                           .dd1    <LOAD
ea05: 42                           .dd1    <SAVE
ea06: 0a                           .dd1    <CON
ea07: f2                           .dd1    <RUNNUM
ea08: ec                           .dd1    <RUN
ea09: 87                           .dd1    <DEL
ea0a: 6f                           .dd1    <COMMA_DEL
ea0b: ad                           .dd1    <NEW
ea0c: b7                           .dd1    <CLR
ea0d: e2                           .dd1    <AUTO
ea0e: f8                           .dd1    <COMMA_AUTO
ea0f: 54                           .dd1    <TEE54
ea10: 4d                           .dd1    <VHIMEM
ea11: c9                           .dd1    <VLOMEM
ea12: 85                           .dd1    <TE785
ea13: 82                           .dd1    <SUBTRACT
ea14: 22                           .dd1    <MULT
ea15: 10                           .dd1    <DIVIDE
ea16: 33                           .dd1    <TE733
ea17: 4a                           .dd1    <TE74A
ea18: 5b                           .dd1    <TF25B
ea19: 4e                           .dd1    <TF24E
ea1a: 53                           .dd1    <TF253
ea1b: 4a                           .dd1    <TE74A
ea1c: 49                           .dd1    <TF249
ea1d: 66                           .dd1    <VAND
ea1e: 6d                           .dd1    <VOR
ea1f: 7a                           .dd1    <MOD
ea20: 71                           .dd1    <EXP
ea21: ff                           .dd1    $ff
ea22: 23                           .dd1    <TE823
ea23: 09                           .dd1    <COMMA_SUBSTR
ea24: 5b                           .dd1    <GOTO
ea25: 16                           .dd1    <LET
ea26: b6                           .dd1    <TEFB6
ea27: cb                           .dd1    <TEBCB
ea28: ff                           .dd1    $ff
ea29: ff                           .dd1    $ff
ea2a: fb                           .dd1    <PAREN_SUBSTR
ea2b: ff                           .dd1    $ff
ea2c: ff                           .dd1    $ff
ea2d: 24                           .dd1    <TEF24
ea2e: f6                           .dd1    <PEEK
ea2f: 4e                           .dd1    <RND
ea30: 59                           .dd1    <SGN
ea31: 50                           .dd1    <ABS
ea32: 3b                           .dd1    <PDL
ea33: ff                           .dd1    $ff
ea34: 23                           .dd1    <TE823
ea35: a3                           .dd1    <POSITIVE
ea36: 6f                           .dd1    <NEGATE
ea37: 36                           .dd1    <NOT
ea38: 23                           .dd1    <TE823
ea39: d7                           .dd1    <TE1D7
ea3a: 1c                           .dd1    <TE21C
ea3b: 22                           .dd1    <LEN
ea3c: 1d                           .dd1    <ASC
ea3d: 8a                           .dd1    <SCRN
ea3e: ab                           .dd1    <COMMA_SCRN
ea3f: 23                           .dd1    <TE823
ea40: ff                           .dd1    $ff
ea41: ff                           .dd1    $ff
ea42: 21                           .dd1    <TE121
ea43: 30                           .dd1    <DIMSTR
ea44: 1e                           .dd1    <DIMNUM
ea45: 03                           .dd1    <PRINTSTR
ea46: c4                           .dd1    <PRINTNUM
ea47: 20                           .dd1    <TE820
ea48: 00                           .dd1    <TEE00
ea49: c1                           .dd1    <TE7C1
ea4a: ba                           .dd1    <TF3BA
ea4b: 39                           .dd1    <MON_SETTXT
ea4c: 40                           .dd1    <MON_SETGR
ea4d: a0                           .dd1    <CALL
ea4e: 30                           .dd1    <DIMSTR
ea4f: 1e                           .dd1    <DIMNUM
ea50: a4                           .dd1    <TAB
ea51: d3                           .dd1    <END
ea52: b6                           .dd1    <TEFB6
ea53: bc                           .dd1    <INPUT_PROMPT
ea54: aa                           .dd1    <TEBAA
ea55: 3a                           .dd1    <FOR
ea56: 01                           .dd1    <TE801
ea57: 50                           .dd1    <TO
ea58: 79                           .dd1    <STEP
ea59: d8                           .dd1    <NEXT
ea5a: d8                           .dd1    <NEXT
ea5b: a5                           .dd1    <RETURN
ea5c: 3c                           .dd1    <GOSUB
ea5d: ff                           .dd1    $ff
ea5e: 16                           .dd1    <LET
ea5f: 5b                           .dd1    <GOTO
ea60: 28                           .dd1    <IF
ea61: 03                           .dd1    <PRINTSTR
ea62: c4                           .dd1    <PRINTNUM
ea63: 1d                           .dd1    <PRINT_CR
ea64: 08                           .dd1    <POKE
ea65: 00                           .dd1    <GETVAL255
ea66: 4e                           .dd1    <TEE4E
ea67: 00                           .dd1    <GETVAL255
ea68: 3e                           .dd1    <COMMA_PLOT
ea69: 00                           .dd1    <GETVAL255
ea6a: a6                           .dd1    <COMMA_HLIN
ea6b: b0                           .dd1    <AT_HLIN
ea6c: 00                           .dd1    <GETVAL255
ea6d: bc                           .dd1    <COMMA_VLIN
ea6e: c6                           .dd1    <AT_VLIN
ea6f: 57                           .dd1    <IVTAB
ea70: 8c                           .dd1    <TE18C
ea71: 01                           .dd1    <TE801
ea72: 27                           .dd1    <RIGHT_PAREN
ea73: ff                           .dd1    $ff
ea74: 5d                           .dd1    <LISTNUM
ea75: 35                           .dd1    <COMMA_LIST
ea76: 4b                           .dd1    <LIST
ea77: 67                           .dd1    <POP
ea78: e0                           .dd1    <NODSP_STR
ea79: e1                           .dd1    <NODSP_NUM
ea7a: 76                           .dd1    <NOTRACE
ea7b: 04                           .dd1    <DSP_STR
ea7c: 05                           .dd1    <DSP_NUM
ea7d: 71                           .dd1    <TRACE
ea7e: c9                           .dd1    <PRSLOT
ea7f: 1a                           .dd1    <INSLOT
ea80: e8           VERBADRH        .dd1    >BEGIN_LINE
ea81: ff                           .dd1    $ff
ea82: ff                           .dd1    $ff
ea83: e8                           .dd1    >COLON
ea84: f0                           .dd1    >LOAD
ea85: f1                           .dd1    >SAVE
ea86: f3                           .dd1    >CON
ea87: ef                           .dd1    >RUNNUM
ea88: ef                           .dd1    >RUN
ea89: e3                           .dd1    >DEL
ea8a: e3                           .dd1    >COMMA_DEL
ea8b: e5                           .dd1    >NEW
ea8c: e5                           .dd1    >CLR
ea8d: e7                           .dd1    >AUTO
ea8e: e7                           .dd1    >COMMA_AUTO
ea8f: ee                           .dd1    >TEE54
ea90: f0                           .dd1    >VHIMEM
ea91: f0                           .dd1    >VLOMEM
ea92: e7                           .dd1    >TE785
ea93: e7                           .dd1    >SUBTRACT
ea94: e2                           .dd1    >MULT
ea95: ef                           .dd1    >DIVIDE
ea96: e7                           .dd1    >TE733
ea97: e7                           .dd1    >TE74A
ea98: f2                           .dd1    >TF25B
ea99: f2                           .dd1    >TF24E
ea9a: f2                           .dd1    >TF253
ea9b: e7                           .dd1    >TE74A
ea9c: f2                           .dd1    >TF249
ea9d: f2                           .dd1    >VAND
ea9e: f2                           .dd1    >VOR
ea9f: e2                           .dd1    >MOD
eaa0: f3                           .dd1    >EXP
eaa1: ff                           .dd1    $ff
eaa2: e8                           .dd1    >TE823
eaa3: e1                           .dd1    >COMMA_SUBSTR
eaa4: e8                           .dd1    >GOTO
eaa5: e8                           .dd1    >LET
eaa6: ef                           .dd1    >TEFB6
eaa7: eb                           .dd1    >TEBCB
eaa8: ff                           .dd1    $ff
eaa9: ff                           .dd1    $ff
eaaa: e0                           .dd1    >PAREN_SUBSTR
eaab: ff                           .dd1    $ff
eaac: ff                           .dd1    $ff
eaad: ef                           .dd1    >TEF24
eaae: ee                           .dd1    >PEEK
eaaf: ef                           .dd1    >RND
eab0: e7                           .dd1    >SGN
eab1: e7                           .dd1    >ABS
eab2: f3                           .dd1    >PDL
eab3: ff                           .dd1    $ff
eab4: e8                           .dd1    >TE823
eab5: e7                           .dd1    >POSITIVE
eab6: e7                           .dd1    >NEGATE
eab7: e7                           .dd1    >NOT
eab8: e8                           .dd1    >TE823
eab9: e1                           .dd1    >TE1D7
eaba: e2                           .dd1    >TE21C
eabb: ee                           .dd1    >LEN
eabc: f3                           .dd1    >ASC
eabd: e2                           .dd1    >SCRN
eabe: e2                           .dd1    >COMMA_SCRN
eabf: e8                           .dd1    >TE823
eac0: ff                           .dd1    $ff
eac1: ff                           .dd1    $ff
eac2: e1                           .dd1    >TE121
eac3: e1                           .dd1    >DIMSTR
eac4: ef                           .dd1    >DIMNUM
eac5: ee                           .dd1    >PRINTSTR
eac6: e7                           .dd1    >PRINTNUM
eac7: e8                           .dd1    >TE820
eac8: ee                           .dd1    >TEE00
eac9: e7                           .dd1    >TE7C1
eaca: f3                           .dd1    >TF3BA
eacb: fb                           .dd1    >MON_SETTXT
eacc: fb                           .dd1    >MON_SETGR
eacd: ee                           .dd1    >CALL
eace: e1                           .dd1    >DIMSTR
eacf: ef                           .dd1    >DIMNUM
ead0: e7                           .dd1    >TAB
ead1: e8                           .dd1    >END
ead2: ef                           .dd1    >TEFB6
ead3: ef                           .dd1    >INPUT_PROMPT
ead4: eb                           .dd1    >TEBAA
ead5: e9                           .dd1    >FOR
ead6: e8                           .dd1    >TE801
ead7: e9                           .dd1    >TO
ead8: f2                           .dd1    >STEP
ead9: e8                           .dd1    >NEXT
eada: e8                           .dd1    >NEXT
eadb: e8                           .dd1    >RETURN
eadc: e8                           .dd1    >GOSUB
eadd: ff                           .dd1    $ff
eade: e8                           .dd1    >LET
eadf: e8                           .dd1    >GOTO
eae0: e8                           .dd1    >IF
eae1: ee                           .dd1    >PRINTSTR
eae2: e7                           .dd1    >PRINTNUM
eae3: e8                           .dd1    >PRINT_CR
eae4: ef                           .dd1    >POKE
eae5: ef                           .dd1    >GETVAL255
eae6: ee                           .dd1    >TEE4E
eae7: ef                           .dd1    >GETVAL255
eae8: ee                           .dd1    >COMMA_PLOT
eae9: ef                           .dd1    >GETVAL255
eaea: ee                           .dd1    >COMMA_HLIN
eaeb: ee                           .dd1    >AT_HLIN
eaec: ef                           .dd1    >GETVAL255
eaed: ee                           .dd1    >COMMA_VLIN
eaee: ee                           .dd1    >AT_VLIN
eaef: ee                           .dd1    >IVTAB
eaf0: e1                           .dd1    >TE18C
eaf1: e8                           .dd1    >TE801
eaf2: e8                           .dd1    >RIGHT_PAREN
eaf3: ff                           .dd1    $ff
eaf4: e0                           .dd1    >LISTNUM
eaf5: e0                           .dd1    >COMMA_LIST
eaf6: e0                           .dd1    >LIST
eaf7: f1                           .dd1    >POP
eaf8: f2                           .dd1    >NODSP_STR
eaf9: f2                           .dd1    >NODSP_NUM
eafa: f1                           .dd1    >NOTRACE
eafb: f3                           .dd1    >DSP_STR
eafc: f3                           .dd1    >DSP_NUM
eafd: f1                           .dd1    >TRACE
eafe: f3                           .dd1    >PRSLOT
eaff: f4                           .dd1    >INSLOT
                   ; Error messages.
eb00: be b3 b2 b7+ ErrMsg00        .dstr   “>32767”
eb06: d4 cf cf a0+ ErrMsg01        .dstr   “TOO LONG”
eb0e: d3 d9 ce d4+ ErrMsg02        .dstr   “SYNTAX”
eb14: cd c5 cd a0+ ErrMsg03        .dstr   “MEM FULL”
eb1c: d4 cf cf a0+ ErrMsg04        .dstr   “TOO MANY PARENS”
eb2b: d3 d4 d2 c9+ ErrMsg05        .dstr   “STRING”
eb31: ce cf a0 c5+ ErrMsg06        .dstr   “NO END”
eb37: c2 c1 c4 a0+ ErrMsg07        .dstr   “BAD BRANCH”
eb41: b1 b6 a0 c7+ ErrMsg08        .dstr   “16 GOSUBS”
eb4a: c2 c1 c4 a0+ ErrMsg09        .dstr   “BAD RETURN”
eb54: b1 b6 a0 c6+ ErrMsg10        .dstr   “16 FORS”
eb5b: c2 c1 c4 a0+ ErrMsg11        .dstr   “BAD NEXT”
eb63: d3 d4 cf d0+ ErrMsg12        .dstr   “STOPPED AT ”
eb6e: aa aa aa 20  ErrMsg13        .dstr   “*** ”
eb72: a0 c5 d2 d2+ ErrMsg14        .dstr   “ ERR”,$8d
eb77: be b2 b5 35  ErrMsg15        .dstr   “>255”
eb7b: d2 c1 ce c7+ ErrMsg16        .dstr   “RANGE”
eb80: c4 c9 4d     ErrMsg17        .dstr   “DIM”
eb83: d3 d4 d2 a0+ ErrMsg18        .dstr   “STR OVFL”
eb8b: dc 0d                        .dstr   “\”,$8d
eb8d: d2 c5 d4 d9+ ErrMsg20        .str    “RETYPE LINE”,$8d
eb99: 3f           ErrMsg21        .dd1    ‘?’

                   ; Continue run w/o deleting vars?
eb9a: 46 d9        LEB9A           lsr     RUNFLAG           ;pos
eb9c: 90 03                        bcc     LEBA1
eb9e: 4c c3 e8                     jmp     STOPPED_AT

eba1: a6 cf        LEBA1           ldx     ACC+1
eba3: 9a                           txs
eba4: a6 ce                        ldx     ACC
eba6: a0 8d                        ldy     #<ErrMsg20        ;"RETYPE LINE\r?"
eba8: d0 02                        bne     LEBAC             ;(always)

                   ; Token $54 INPUT
                   ;   num with no prompt
                   ;   INPUT X
ebaa: a0 99        TEBAA           ldy     #<ErrMsg21        ;"?" for INPUT
ebac: 20 c4 e3     LEBAC           jsr     ERRORMESS
ebaf: 86 ce                        stx     ACC
ebb1: ba                           tsx
ebb2: 86 cf                        stx     ACC+1
ebb4: 20 66 f3                     jsr     LF366
ebb7: 84 f1                        sty     TOKNDX
ebb9: a9 ff                        lda     #$ff
ebbb: 85 c8                        sta     TXTNDX
ebbd: 0a                           asl     A
ebbe: 85 d9                        sta     RUNFLAG           ;neg
ebc0: a2 20                        ldx     #$20
ebc2: a9 15                        lda     #$15
ebc4: 20 91 e4                     jsr     LE491
ebc7: e6 d9                        inc     RUNFLAG
ebc9: a6 ce                        ldx     ACC
                   ; Token $27 ,
                   ;   num inputs
                   ;   INPUT "QUANTITY",Q
ebcb: a4 c8        TEBCB           ldy     TXTNDX
ebcd: 0a                           asl     A
ebce: 85 ce        LEBCE           sta     ACC
ebd0: c8                           iny
ebd1: b9 00 02                     lda     IN,y
ebd4: c9 80                        cmp     #$80
ebd6: f0 d2                        beq     TEBAA             ;end of input?
ebd8: 49 b0                        eor     #“0”
ebda: c9 0a                        cmp     #10
ebdc: b0 f0                        bcs     LEBCE
ebde: c8                           iny
ebdf: c8                           iny
ebe0: 84 c8                        sty     TXTNDX
ebe2: b9 00 02                     lda     IN,y
ebe5: 48                           pha
ebe6: b9 ff 01                     lda     IN-1,y
ebe9: a0 00                        ldy     #$00
ebeb: 20 08 e7                     jsr     LE708
ebee: 68                           pla
ebef: 95 a0                        sta     NOUNSTKC,x
ebf1: a5 ce                        lda     ACC
ebf3: c9 33                        cmp     #$33
ebf5: d0 03                        bne     LEBFA
ebf7: 20 6f e7                     jsr     NEGATE
ebfa: 4c 01 e8     LEBFA           jmp     TE801

ebfd: ff ff ff                     .align  $0100 (3 bytes)
                   ; Token / syntax table.
                   ; Each entry has a token, stored in reverse, with character values adjusted. 
                   ; For example, "TRACE" is stored:
                   ;   "E"+32, "C"-32, "A"-32, "R"-32", "T"-32
                   ;   $e5     $a3     $a1     $b2      $b4
ec00: 50 20 4f c0+ SYNTABL         .bulk   $50,$20,$4f,$c0,$f4,$a1,$e4,$af
ec08: ad f2 af e4+                 .bulk   $ad,$f2,$af,$e4,$ae,$a1,$f0,$a5
ec10: b4 b3 ef b4+                 .bulk   $b4,$b3,$ef,$b4,$ee,$a5,$a8,$b4
ec18: 5c 80 00 40+                 .bulk   $5c,$80,$00,$40,$60,$8d,$60,$8b
ec20: 7f 1d 20 7e+                 .bulk   $7f,$1d,$20,$7e,$8c,$33,$00,$00
ec28: 60 03 bf 12                  .bulk   $60,$03,$bf,$12
ec2c: 47 83 ae a9+                 .bulk   $47,$83,$ae,$a9,$67,$83,$b2,$b0
ec34: e5 a3 a1 b2+                 .bulk   $e5,$a3,$a1,$b2,$b4,$79,$b0,$b3
ec3c: a4 69 b0 b3+                 .bulk   $a4,$69,$b0,$b3,$a4,$e5,$a3,$a1
ec44: b2 b4 af ae+                 .bulk   $b2,$b4,$af,$ae,$79,$b0,$b3,$a4
ec4c: af ae 69 b0+                 .bulk   $af,$ae,$69,$b0,$b3,$a4,$af,$ae
ec54: f0 af b0 f4+                 .bulk   $f0,$af,$b0,$f4,$b3,$a9,$ac,$60
ec5c: 8c 20 b4 b3+                 .bulk   $8c,$20,$b4,$b3,$a9,$ac
ec62: 00                           .dd1    $00
ec63: 40 89 c9 47+                 .bulk   $40,$89,$c9,$47,$9d,$17,$68,$9d
ec6b: 0a 58 7b 67+                 .bulk   $0a,$58,$7b,$67,$a2,$a1,$b4,$b6
ec73: 67 b4 a1 07+                 .bulk   $67,$b4,$a1,$07,$8c,$07,$ae,$a9
ec7b: ac b6 67 b4+                 .bulk   $ac,$b6,$67,$b4,$a1,$07,$8c,$07
ec83: ae a9 ac a8+                 .bulk   $ae,$a9,$ac,$a8,$67,$8c,$07,$b4
ec8b: af ac b0 67+                 .bulk   $af,$ac,$b0,$67,$9d,$b2,$af,$ac
ec93: af a3 67 8c+                 .bulk   $af,$a3,$67,$8c,$07,$a5,$ab,$af
ec9b: b0 f4 ae a9+                 .bulk   $b0,$f4,$ae,$a9,$b2,$b0,$7f,$0e
eca3: 27 b4 ae a9+                 .bulk   $27,$b4,$ae,$a9,$b2,$b0,$7f,$0e
ecab: 28 b4 ae a9+                 .bulk   $28,$b4,$ae,$a9,$b2,$b0,$64,$07
ecb3: a6 a9 67 af+                 .bulk   $a6,$a9,$67,$af,$b4,$af,$a7,$78
ecbb: b4 a5 ac 6b+                 .bulk   $b4,$a5,$ac,$6b,$7f,$02,$ad,$a5
ecc3: b2 67 a2 b5+                 .bulk   $b2,$67,$a2,$b5,$b3,$af,$a7,$ee
eccb: b2 b5 b4 a5+                 .bulk   $b2,$b5,$b4,$a5,$b2,$7e,$8c,$39
ecd3: b4 b8 a5 ae+                 .bulk   $b4,$b8,$a5,$ae,$67,$b0,$a5,$b4
ecdb: b3 27 af b4+                 .bulk   $b3,$27,$af,$b4,$07,$9d,$19,$b2
ece3: af a6 7f 05+                 .bulk   $af,$a6,$7f,$05,$37,$b4,$b5,$b0
eceb: ae a9 7f 05+                 .bulk   $ae,$a9,$7f,$05,$28,$b4,$b5,$b0
ecf3: ae a9 7f 05+                 .bulk   $ae,$a9,$7f,$05,$2a,$b4,$b5,$b0
ecfb: ae a9 e4 ae+                 .bulk   $ae,$a9,$e4,$ae,$a5
ed00: 00           SYNTABL2        .dd1    $00
ed01: 47 a2 a1 b4+                 .bulk   $47,$a2,$a1,$b4,$7f,$0d,$30,$ad
ed09: a9 a4 7f 0d+                 .bulk   $a9,$a4,$7f,$0d,$23,$ad,$a9,$a4
ed11: 67 ac ac a1+                 .bulk   $67,$ac,$ac,$a1,$a3,$f2,$a7,$f4
ed19: b8 a5 b4                     .bulk   $b8,$a5,$b4
ed1c: 00                           .dd1    $00               ;above are statements
ed1d: 4d cc 67 8c+                 .bulk   $4d,$cc,$67,$8c,$68,$8c,$db,$67
ed25: 9b 68 9b 50+                 .bulk   $9b,$68,$9b,$50,$8c,$63,$8c,$7f
ed2d: 01 51 07 88+                 .bulk   $01,$51,$07,$88,$29,$84,$80,$c4
ed35: 19 57 71 07+                 .bulk   $19,$57,$71,$07,$88,$14,$71,$07
ed3d: 8c 07 88 ae+                 .bulk   $8c,$07,$88,$ae,$b2,$a3,$b3,$71
ed45: 08 88 a3 b3+                 .bulk   $08,$88,$a3,$b3,$a1,$71,$08,$88
ed4d: ae a5 ac 68+                 .bulk   $ae,$a5,$ac,$68,$83,$08,$68,$9d
ed55: 08 71 07 88+                 .bulk   $08,$71,$07,$88,$60,$75,$b4,$af
ed5d: ae 75 8d 75+                 .bulk   $ae,$75,$8d,$75,$8b,$51,$07,$88
ed65: 19 b8 a4 ae+                 .bulk   $19,$b8,$a4,$ae,$b2,$ec,$a4,$b0
ed6d: f3 a2 a1 ee+                 .bulk   $f3,$a2,$a1,$ee,$a7,$b3,$e4,$ae
ed75: b2 eb a5 a5+                 .bulk   $b2,$eb,$a5,$a5,$b0,$51,$07,$88
ed7d: 39 81 c1 4f+                 .bulk   $39,$81,$c1,$4f,$7f,$0f,$2f,$00
ed85: 51 06 88 29+                 .bulk   $51,$06,$88,$29,$c2,$0c,$82,$57
ed8d: 8c 6a 8c 42+                 .bulk   $8c,$6a,$8c,$42,$ae,$a5,$a8,$b4
ed95: 60 ae a5 a8+                 .bulk   $60,$ae,$a5,$a8,$b4,$4f,$7e,$1e
ed9d: 35 8c 27 51+                 .bulk   $35,$8c,$27,$51,$07,$88,$09,$8b
eda5: fe e4 af ad+                 .bulk   $fe,$e4,$af,$ad,$f2,$af,$e4,$ae
edad: a1 dc de 9c+                 .bulk   $a1,$dc,$de,$9c,$dd,$9c,$de,$dd
edb5: 9e c3 dd cf+                 .bulk   $9e,$c3,$dd,$cf,$ca,$cd,$cb
edbc: 00                           .dd1    $00               ;above 4 are num ops
edbd: 47 9a ad a5+                 .bulk   $47,$9a,$ad,$a5,$ad,$af,$ac,$67
edc5: 9a ad a5 ad+                 .bulk   $9a,$ad,$a5,$ad,$a9,$a8,$ee,$a1
edcd: ad 60 8c 20+                 .bulk   $ad,$60,$8c,$20,$af,$b4,$b5,$a1
edd5: f2 ac a3 f7+                 .bulk   $f2,$ac,$a3,$f7,$a5,$ae,$60,$8c
eddd: 20 ac a5 a4+                 .bulk   $20,$ac,$a5,$a4,$ee,$b5,$b2,$60
ede5: ae b5 b2 ee+                 .bulk   $ae,$b5,$b2,$ee,$af,$a3,$e5,$b6
eded: a1 b3 e4 a1+                 .bulk   $a1,$b3,$e4,$a1,$af,$ac
                   ; Above are commands.
edf3: 7a 7e 9a 22+                 .bulk   $7a,$7e,$9a,$22,$20,$00,$60,$03
edfb: bf 60 03 bf+                 .bulk   $bf,$60,$03,$bf,$1f

                   ; Token $48 ,
                   ;   string prints
                   ;   PRINT T,A$
ee00: 20 b1 e7     TEE00           jsr     LE7B1
                   ; Token $45 ;
                   ;   string prints
                   ;   PRINT anytype ; string
                   ; Token $61 PRINT
                   ;   string var or literal
                   ;   PRINT A$: PRINT "HELLO"
ee03: e8           PRINTSTR        inx
ee04: e8                           inx
ee05: b5 4f                        lda     NOUNSTKL-1,x
ee07: 85 da                        sta     AUX
ee09: b5 77                        lda     NOUNSTKH-1,x
ee0b: 85 db                        sta     AUX+1
ee0d: b4 4e                        ldy     NOUNSTKL-2,x
ee0f: 98           :Loop           tya
ee10: d5 76                        cmp     NOUNSTKH-2,x
ee12: b0 09                        bcs     LEE1D             ;exit loop
ee14: b1 da                        lda     (AUX),y
ee16: 20 ed fd                     jsr     MON_COUT
ee19: c8                           iny
ee1a: 4c 0f ee                     jmp     :Loop

ee1d: a9 ff        LEE1D           lda     #$ff
ee1f: 85 d5                        sta     CRFLAG            ;CRFLAG = $ff
ee21: 60                           rts

                   ; Token $3b LEN(
ee22: e8           LEN             inx
ee23: a9 00                        lda     #$00
ee25: 95 78                        sta     NOUNSTKH,x
ee27: 95 a0                        sta     NOUNSTKC,x
ee29: b5 77                        lda     NOUNSTKH-1,x
ee2b: 38                           sec
ee2c: f5 4f                        sbc     NOUNSTKL-1,x
ee2e: 95 50                        sta     NOUNSTKL,x
ee30: 4c 23 e8                     jmp     TE823

ee33: ff                           .dd1    $ff

ee34: 20 15 e7     GETBYTE         jsr     GET16BIT
ee37: a5 cf                        lda     ACC+1
ee39: d0 28                        bne     HI255ERR          ;">255"
ee3b: a5 ce                        lda     ACC
ee3d: 60                           rts

                   ; Token $68 ,
                   ;   PLOT 20,15
ee3e: 20 34 ee     COMMA_PLOT      jsr     GETBYTE
ee41: a4 c8                        ldy     TXTNDX
ee43: c9 30                        cmp     #48
ee45: b0 21                        bcs     RANGERR
ee47: c0 28                        cpy     #40
ee49: b0 1d                        bcs     RANGERR
ee4b: 4c 00 f8                     jmp     MON_PLOT

                   ; Token $66 COLOR=
ee4e: 20 34 ee     TEE4E           jsr     GETBYTE
ee51: 4c 64 f8                     jmp     MON_SETCOL

                   ; Token $0f MAN
ee54: 46 f8        TEE54           lsr     AUTOFLAG          ;manual
ee56: 60                           rts

                   ; Token $6f VTAB
ee57: 20 b3 f3     IVTAB           jsr     LF3B3
ee5a: c9 18                        cmp     #24
ee5c: b0 0a                        bcs     RANGERR
ee5e: 85 25                        sta     MON_CV
ee60: 4c 22 fc                     jmp     MON_VTAB

ee63: a0 77        HI255ERR        ldy     #<ErrMsg15        ;">255"
ee65: 4c e0 e3     JmpERRMESS3     jmp     ERRMESS

ee68: a0 7b        RANGERR         ldy     #<ErrMsg16        ;"RANGE"
ee6a: d0 f9                        bne     JmpERRMESS3

                   ; Divide routine.
ee6c: 20 54 e2     LEE6C           jsr     LE254
ee6f: a5 da                        lda     AUX               ;is AUX zero?
ee71: d0 07                        bne     LEE7A
ee73: a5 db                        lda     AUX+1
ee75: d0 03                        bne     LEE7A
ee77: 4c 7e e7                     jmp     Err32767          ;yes, ">32767" error

ee7a: 06 ce        LEE7A           asl     ACC
ee7c: 26 cf                        rol     ACC+1
ee7e: 26 e6                        rol     P3
ee80: 26 e7                        rol     P3+1
ee82: a5 e6                        lda     P3
ee84: c5 da                        cmp     AUX               ;compare P3 to AUX
ee86: a5 e7                        lda     P3+1
ee88: e5 db                        sbc     AUX+1
ee8a: 90 0a                        bcc     LEE96
ee8c: 85 e7                        sta     P3+1              ;P3 = P3 - AUX
ee8e: a5 e6                        lda     P3
ee90: e5 da                        sbc     AUX
ee92: 85 e6                        sta     P3
ee94: e6 ce                        inc     ACC
ee96: 88           LEE96           dey
ee97: d0 e1                        bne     LEE7A
ee99: 60                           rts

ee9a: ff ff ff ff+                 .bulk   $ff,$ff,$ff,$ff,$ff,$ff

                   ; Token $4d CALL
eea0: 20 15 e7     CALL            jsr     GET16BIT
eea3: 6c ce 00                     jmp     (ACC)

                   ; Token $6a ,
                   ;   HLIN 10,20 AT 30
eea6: 20 34 ee     COMMA_HLIN      jsr     GETBYTE
eea9: c5 c8                        cmp     TXTNDX
eeab: 90 bb                        bcc     RANGERR
eead: 85 2c                        sta     MON_H2
eeaf: 60                           rts

                   ; Token $6b AT
                   ;   HLIN 10,20 AT 30
eeb0: 20 34 ee     AT_HLIN         jsr     GETBYTE
eeb3: c9 30                        cmp     #48
eeb5: b0 b1                        bcs     RANGERR
eeb7: a4 c8                        ldy     TXTNDX
eeb9: 4c 19 f8                     jmp     MON_HLINE

                   ; Token $6d ,
                   ;   VLIN 10,20 AT 30
eebc: 20 34 ee     COMMA_VLIN      jsr     GETBYTE
eebf: c5 c8                        cmp     TXTNDX
eec1: 90 a5                        bcc     RANGERR
eec3: 85 2d                        sta     MON_V2
eec5: 60                           rts

                   ; Token $6e AT
                   ;   VLIN 10,20 AT 30
eec6: 20 34 ee     AT_VLIN         jsr     GETBYTE
eec9: c9 28                        cmp     #40
eecb: b0 9b        BcsRANGERR      bcs     RANGERR
eecd: a8                           tay
eece: a5 c8                        lda     TXTNDX
eed0: 4c 28 f8                     jmp     MON_VLINE

eed3: 98           PRINTERR        tya
eed4: aa                           tax
eed5: a0 6e                        ldy     #<ErrMsg13        ;"*** "
eed7: 20 c4 e3                     jsr     ERRORMESS
eeda: 8a                           txa
eedb: a8                           tay
eedc: 20 c4 e3                     jsr     ERRORMESS
eedf: a0 72                        ldy     #<ErrMsg14        ;" ERR"
eee1: 4c 61 f1                     jmp     PRTERR

eee4: 20 3f f2     LEEE4           jsr     LF23F
eee7: 06 ce        LEEE7           asl     ACC
eee9: 26 cf                        rol     ACC+1
eeeb: 30 fa                        bmi     LEEE7
eeed: b0 dc                        bcs     BcsRANGERR
eeef: d0 04                        bne     LEEF5
eef1: c5 ce                        cmp     ACC
eef3: b0 d6                        bcs     BcsRANGERR
eef5: 60           LEEF5           rts

                   ; Token $2e PEEK
                   ;   uses tken $3f (
eef6: 20 15 e7     PEEK            jsr     GET16BIT
eef9: b1 ce                        lda     (ACC),y
eefb: 94 9f                        sty     NOUNSTKC-1,x
eefd: 4c 08 e7                     jmp     LE708

                   ; Token $65 ,
                   ;   POKE 20000,5
                   ; Token $67 PLOT
                   ; Token $69 HLIN
                   ; Token $6c VLIN
ef00: 20 34 ee     GETVAL255       jsr     GETBYTE
ef03: a5 ce                        lda     ACC
ef05: 85 c8                        sta     TXTNDX
ef07: 60                           rts

                   ; Token $64 POKE
ef08: 20 15 e7     POKE            jsr     GET16BIT
ef0b: a5 c8                        lda     TXTNDX
ef0d: 91 ce                        sta     (ACC),y
ef0f: 60                           rts

                   ; Token $15 /
                   ;   num op. uses $38 (
                   ;   A = 27 / 2
ef10: 20 6c ee     DIVIDE          jsr     LEE6C
ef13: a5 ce                        lda     ACC               ;P3 = ACC
ef15: 85 e6                        sta     P3
ef17: a5 cf                        lda     ACC+1
ef19: 85 e7                        sta     P3+1
ef1b: 4c 44 e2                     jmp     MultEnd

                   ; Token $44 ,
                   ;   next var in DIM is num
                   ;   DIM X(5),A(5)
                   ; Token $4f DIM
                   ;   num var. uses tkn $22 (
                   ;   DIM A(5)
ef1e: 20 e4 ee     DIMNUM          jsr     LEEE4
ef21: 4c 34 e1                     jmp     LE134

                   ; Token $2d (
                   ;   var array
                   ;   X(12)
ef24: 20 e4 ee     TEF24           jsr     LEEE4
ef27: b4 78                        ldy     NOUNSTKH,x
ef29: b5 50                        lda     NOUNSTKL,x
ef2b: 69 fe                        adc     #$fe
ef2d: b0 01                        bcs     LEF30
ef2f: 88                           dey
ef30: 85 da        LEF30           sta     AUX
ef32: 84 db                        sty     AUX+1
ef34: 18                           clc
ef35: 65 ce                        adc     ACC
ef37: 95 50                        sta     NOUNSTKL,x
ef39: 98                           tya
ef3a: 65 cf                        adc     ACC+1
ef3c: 95 78                        sta     NOUNSTKH,x
ef3e: a0 00                        ldy     #$00
ef40: b5 50                        lda     NOUNSTKL,x
ef42: d1 da                        cmp     (AUX),y
ef44: c8                           iny
ef45: b5 78                        lda     NOUNSTKH,x
ef47: f1 da                        sbc     (AUX),y
ef49: b0 80                        bcs     BcsRANGERR        ;"RANGE"
ef4b: 4c 23 e8                     jmp     TE823

                   ; Token $2f RND
                   ;   uses tken $3f (
ef4e: 20 15 e7     RND             jsr     GET16BIT
ef51: a5 4e                        lda     MON_RNDL
ef53: 20 08 e7                     jsr     LE708
ef56: a5 4f                        lda     MON_RNDH
ef58: d0 04                        bne     LEF5E
ef5a: c5 4e                        cmp     MON_RNDL
ef5c: 69 00                        adc     #$00
ef5e: 29 7f        LEF5E           and     #$7f
ef60: 85 4f                        sta     MON_RNDH
ef62: 95 a0                        sta     NOUNSTKC,x
ef64: a0 11                        ldy     #$11
ef66: a5 4f        LEF66           lda     MON_RNDH
ef68: 0a                           asl     A
ef69: 18                           clc
ef6a: 69 40                        adc     #$40
ef6c: 0a                           asl     A
ef6d: 26 4e                        rol     MON_RNDL
ef6f: 26 4f                        rol     MON_RNDH
ef71: 88                           dey
ef72: d0 f2                        bne     LEF66
ef74: a5 ce                        lda     ACC
ef76: 20 08 e7                     jsr     LE708
ef79: a5 cf                        lda     ACC+1
ef7b: 95 a0                        sta     NOUNSTKC,x
ef7d: 4c 7a e2                     jmp     MOD

ef80: 20 15 e7     unref_ef80      jsr     GET16BIT
ef83: a4 ce                        ldy     ACC               ;compare ACC and LOMEM
ef85: c4 4a                        cpy     LOMEM
ef87: a5 cf                        lda     ACC+1
ef89: e5 4b                        sbc     LOMEM+1
ef8b: 90 1e                        bcc     JmpBcsRANGEERR    ;[bad idea]
ef8d: 84 4c                        sty     HIMEM             ;HIMEM = ACC
ef8f: a5 cf                        lda     ACC+1
ef91: 85 4d                        sta     HIMEM+1
ef93: 4c ad e5     :unref_branch   jmp     NEW

ef96: 20 15 e7     unref_ef96      jsr     GET16BIT
ef99: a4 ce                        ldy     ACC               ;compare ACC and LOMEM
ef9b: c4 4c                        cpy     HIMEM
ef9d: a5 cf                        lda     ACC+1
ef9f: e5 4d                        sbc     HIMEM+1
efa1: b0 08                        bcs     JmpBcsRANGEERR
efa3: 84 4a                        sty     LOMEM             ;LOMEM = ACC
efa5: a5 cf                        lda     ACC+1
efa7: 85 4b                        sta     LOMEM+1
efa9: 90 e8                        bcc     :unref_branch     ;(always)

efab: 4c cb ee     JmpBcsRANGEERR  jmp     BcsRANGERR

efae: ff ff ff ff+                 .bulk   $ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff

                   ; Token $26 ,
                   ;   string inputs
                   ;   INPUT "WHO",W$
                   ; Token $52 INPUT
                   ;   string with no prompt
                   ;   INPUT S$
efb6: 20 71 e1     TEFB6           jsr     INPUTSTR
efb9: 4c bf ef                     jmp     LEFBF

                   ; Token $53 INPUT
                   ;   string or num with prompt
                   ;   INPUT "WHO",W$: INPUT "QUANTITY",Q
efbc: 20 03 ee     INPUT_PROMPT    jsr     PRINTSTR
efbf: a9 ff        LEFBF           lda     #$ff
efc1: 85 c8                        sta     TXTNDX
efc3: a9 80                        lda     #$80
efc5: 8d 00 02                     sta     IN
efc8: 60                           rts

efc9: 20 36 e7     LEFC9           jsr     NOT
efcc: e8                           inx
efcd: 20 36 e7     LEFCD           jsr     NOT
efd0: b5 50                        lda     NOUNSTKL,x
efd2: 60                           rts

                   ; Old 4K cold start.
efd3: a9 00        LEFD3           lda     #$00
efd5: 85 4a                        sta     LOMEM             ;LOMEM = $0800
efd7: 85 4c                        sta     HIMEM             ;HIMEM = $1000
efd9: a9 08                        lda     #$08
efdb: 85 4b                        sta     LOMEM+1
efdd: a9 10                        lda     #$10
efdf: 85 4d                        sta     HIMEM+1
efe1: 4c ad e5                     jmp     NEW

efe4: d5 78        LEFE4           cmp     NOUNSTKH,x
efe6: d0 01                        bne     LEFE9
efe8: 18                           clc
efe9: 4c 02 e1     LEFE9           jmp     LE102

                   ; Token $08 RUN
                   ;   run from first line of program
efec: 20 b7 e5     RUN             jsr     CLR
efef: 4c 36 e8                     jmp     RUNWARM

                   ; Token $07 RUN
                   ;   RUN 100
eff2: 20 b7 e5     RUNNUM          jsr     CLR
eff5: 4c 5b e8                     jmp     GOTO

eff8: e0 80        LEFF8           cpx     #$80
effa: d0 01                        bne     LEFFD
effc: 88                           dey
effd: 4c 0c e0     LEFFD           jmp     LE00C

                   ; Cold start.
                   ;   set LOMEM, find HIMEM
                   ;   fall into NEW
f000: a0 00        COLD            ldy     #$00
f002: 84 a0                        sty     NOUNSTKC
f004: 84 4a                        sty     LOMEM             ;LOMEM = $0800
f006: 84 4c                        sty     HIMEM             ;HIMEM = $0800
f008: a9 08                        lda     #$08
f00a: 85 4b                        sta     LOMEM+1
f00c: 85 4d                        sta     HIMEM+1
f00e: e6 4d        :Loop           inc     HIMEM+1           ;find top of RAM
f010: b1 4c                        lda     (HIMEM),y
f012: 49 ff                        eor     #$ff
f014: 91 4c                        sta     (HIMEM),y
f016: d1 4c                        cmp     (HIMEM),y
f018: d0 08                        bne     LF022
f01a: 49 ff                        eor     #$ff
f01c: 91 4c                        sta     (HIMEM),y
f01e: d1 4c                        cmp     (HIMEM),y
f020: f0 ec                        beq     :Loop             ;(always, unless RAM is broken)

f022: 4c ad e5     LF022           jmp     NEW

f025: 4c 79 f1     LF025           jmp     LF179

f028: 20 32 f0     unref_f028      jsr     :from_unref
f02b: 4c be e8                     jmp     LE8BE

f02e: a6 e0        LF02E           ldx     PX
f030: a5 e1                        lda     PX+1
f032: ac 00 c0     :from_unref     ldy     KBD               ;get keypress
f035: c0 83                        cpy     #ETX+128          ;is it Ctrl+C?
f037: d0 ec                        bne     LF025             ;no
f039: 2c 10 c0                     bit     KBDSTRB           ;yes, clear keypress
f03c: 86 50                        stx     NOUNSTKL
f03e: 85 51                        sta     NOUNSTKL+1
f040: a5 dc                        lda     PR                ;NOUNSTKH = PR
f042: 85 78                        sta     NOUNSTKH
f044: a5 dd                        lda     PR+1
f046: 85 79                        sta     NOUNSTKH+1
f048: 4c c3 e8                     jmp     STOPPED_AT

f04b: ff ff                        .bulk   $ff,$ff

                   ; Token $10 HIMEM:
f04d: 20 15 e7     VHIMEM          jsr     GET16BIT
f050: 86 d8                        stx     XSAVE
f052: a2 fe                        ldx     #$fe
f054: 38                           sec
f055: b5 d0        :Loop1          lda     ACC+2,x           ;P2 = ACC
f057: 95 e6                        sta     P2+2,x
f059: b5 4e                        lda     HIMEM+2,x         ;AUX = HIMEM - ACC
f05b: f5 d0                        sbc     ACC+2,x
f05d: 95 dc                        sta     AUX+2,x
f05f: e8                           inx
f060: d0 f3                        bne     :Loop1
f062: 90 4b                        bcc     LF0AF
f064: ca                           dex                       ;X-reg = $ff
f065: b5 cb        :Loop2          lda     PP+1,x            ;P3 = PP
f067: 95 e7                        sta     P3+1,x
f069: f5 db                        sbc     AUX+1,x           ;P2 = PP - AUX
f06b: 95 e5                        sta     P2+1,x
f06d: e8                           inx
f06e: f0 f5                        beq     :Loop2            ;compare PV to P2
f070: 90 0a                        bcc     JmpMEMFULL
f072: a5 cc                        lda     PV
f074: c5 e4                        cmp     P2
f076: a5 cd                        lda     PV+1
f078: e5 e5                        sbc     P2+1
f07a: 90 13                        bcc     :NoInc3
f07c: 4c 6b e3     JmpMEMFULL      jmp     MEMFULL

f07f: b1 e6        :Loop           lda     (P3),y
f081: 91 e4                        sta     (P2),y
f083: e6 e4                        inc     P2
f085: d0 02                        bne     :NoInc2
f087: e6 e5                        inc     P2+1
f089: e6 e6        :NoInc2         inc     P3
f08b: d0 02                        bne     :NoInc3
f08d: e6 e7                        inc     P3+1
f08f: a5 e6        :NoInc3         lda     P3                ;compare P3 and HIMEM
f091: c5 4c                        cmp     HIMEM
f093: a5 e7                        lda     P3+1
f095: e5 4d                        sbc     HIMEM+1
f097: 90 e6                        bcc     :Loop
f099: a2 fe        LF099           ldx     #$fe
f09b: b5 e6        :Loop           lda     P2+2,x            ;P2 = HIMEM
f09d: 95 4e                        sta     HIMEM+2,x
f09f: b5 cc                        lda     PP+2,x            ;PP = PP - AUX
f0a1: f5 dc                        sbc     AUX+2,x
f0a3: 95 cc                        sta     PP+2,x
f0a5: e8                           inx
f0a6: d0 f3                        bne     :Loop
f0a8: a6 d8                        ldx     XSAVE
f0aa: 60                           rts

f0ab: b1 4c        LF0AB           lda     (HIMEM),y
f0ad: 91 ce                        sta     (ACC),y
f0af: a5 ce        LF0AF           lda     ACC
f0b1: d0 02                        bne     :NoInc
f0b3: c6 cf                        dec     ACC+1
f0b5: c6 ce        :NoInc          dec     ACC
f0b7: a5 4c                        lda     HIMEM
f0b9: d0 02                        bne     :NoInc
f0bb: c6 4d                        dec     HIMEM+1
f0bd: c6 4c        :NoInc          dec     HIMEM
f0bf: c5 ca                        cmp     PP                ;compare PP to HIMEM
f0c1: a5 4d                        lda     HIMEM+1
f0c3: e5 cb                        sbc     PP+1
f0c5: 90 e4                        bcc     LF0AB
f0c7: b0 d0                        bcs     LF099             ;(always)

                   ; Token $11 LOMEM:
f0c9: 20 15 e7     VLOMEM          jsr     GET16BIT
f0cc: a4 ce                        ldy     ACC
f0ce: c0 ca                        cpy     #PP
                   ; BUG: above line should be CPY PP
f0d0: a5 cf                        lda     ACC+1
f0d2: e5 cb                        sbc     PP+1
f0d4: b0 a6        BcsJmpMEMFULL   bcs     JmpMEMFULL
f0d6: 84 4a                        sty     LOMEM
f0d8: a5 cf                        lda     ACC+1
f0da: 85 4b                        sta     LOMEM+1
f0dc: 4c b7 e5                     jmp     CLR

                   ; Token $04 LOAD
f0df: 86 d8        LOAD            stx     XSAVE
f0e1: 20 1e f1                     jsr     SETHDR
f0e4: 20 fd fe                     jsr     MON_READ
f0e7: a2 ff                        ldx     #$ff
f0e9: 38                           sec
f0ea: b5 4d        :Loop           lda     HIMEM+1,x         ;AUX = HIMEM - ACC
f0ec: f5 cf                        sbc     ACC+1,x
f0ee: 95 db                        sta     AUX+1,x
f0f0: e8                           inx
f0f1: f0 f7                        beq     :Loop
f0f3: 90 87                        bcc     JmpMEMFULL
f0f5: a5 cc                        lda     PV                ;compare PV to AUX
f0f7: c5 da                        cmp     AUX
f0f9: a5 cd                        lda     PV+1
f0fb: e5 db                        sbc     AUX+1
f0fd: b0 d5                        bcs     BcsJmpMEMFULL
f0ff: a5 ce                        lda     ACC               ;is ACC zero?
f101: d0 04                        bne     LF107
f103: a5 cf                        lda     ACC+1
f105: f0 11                        beq     LF118             ;yes
f107: a5 da        LF107           lda     AUX               ;PP = AUX
f109: 85 ca                        sta     PP
f10b: a5 db                        lda     AUX+1
f10d: 85 cb                        sta     PP+1
f10f: 20 2c f1                     jsr     SETPRG
f112: 20 fd fe                     jsr     MON_READ
f115: a6 d8        LF115           ldx     XSAVE
f117: 60                           rts

f118: 20 3a ff     LF118           jsr     MON_BELL
f11b: 4c 15 f1                     jmp     LF115

f11e: a0 ce        SETHDR          ldy     #$ce
f120: 84 3c                        sty     MON_A1L           ;A1 = $00ce
f122: c8                           iny
f123: 84 3e                        sty     MON_A2L           ;A2 = $00cd
f125: a0 00                        ldy     #$00
f127: 84 3d                        sty     MON_A1H
f129: 84 3f                        sty     MON_A2H
f12b: 60                           rts

f12c: b5 ca        SETPRG          lda     PP,x
f12e: 95 3c                        sta     MON_A1L,x
f130: b4 4c                        ldy     HIMEM,x
f132: 94 3e                        sty     MON_A2L,x
f134: ca                           dex
f135: 10 f5                        bpl     SETPRG
f137: a5 3e                        lda     MON_A2L           ;decrement A2
f139: d0 02                        bne     LF13D
f13b: c6 3f                        dec     MON_A2H
f13d: c6 3e        LF13D           dec     MON_A2L
f13f: 60                           rts

f140: 86 d8        unref_f140      stx     XSAVE
                   ; Token $05 SAVE
f142: 38           SAVE            sec                       ;ACC = HIMEM - PP
f143: a2 ff                        ldx     #$ff
f145: b5 4d        :Loop           lda     HIMEM+1,x
f147: f5 cb                        sbc     PP+1,x
f149: 95 cf                        sta     ACC+1,x
f14b: e8                           inx
f14c: f0 f7                        beq     :Loop
f14e: 20 1e f1                     jsr     SETHDR
f151: 20 cd fe                     jsr     MON_WRITE
f154: a2 01                        ldx     #$01
f156: 20 2c f1                     jsr     SETPRG
f159: a9 1a                        lda     #$1a
f15b: 20 cf fe                     jsr     MON_WRITE0
f15e: a6 d8                        ldx     XSAVE
f160: 60                           rts

f161: 20 c4 e3     PRTERR          jsr     ERRORMESS
f164: 4c 3a ff                     jmp     MON_BELL

                   ; Token $77 POP
f167: a5 fc        POP             lda     GOSUBNDX
f169: d0 03                        bne     LF16E
f16b: 4c a5 e8                     jmp     RETURN

f16e: c6 fc        LF16E           dec     GOSUBNDX
f170: 60                           rts

                   ; Token $7d TRACE
f171: a9 ff        TRACE           lda     #$ff
f173: 85 a0                        sta     NOUNSTKC
f175: 60                           rts

                   ; Token $7a NOTRACE
f176: 46 a0        NOTRACE         lsr     NOUNSTKC          ;clear bit 7
f178: 60                           rts

f179: 24 a0        LF179           bit     NOUNSTKC          ;trace mode?
f17b: 10 19                        bpl     :Return           ;no
f17d: a9 a3        LF17D           lda     #“#”              ;yes, print line number
f17f: 20 ed fd                     jsr     MON_COUT
f182: a0 01                        ldy     #$01
f184: b1 dc                        lda     (PR),y
f186: aa                           tax
f187: c8                           iny
f188: b1 dc                        lda     (PR),y
f18a: 20 1b e5                     jsr     PRDEC
f18d: a9 a0                        lda     #BLANK+128
f18f: 4c ed fd                     jmp     MON_COUT

f192: a5 dc        unref_f192      lda     PR
f194: a4 dd                        ldy     PR+1
f196: 60           :Return         rts

                   ; Indices into SYNTABL.
f197: c1 00 7f d1+ SYNTABLNDX      .bulk   $c1,$00,$7f,$d1,$cc,$c7,$cf,$ce
f19f: c5 9a 98 8d+                 .bulk   $c5,$9a,$98,$8d,$96,$95,$93,$bf
f1a7: b2 32 12 0f+                 .bulk   $b2,$32,$12,$0f,$bc,$b0,$ac,$be
f1af: 35 0c 61 30+                 .bulk   $35,$0c,$61,$30,$10,$0b,$dd,$fb

f1b7: a0 00        LF1B7           ldy     #$00
f1b9: 20 c7 e7                     jsr     LE7C7
f1bc: a9 a0                        lda     #$a0
f1be: 4c ed fd                     jmp     MON_COUT

f1c1: 00 00 00 00+                 .bulk   $00,$00,$00,$00,$00,$00,$00,$00

f1c9: a4 4a        LF1C9           ldy     LOMEM
f1cb: a5 4b                        lda     LOMEM+1
f1cd: 48           :Loop1          pha
f1ce: c4 da                        cpy     AUX               ;compare LOMEM to AUX
f1d0: e5 db                        sbc     AUX+1
f1d2: b0 1c                        bcs     LF1F0
f1d4: 68                           pla
f1d5: 84 d0                        sty     SRCH              ;SRCH = LOMEM
f1d7: 85 d1                        sta     TOKNDXSTK
f1d9: a0 ff                        ldy     #$ff
f1db: c8           :Loop2          iny
f1dc: b1 d0                        lda     (SRCH),y
f1de: 30 fb                        bmi     :Loop2
f1e0: c9 40                        cmp     #$40
f1e2: f0 f7                        beq     :Loop2
f1e4: c8                           iny
f1e5: c8                           iny
f1e6: b1 d0                        lda     (SRCH),y
f1e8: 48                           pha
f1e9: 88                           dey
f1ea: b1 d0                        lda     (SRCH),y
f1ec: a8                           tay
f1ed: 68                           pla
f1ee: d0 dd                        bne     :Loop1
f1f0: 68           LF1F0           pla
f1f1: a0 00                        ldy     #$00
f1f3: b1 d0        LF1F3           lda     (SRCH),y
f1f5: 30 05                        bmi     LF1FC
f1f7: 4a                           lsr     A
f1f8: f0 08                        beq     LF202
f1fa: a9 a4                        lda     #“$”
f1fc: 20 ed fd     LF1FC           jsr     MON_COUT
f1ff: c8                           iny
f200: d0 f1                        bne     LF1F3
f202: a9 bd        LF202           lda     #“=”
f204: 4c ed fd                     jmp     MON_COUT

f207: 91 da        LF207           sta     (AUX),y
f209: e8                           inx
f20a: b5 9f                        lda     NOUNSTKC-1,x
f20c: f0 30                        beq     :Return
f20e: 4c d5 f3                     jmp     LF3D5

f211: a0                           .dd1    $a0

f212: 30 07        LF212           bmi     LF21B
f214: a5 dc                        lda     PR
f216: a4 dd                        ldy     PR+1
f218: 20 7d f1                     jsr     LF17D
f21b: 20 c9 f1     LF21B           jsr     LF1C9
f21e: a6 d8                        ldx     XSAVE
f220: 4c b7 f1                     jmp     LF1B7

f223: e8           LF223           inx
f224: e8                           inx
f225: b5 9f                        lda     NOUNSTKC-1,x
f227: f0 1f                        beq     :Return
f229: 4c e0 f3                     jmp     LF3E0

f22c: 30 07        LF22C           bmi     LF235
f22e: a5 dc                        lda     PR
f230: a4 dd                        ldy     PR+1
f232: 20 7d f1                     jsr     LF17D
f235: 20 c9 f1     LF235           jsr     LF1C9
f238: a6 d8                        ldx     XSAVE
f23a: 4c 09 f4                     jmp     LF409

f23d: e8                           .dd1    $e8

f23e: 60           :Return         rts

f23f: 20 15 e7     LF23F           jsr     GET16BIT
f242: e6 ce                        inc     ACC
f244: d0 02                        bne     :Return
f246: e6 cf                        inc     ACC+1
f248: 60           :Return         rts

                   ; Token $1c <
                   ;   IF X < 13 THEN END
f249: 20 5b f2     TF249           jsr     TF25B
f24c: d0 15                        bne     JmpNOT
                   ; Token $19 >
                   ;   IF X > 13 THEN END
f24e: 20 53 f2     TF24E           jsr     TF253
f251: d0 10                        bne     JmpNOT
                   ; Token $1a <=
                   ;   IF X <= 13 THEN END
f253: 20 82 e7     TF253           jsr     SUBTRACT
f256: 20 6f e7                     jsr     NEGATE
f259: 50 03                        bvc     LF25E
                   ; Token $18 >=
                   ;   IF X >= 13 THEN END
f25b: 20 82 e7     TF25B           jsr     SUBTRACT
f25e: 20 59 e7     LF25E           jsr     SGN
f261: 56 50                        lsr     NOUNSTKL,x
f263: 4c 36 e7     JmpNOT          jmp     NOT

                   ; Token $1d AND
f266: 20 c9 ef     VAND            jsr     LEFC9
f269: 15 4f                        ora     NOUNSTKL-1,x
f26b: 10 05                        bpl     LF272             ;(always?)
                   ; Token $1e OR
f26d: 20 c9 ef     VOR             jsr     LEFC9
f270: 35 4f                        and     NOUNSTKL-1,x
f272: 95 50        LF272           sta     NOUNSTKL,x
f274: 10 ed                        bpl     JmpNOT
f276: 4c c9 ef                     jmp     LEFC9

                   ; Token $58 STEP
f279: 20 15 e7     STEP            jsr     GET16BIT
f27c: a4 fb                        ldy     FORNDX
f27e: a5 ce                        lda     ACC
f280: 99 5f 01                     sta     STK_60-1,y
f283: a5 cf                        lda     ACC+1
f285: 4c 66 e9                     jmp     LE966

f288: 99 50 01     LF288           sta     STK_50,y
f28b: 88           :Loop1          dey
f28c: 30 51                        bmi     :Return
f28e: b9 40 01                     lda     STK_40,y
f291: d5 50                        cmp     NOUNSTKL,x
f293: d0 f6                        bne     :Loop1
f295: b9 50 01                     lda     STK_50,y
f298: d5 78                        cmp     NOUNSTKH,x
f29a: d0 ef                        bne     :Loop1
f29c: c6 fb                        dec     FORNDX
f29e: b9 41 01     :Loop2          lda     STK_40+1,y
f2a1: 99 40 01                     sta     STK_40,y
f2a4: b9 51 01                     lda     STK_50+1,y
f2a7: 99 50 01                     sta     STK_50,y
f2aa: b9 c1 01                     lda     STK_C0+1,y
f2ad: 99 c0 01                     sta     STK_C0,y
f2b0: b9 d1 01                     lda     STK_D0+1,y
f2b3: 99 d0 01                     sta     STK_D0,y
f2b6: b9 61 01                     lda     STK_60+1,y
f2b9: 99 60 01                     sta     STK_60,y
f2bc: b9 71 01                     lda     STK_70+1,y
f2bf: 99 70 01                     sta     STK_70,y
f2c2: b9 81 01                     lda     STK_80+1,y
f2c5: 99 80 01                     sta     STK_80,y
f2c8: b9 91 01                     lda     STK_90+1,y
f2cb: 99 90 01                     sta     STK_90,y
f2ce: b9 a1 01                     lda     STK_A0+1,y
f2d1: 99 a0 01                     sta     STK_A0,y
f2d4: b9 a1 01                     lda     STK_A0+1,y
f2d7: 99 a0 01                     sta     STK_A0,y
                   ; BUG: above two lines should be:
                   ;   LDA STK_B0+1,Y
                   ;   STA STK_B0,Y
f2da: c8                           iny
f2db: c4 fb                        cpy     FORNDX
f2dd: 90 bf                        bcc     :Loop2
f2df: 60           :Return         rts

                   ; Token $78 NODSP
                   ;   string var
f2e0: e8           NODSP_STR       inx
                   ; Token $79 NODSP
                   ;   num var
f2e1: a9 00        NODSP_NUM       lda     #$00
f2e3: 48           LF2E3           pha
f2e4: b5 50                        lda     NOUNSTKL,x
f2e6: 38                           sec
f2e7: e9 03                        sbc     #$03
f2e9: 85 ce                        sta     ACC
f2eb: b5 78                        lda     NOUNSTKH,x
f2ed: e9 00                        sbc     #$00
f2ef: 85 cf                        sta     ACC+1
f2f1: 68                           pla
f2f2: a0 00                        ldy     #$00
f2f4: 91 ce                        sta     (ACC),y
f2f6: e8                           inx
f2f7: 60                           rts

f2f8: c9 85        LF2F8           cmp     #$85
f2fa: b0 03                        bcs     LF2FF
f2fc: 4c c0 e4                     jmp     LE4C0

f2ff: a0 02        LF2FF           ldy     #$02
f301: 4c 48 e4                     jmp     LE448

                   ; Token $7b DSP
                   ;   string var
f304: e8           DSP_STR         inx                       ;[DSP_NUM in paulrsm disasm]
                   ; Token $7c DSP
                   ;   num var
f305: a9 01        DSP_NUM         lda     #$01              ;[DSP_STR in paulrsm disasm]
f307: d0 da                        bne     LF2E3             ;(always)

f309: e8                           .dd1    $e8

                   ; Token $06 CON
f30a: a5 78        CON             lda     NOUNSTKH          ;PR = NOUNSTKH
f30c: 85 dc                        sta     PR
f30e: a5 79                        lda     NOUNSTKH+1
f310: 85 dd                        sta     PR+1
f312: a5 50                        lda     NOUNSTKL
f314: a4 51                        ldy     NOUNSTKL+1
f316: 4c 75 e8                     jmp     GETNEXT

f319: a9 01        unref_f319      lda     #$01
f31b: d0 c6                        bne     LF2E3

                   ; Token $3c ASC(
f31d: b5 50        ASC             lda     NOUNSTKL,x
f31f: d5 78                        cmp     NOUNSTKH,x
f321: 90 03                        bcc     LF326
f323: 4c 68 ee                     jmp     RANGERR

f326: a8           LF326           tay
f327: b5 51                        lda     NOUNSTKL+1,x
f329: 85 ce                        sta     ACC
f32b: b5 79                        lda     NOUNSTKH+1,x
f32d: 85 cf                        sta     ACC+1
f32f: b1 ce                        lda     (ACC),y
f331: a0 00                        ldy     #$00
f333: e8                           inx
f334: e8                           inx
f335: 20 08 e7                     jsr     LE708
f338: 4c 04 f4                     jmp     LF404

                   ; Token $32 PDL
f33b: 20 34 ee     PDL             jsr     GETBYTE
f33e: 86 d8                        stx     XSAVE
f340: 29 03                        and     #$03
f342: aa                           tax
f343: 20 1e fb                     jsr     MON_PREAD
f346: a6 d8                        ldx     XSAVE
f348: 98                           tya
f349: a0 00                        ldy     #$00
f34b: 20 08 e7                     jsr     LE708
f34e: 94 a0                        sty     NOUNSTKC,x
f350: 60                           rts

f351: 20 75 fd     RDKEY           jsr     MON_NXTCHAR
f354: 8a           LF354           txa
f355: 48                           pha
f356: bd 00 02     :Loop           lda     IN,x
f359: c9 83                        cmp     #ETX+128          ;is it Ctrl+C?
f35b: d0 03                        bne     LF360
f35d: 4c 03 e0                     jmp     BASIC2

f360: ca           LF360           dex
f361: 10 f3                        bpl     :Loop
f363: 68                           pla
f364: aa                           tax
f365: 60                           rts

f366: 20 80 e2     LF366           jsr     LE280
f369: 98                           tya
f36a: aa                           tax
f36b: 20 54 f3                     jsr     LF354
f36e: 8a                           txa
f36f: a8                           tay
f370: 60                           rts

                   ; Token $20 ^
f371: 20 15 e7     EXP             jsr     GET16BIT
f374: a5 cf                        lda     ACC+1
f376: 10 08                        bpl     LF380
f378: 98                           tya                       ;A-reg = 0
f379: ca                           dex
f37a: 20 08 e7                     jsr     LE708
f37d: 94 a0                        sty     NOUNSTKC,x
f37f: 60           :Return         rts

f380: 85 d1        LF380           sta     SRCH+1            ;SRCH = ACC
f382: a5 ce                        lda     ACC
f384: 85 d0                        sta     SRCH
f386: 20 15 e7                     jsr     GET16BIT
f389: a5 ce                        lda     ACC               ;SRCH2 = ACC
f38b: 85 d2                        sta     SRCH2
f38d: a5 cf                        lda     ACC+1
f38f: 85 d3                        sta     SRCH2+1
f391: a9 01                        lda     #$01
f393: 20 08 e7                     jsr     LE708
f396: 94 a0                        sty     NOUNSTKC,x
f398: a5 d0        :Loop           lda     SRCH              ;srch = SRCH - 1
f39a: d0 04                        bne     :NoDec
f39c: c6 d1                        dec     SRCH+1            ;is SRCH negative?
f39e: 30 df                        bmi     :Return           ;yes, return
f3a0: c6 d0        :NoDec          dec     SRCH
f3a2: a5 d2                        lda     SRCH2
f3a4: a0 00                        ldy     #$00
f3a6: 20 08 e7                     jsr     LE708
f3a9: a5 d3                        lda     SRCH2+1
f3ab: 95 a0                        sta     NOUNSTKC,x
f3ad: 20 22 e2                     jsr     MULT
f3b0: 4c 98 f3                     jmp     :Loop

f3b3: 20 34 ee     LF3B3           jsr     GETBYTE
f3b6: 18                           clc                       ;A-reg = A-reg - 1
f3b7: 69 ff                        adc     #$ff
f3b9: 60           :Return         rts

                   ; Token $4a ,
                   ;   end of PRINT statement
                   ;   PRINT A$,
f3ba: 20 b1 e7     TF3BA           jsr     LE7B1
f3bd: 46 d5                        lsr     CRFLAG            ;pos
f3bf: 60                           rts

f3c0: 86 d9        unref_f3c0      stx     RUNFLAG
f3c2: 9a                           txs
f3c3: 20 2e f0                     jsr     LF02E
f3c6: 4c 83 e8                     jmp     LE883

                   ; Token $7e PR#
f3c9: 20 34 ee     PRSLOT          jsr     GETBYTE
f3cc: 86 d8                        stx     XSAVE
f3ce: 20 95 fe                     jsr     MON_OUTPORT
f3d1: a6 d8                        ldx     XSAVE
f3d3: 60                           rts

f3d4: fe                           .dd1    $fe

f3d5: 24 d9        LF3D5           bit     RUNFLAG
f3d7: 10 e0                        bpl     :Return
f3d9: 86 d8                        stx     XSAVE
f3db: 24 a0                        bit     NOUNSTKC
f3dd: 4c 12 f2                     jmp     LF212

f3e0: 24 d9        LF3E0           bit     RUNFLAG
f3e2: 10 d5                        bpl     :Return
f3e4: 86 d8                        stx     XSAVE
f3e6: 24 a0                        bit     NOUNSTKC
f3e8: 4c 2c f2                     jmp     LF22C

f3eb: a0 00        LF3EB           ldy     #$00
f3ed: 4c ff e6                     jmp     GETVERB

f3f0: a8           :Loop           tay
f3f1: 20 8e fd                     jsr     MON_CROUT
f3f4: 98           LF3F4           tya
f3f5: 38                           sec
f3f6: e5 21                        sbc     MON_WNDWDTH
f3f8: b0 f6                        bcs     :Loop
f3fa: 84 24                        sty     MON_CH
f3fc: 60                           rts

f3fd: 00 00 00 ff+                 .bulk   $00,$00,$00,$ff,$ff,$ff,$ff

f404: 94 a0        LF404           sty     NOUNSTKC,x
f406: 4c 23 e8                     jmp     TE823

f409: a0 00        LF409           ldy     #$00
f40b: f0 04                        beq     LF411             ;(always)

f40d: 20 ed fd     :Loop           jsr     MON_COUT
f410: c8                           iny
f411: b1 da        LF411           lda     (AUX),y
f413: 30 f8                        bmi     :Loop
f415: a9 ff                        lda     #$ff
f417: 85 d5                        sta     CRFLAG            ;CRFLAG = $ff
f419: 60                           rts

                   ; Token $7f IN#
f41a: 20 34 ee     INSLOT          jsr     GETBYTE
f41d: 86 d8                        stx     XSAVE
f41f: 20 8b fe                     jsr     MON_INPORT
f422: a6 d8                        ldx     XSAVE
f424: 60                           rts

f425: 18 a2 02 b5+                 .junk   987               ;binary ends at $f7ff
                                   .adrend ↑ $e000

Symbol Table

No exported symbols found.