C 64   Basic ROM
A000   .WD $E394                ; RESET
A002   .WD $E37B                ; Warmstart

; CBM BASIC

A004   .BY $43,$42,$4D,$42,$41,$53,$49,$43

; Adressen der Befehle (Adresse minus 1)

A00C   .WD $A830                ; end
A00E   .WD $A741                ; for
A010   .WD $AD1D                ; next
A012   .WD $A8F7                ; data
A014   .WD $ABA4                ; input#
A016   .WD $ABBE                ; input
A018   .WD $B080                ; dim
A01A   .WD $AC05                ; read
A01C   .WD $A9A4                ; let
A01E   .WD $A89F                ; goto
A020   .WD $A870                ; run
A022   .WD $A927                ; if
A024   .WD $A81C                ; restore
A026   .WD $A882                ; gosub
A028   .WD $A8D1                ; return
A02A   .WD $A93A                ; rem
A02C   .WD $A82E                ; stop
A02E   .WD $A94A                ; on
A030   .WD $B82C                ; wait
A032   .WD $E167                ; load
A034   .WD $E155                ; save
A036   .WD $E164                ; verify
A038   .WD $B3B2                ; def
A03A   .WD $B823                ; poke
A03C   .WD $AA7F                ; print#
A03E   .WD $AA9F                ; print
A040   .WD $A856                ; cont
A042   .WD $A69B                ; list
A044   .WD $A65D                ; clr
A046   .WD $AA85                ; cmd
A048   .WD $E129                ; sys
A04A   .WD $E1BD                ; open
A04C   .WD $E1C6                ; close
A04E   .WD $AB7A                ; get
A050   .WD $A641                ; new

; Adressen der Funktionen

A052   .WD $BC39                ; sgn
A054   .WD $BCCC                ; int
A056   .WD $BC58                ; abs
A058   .WD $0310                ; usr
A05A   .WD $B37D                ; fre
A05C   .WD $B39E                ; pos
A05E   .WD $BF71                ; sqr
A060   .WD $E097                ; rnd
A062   .WD $B9EA                ; log
A064   .WD $BFED                ; exp
A066   .WD $E264                ; cos
A068   .WD $E26B                ; sin
A06A   .WD $E2B4                ; tan
A06C   .WD $E30E                ; atn
A06E   .WD $B80D                ; peek
A070   .WD $B77C                ; len
A072   .WD $B465                ; str$
A074   .WD $B7AD                ; val
A076   .WD $B78B                ; asc
A078   .WD $B6EC                ; chr$
A07A   .WD $B700                ; left$
A07C   .WD $B72C                ; right$
A07E   .WD $B737                ; mid$

; Prioritäten and Adressen der Operatoren (Adresse minus 1)

A080   .BY $79
A081   .WD $B869                ; plus
A083   .BY $79
A084   .WD $B852                ; minus
A086   .BY $7B
A087   .WD $BA2A                ; multiply
A089   .BY $7B
A08A   .WD $BB11                ; divide
A08C   .BY $7F
A08D   .WD $BF7A                ; power
A08F   .BY $50
A090   .WD $AFE8                ; AND
A092   .BY $46
A093   .WD $AFE5                ; OR
A095   .BY $7D
A096   .WD $BFB3                ; negative
A098   .BY $5A
A099   .WD $AED3                ; NOT
A09B   .BY $64
A09C   .WD $B015                ; greater / equal / less

; Tabelle der Befehle, endet jeweils mit $80

A09E   .BY $45,$4E,$C4                  ; end
A0A1   .BY $46,$4F,$D2                  ; for
A0A4   .BY $4E,$45,$58,$D4              ; next
A0A8   .BY $44,$41,$54,$C1              ; data
A0AC   .BY $49,$4E,$50,$55,$54,$A3      ; input#
A0B2   .BY $49,$4E,$50,$55,$D4          ; input
A0B7   .BY $44,$49,$CD                  ; dim
A0BA   .BY $52,$45,$41,$C4              ; read
A0BE   .BY $4C,$45,$D4                  ; let
A0C1   .BY $47,$4F,$54,$CF              ; goto
A0C5   .BY $52,$55,$CE                  ; run
A0C8   .BY $49,$C6                      ; if
A0CA   .BY $52,$45,$53,$54,$4F,$52,$C5  ; restore
A0D1   .BY $47,$4F,$53,$55,$C2          ; gosub
A0D6   .BY $52,$45,$54,$55,$52,$CE      ; return
A0DC   .BY $52,$45,$CD                  ; rem
A0DF   .BY $53,$54,$4F,$D0              ; stop
A0E3   .BY $4F,$CE                      ; on
A0E5   .BY $57,$41,$49,$D4              ; wait
A0E9   .BY $4C,$4F,$41,$C4              ; load
A0ED   .BY $53,$41,$56,$C5              ; save
A0F1   .BY $56,$45,$52,$49,$46,$D9      ; verify
A0F7   .BY $44,$45,$C6                  ; def
A0FA   .BY $50,$4F,$4B,$C5              ; poke
A0FE   .BY $50,$52,$49,$4E,$54,$A3      ; print#
A104   .BY $50,$52,$49,$4E,$D4          ; print
A109   .BY $43,$4F,$4E,$D4              ; cont
A10D   .BY $4C,$49,$53,$D4              ; list
A111   .BY $43,$4C,$D2                  ; clr
A114   .BY $43,$4D,$C4                  ; cmd
A117   .BY $53,$59,$D3                  ; sys
A11A   .BY $4F,$50,$45,$CE              ; open
A11E   .BY $43,$4C,$4F,$53,$C5          ; close
A123   .BY $47,$45,$D4                  ; get
A126   .BY $4E,$45,$D7                  ; new

; Tabelle der Funktionen, endet jeweils mit $80

A129   .BY $54,$41,$42,$A8           ; tab(
A12D   .BY $54,$CF                   ; to
A12F   .BY $46,$CE                   ; fn
A131   .BY $53,$50,$43,$A8           ; spc(
A135   .BY $54,$48,$45,$CE           ; then
A139   .BY $4E,$4F,$D4               ; not
A13C   .BY $53,$54,$45,$D0           ; step
A140   .BY $AB                       ; plus
A141   .BY $AD                       ; minus
A142   .BY $AA                       ; multiply
A143   .BY $AF                       ; divide
A144   .BY $DE                       ; power
A145   .BY $41,$4E,$C4               ; and
A148   .BY $4F,$D2                   ; on
A14A   .BY $BE                       ; greater
A14B   .BY $BD                       ; equal
A14C   .BY $BC                       ; less
A14D   .BY $53,$47,$CE               ; sgn
A150   .BY $49,$4E,$D4               ; int
A153   .BY $41,$42,$D3               ; abs
A156   .BY $55,$53,$D2               ; usr
A159   .BY $46,$52,$C5               ; fre
A15C   .BY $50,$4F,$D3               ; pos
A15F   .BY $53,$51,$D2               ; sqr
A162   .BY $52,$4E,$C4               ; rnd
A165   .BY $4C,$4F,$C7               ; log
A168   .BY $45,$58,$D0               ; exp
A16B   .BY $43,$4F,$D3               ; cos
A16E   .BY $53,$49,$CE               ; sin
A171   .BY $54,$41,$CE               ; tan
A174   .BY $41,$54,$CE               ; atn
A177   .BY $50,$45,$45,$CB           ; peek
A17B   .BY $4C,$45,$CE               ; len
A17E   .BY $53,$54,$52,$A4           ; str$
A182   .BY $56,$41,$CC               ; val
A185   .BY $41,$53,$C3               ; asc
A188   .BY $43,$48,$52,$A4           ; chr$
A18C   .BY $4C,$45,$46,$54,$A4       ; left$
A191   .BY $52,$49,$47,$48,$54,$A4   ; right$
A197   .BY $4D,$49,$44,$A4           ; mid$

; Andere Befehle

A19B   .BY $47,$CF                   ; go
A19D   .BY $00

; Tabelle der Fehlermeldungen, endet jeweils mit $80

; too many files

A19E   .BY $54,$4F,$4F
A1A1   .BY $20,$4D,$41,$4E,$59
A1A6   .BY $20,$46,$49,$4C,$45,$D3

; file open

A1AC   .BY $46,$49,$4C,$45
A1B0   .BY $20,$4F,$50,$45,$CE

; file not open

A1B5   .BY $46,$49,$4C,$45
A1B9   .BY $20,$4E,$4F,$54
A1BD   .BY $20,$4F,$50,$45,$CE

; file not found

A1C2   .BY $46,$49,$4C,$45
A1C6   .BY $20,$4E,$4F,$54
A1CA   .BY $20,$46,$4F,$55,$4E,$C4

; device not present

A1D0   .BY $44,$45,$56,$49,$43,$45
A1D6   .BY $20,$4E,$4F,$54
A1DA   .BY $20,$50,$52,$45,$53,$45,$4E,$D4

; not input file

A1E2   .BY $4E,$4F,$54
A1E5   .BY $20,$49,$4E,$50,$55,$54
A1EB   .BY $20,$46,$49,$4C,$C5

; not output file

A1F0   .BY $4E,$4F,$54
A1F3   .BY $20,$4F,$55,$54,$50,$55,$54
A1FA   .BY $20,$46,$49,$4C,$C5

; missisng file name

A1FF   .BY $4D,$49,$53,$53,$49,$4E,$47
A206   .BY $20,$46,$49,$4C,$45
A20B   .BY $20,$4E,$41,$4D,$C5

; illegal device number

A210   .BY $49,$4C,$4C,$45,$47,$41,$4C
A217   .BY $20,$44,$45,$56,$49,$43,$45
A21E   .BY $20,$4E,$55,$4D,$42,$45,$D2

; next without for

A225   .BY $4E,$45,$58,$54
A229   .BY $20,$57,$49,$54,$48,$4F,$55,$54
A231   .BY $20,$46,$4F,$D2

; syntax

A235   .BY $53,$59,$4E,$54,$41,$D8

; return without gosub

A23B   .BY $52,$45,$54,$55,$52,$4E
A241   .BY $20,$57,$49,$54,$48,$4F,$55,$54
A249   .BY $20,$47,$4F,$53,$55,$C2

; out of data

A24F   .BY $4F,$55,$54
A252   .BY $20,$4F,$46
A255   .BY $20,$44,$41,$54,$C1

; illegal quantity

A25A   .BY $49,$4C,$4C,$45,$47,$41,$4C
A261   .BY $20,$51,$55,$41,$4E,$54,$49,$54,$D9

; overflow

A26A   .BY $4F,$56,$45,$52,$46,$4C,$4F,$D7

; out of memory

A272   .BY $4F,$55,$54
A275   .BY $20,$4F,$46
A278   .BY $20,$4D,$45,$4D,$4F,$52,$D9

; undef'd statement

A27F   .BY $55,$4E,$44,$45,$46,$27,$44
A286   .BY $20,$53,$54,$41,$54,$45,$4D,$45,$4E,$D4

; bad subscript

A290   .BY $42,$41,$44
A293   .BY $20,$53,$55,$42,$53,$43,$52,$49,$50,$D4

; redim'd array

A29D   .BY $52,$45,$44,$49,$4D,$27,$44
A2A4   .BY $20,$41,$52,$52,$41,$D9

; division by zero

A2AA   .BY $44,$49,$56,$49,$53,$49,$4F,$4E
A2B2   .BY $20,$42,$59
A2B5   .BY $20,$5A,$45,$52,$CF

; illegal direct

A2BA   .BY $49,$4C,$4C,$45,$47,$41,$4C
A2C1   .BY $20,$44,$49,$52,$45,$43,$D4

; type mismatch

A2C8   .BY $54,$59,$50,$45
A2CC   .BY $20,$4D,$49,$53,$4D,$41,$54,$43,$C8

; string to long

A2D5   .BY $53,$54,$52,$49,$4E,$47
A2DB   .BY $20,$54,$4F,$4F
A2DF   .BY $20,$4C,$4F,$4E,$C7

; file data

A2E4   .BY $46,$49,$4C,$45
A2E8   .BY $20,$44,$41,$54,$C1

; formula too complex

A2ED   .BY $46,$4F,$52,$4D,$55,$4C,$41
A2F4   .BY $20,$54,$4F,$4F
A2F8   .BY $20,$43,$4F,$4D,$50,$4C,$45,$D8

; can't continue

A300   .BY $43,$41,$4E,$27,$54
A305   .BY $20,$43,$4F,$4E,$54,$49,$4E,$55,$C5

; undef'd function

A30E   .BY $55,$4E,$44,$45,$46,$27,$44
A315   .BY $20,$46,$55,$4E,$43,$54,$49,$4F,$CE

; verify

A31E   .BY $56,$45,$52,$49,$46,$D9

; load

A324   .BY $4C,$4F,$41,$C4

; Adressen der Fehlermeldungen

A328   .WD $A19E                ; 01 too many files
A32A   .WD $A1AC                ; 02 file open
A32C   .WD $A1B5                ; 03 file not open
A32E   .WD $A1C2                ; 04 file not found
A330   .WD $A1D0                ; 05 device not present
A332   .WD $A1E2                ; 06 not input file
A334   .WD $A1F0                ; 07 not output file
A336   .WD $A1FF                ; 08 missing file name
A338   .WD $A210                ; 09 illegal device number
A33A   .WD $A225                ; 0A next without for
A33C   .WD $A235                ; 0B syntax
A33E   .WD $A23B                ; 0C return without gosub
A340   .WD $A24F                ; 0D out of data
A342   .WD $A25A                ; 0E illegal quantity
A344   .WD $A26A                ; 0F overflow
A346   .WD $A272                ; 10 out of memory
A348   .WD $A27F                ; 11 undef'd statment
A34A   .WD $A290                ; 12 bad subscript
A34C   .WD $A29D                ; 13 redim'd array
A34E   .WD $A2AA                ; 14 devision by zero
A350   .WD $A2BA                ; 15 illegal direct
A352   .WD $A2C8                ; 16 type mismatch
A354   .WD $A2D5                ; 17 string too long
A356   .WD $A2E4                ; 18 file data
A358   .WD $A2ED                ; 19 formula too complex
A35A   .WD $A300                ; 1A can't continue
A35C   .WD $A30E                ; 1B undef'd function
A35E   .WD $A31E                ; 1C verify
A360   .WD $A324                ; 1D load
A362   .WD $A383                ; 1E break

; other messages

; ok

A364   .BY $0D,$4F,$4B,$0D
A368   .BY $00

; error

A369   .BY $20,$20,$45,$52,$52,$4F,$52
A370   .BY $00

; in

A371   .BY $20,$49,$4E,$20
A375   .BY $00

; ready.

A376   .BY $0D,$0A,$52,$45,$41,$44,$59,$2E,$0D,$0A
A380   .BY $00

; break

A381   .BY $0D,$0A
A383   .BY $42,$52,$45,$41,$4B
A388   .BY $00
A389   .BY $A0

; Suche nach "for"-Blocks am Stack

A38A   BA         TSX
A38B   E8         INX
A38C   E8         INX
A38D   E8         INX
A38E   E8         INX
A38F   BD 01 01   LDA $0101,X
A392   C9 81      CMP #$81      ; for block code
A394   D0 21      BNE $A3B7
A396   A5 4A      LDA $4A
A398   D0 0A      BNE $A3A4
A39A   BD 02 01   LDA $0102,X
A39D   85 49      STA $49
A39F   BD 03 01   LDA $0103,X
A3A2   85 4A      STA $4A
A3A4   DD 03 01   CMP $0103,X
A3A7   D0 07      BNE $A3B0
A3A9   A5 49      LDA $49
A3AB   DD 02 01   CMP $0102,X
A3AE   F0 07      BEQ $A3B7
A3B0   8A         TXA
A3B1   18         CLC
A3B2   69 12      ADC #$12
A3B4   AA         TAX
A3B5   D0 D8      BNE $A38F
A3B7   60         RTS

; 'move bytes' nach dem Test auf Leerzeichen

A3B8   20 08 A4   JSR $A408
A3BB   85 31      STA $31
A3BD   84 32      STY $32

; 'move bytes'-Routine
;    $5F/$60 Startadresse der Quelldaten (Source)
;    $5A/$5B Endadresse der Quelldaten   (Source)
;    $58/$59 Endadresse der Zieldaten    (Destination)

A3BF   38         SEC
A3C0   A5 5A      LDA $5A
A3C2   E5 5F      SBC $5F
A3C4   85 22      STA $22
A3C6   A8         TAY
A3C7   A5 5B      LDA $5B
A3C9   E5 60      SBC $60
A3CB   AA         TAX
A3CC   E8         INX
A3CD   98         TYA
A3CE   F0 23      BEQ $A3F3
A3D0   A5 5A      LDA $5A
A3D2   38         SEC
A3D3   E5 22      SBC $22
A3D5   85 5A      STA $5A
A3D7   B0 03      BCS $A3DC
A3D9   C6 5B      DEC $5B
A3DB   38         SEC
A3DC   A5 58      LDA $58
A3DE   E5 22      SBC $22
A3E0   85 58      STA $58
A3E2   B0 08      BCS $A3EC
A3E4   C6 59      DEC $59
A3E6   90 04      BCC $A3EC
A3E8   B1 5A      LDA ($5A),Y
A3EA   91 58      STA ($58),Y
A3EC   88         DEY
A3ED   D0 F9      BNE $A3E8
A3EF   B1 5A      LDA ($5A),Y
A3F1   91 58      STA ($58),Y
A3F3   C6 5B      DEC $5B
A3F5   C6 59      DEC $59
A3F7   CA         DEX
A3F8   D0 F2      BNE $A3EC
A3FA   60         RTS

; Überprüft, ob 2*a Bytes am Stack frei sind

A3FB   0A         ASL
A3FC   69 3E      ADC #$3E
A3FE   B0 35      BCS $A435
A400   85 22      STA $22
A402   BA         TSX
A403   E4 22      CPX $22
A405   90 2E      BCC $A435
A407   60         RTS

; überprüft einen Array-Bereich auf überlauf

A408   C4 34      CPY $34
A40A   90 28      BCC $A434
A40C   D0 04      BNE $A412
A40E   C5 33      CMP $33
A410   90 22      BCC $A434
A412   48         PHA
A413   A2 09      LDX #$09
A415   98         TYA
A416   48         PHA
A417   B5 57      LDA $57,X
A419   CA         DEX
A41A   10 FA      BPL $A416
A41C   20 26 B5   JSR $B526
A41F   A2 F7      LDX #$F7
A421   68         PLA
A422   95 61      STA $61,X
A424   E8         INX
A425   30 FA      BMI $A421
A427   68         PLA
A428   A8         TAY
A429   68         PLA
A42A   C4 34      CPY $34
A42C   90 06      BCC $A434
A42E   D0 05      BNE $A435
A430   C5 33      CMP $33
A432   B0 01      BCS $A435
A434   60         RTS

; Fehlermeldungen: 'out of memory error'

A435   A2 10      LDX #$10      ; Nummer der Fehlermeldung

; Fehlermeldungen: handle error

A437   6C 00 03   JMP ($0300)   ; normal A43A

; standardmäßige Fehlermeldungsbehandlung

A43A   8A         TXA
A43B   0A         ASL
A43C   AA         TAX
A43D   BD 26 A3   LDA $A326,X
A440   85 22      STA $22
A442   BD 27 A3   LDA $A327,X
A445   85 23      STA $23
A447   20 CC FF   JSR $FFCC
A44A   A9 00      LDA #$00
A44C   85 13      STA $13
A44E   20 D7 AA   JSR $AAD7
A451   20 45 AB   JSR $AB45
A454   A0 00      LDY #$00
A456   B1 22      LDA ($22),Y
A458   48         PHA
A459   29 7F      AND #$7F
A45B   20 47 AB   JSR $AB47
A45E   C8         INY
A45F   68         PLA
A460   10 F4      BPL $A456
A462   20 7A A6   JSR $A67A
A465   A9 69      LDA #$69      ; low  A369
A467   A0 A3      LDY #$A3      ; high A369
A469   20 1E AB   JSR $AB1E
A46C   A4 3A      LDY $3A
A46E   C8         INY
A46F   F0 03      BEQ $A474
A471   20 C2 BD   JSR $BDC2
A474   A9 76      LDA #$76      ; low A376
A476   A0 A3      LDY #$A3      ; low A376
A478   20 1E AB   JSR $AB1E
A47B   A9 80      LDA #$80
A47D   20 90 FF   JSR $FF90
A480   6C 02 03   JMP ($0302)   ; normal A483

; standardmäßige Warmstart-Routine

A483   20 60 A5   JSR $A560
A486   86 7A      STX $7A
A488   84 7B      STY $7B
A48A   20 73 00   JSR $0073
A48D   AA         TAX
A48E   F0 F0      BEQ $A480
A490   A2 FF      LDX #$FF
A492   86 3A      STX $3A
A494   90 06      BCC $A49C
A496   20 79 A5   JSR $A579
A499   4C E1 A7   JMP $A7E1

; Handler für das Einfügen oder Löschen von Basic-Zeilen

A49C   20 6B A9   JSR $A96B
A49F   20 79 A5   JSR $A579
A4A2   84 0B      STY $0B
A4A4   20 13 A6   JSR $A613
A4A7   90 44      BCC $A4ED

; alte Zeilen löschen

A4A9   A0 01      LDY #$01
A4AB   B1 5F      LDA ($5F),Y
A4AD   85 23      STA $23
A4AF   A5 2D      LDA $2D
A4B1   85 22      STA $22
A4B3   A5 60      LDA $60
A4B5   85 25      STA $25
A4B7   A5 5F      LDA $5F
A4B9   88         DEY
A4BA   F1 5F      SBC ($5F),Y
A4BC   18         CLC
A4BD   65 2D      ADC $2D
A4BF   85 2D      STA $2D
A4C1   85 24      STA $24
A4C3   A5 2E      LDA $2E
A4C5   69 FF      ADC #$FF
A4C7   85 2E      STA $2E
A4C9   E5 60      SBC $60
A4CB   AA         TAX
A4CC   38         SEC
A4CD   A5 5F      LDA $5F
A4CF   E5 2D      SBC $2D
A4D1   A8         TAY
A4D2   B0 03      BCS $A4D7
A4D4   E8         INX
A4D5   C6 25      DEC $25
A4D7   18         CLC
A4D8   65 22      ADC $22
A4DA   90 03      BCC $A4DF
A4DC   C6 23      DEC $23
A4DE   18         CLC
A4DF   B1 22      LDA ($22),Y
A4E1   91 24      STA ($24),Y
A4E3   C8         INY
A4E4   D0 F9      BNE $A4DF
A4E6   E6 23      INC $23
A4E8   E6 25      INC $25
A4EA   CA         DEX
A4EB   D0 F2      BNE $A4DF

; Neue Zeile einfügen

A4ED   20 59 A6   JSR $A659
A4F0   20 33 A5   JSR $A533
A4F3   AD 00 02   LDA $0200
A4F6   F0 88      BEQ $A480
A4F8   18         CLC
A4F9   A5 2D      LDA $2D
A4FB   85 5A      STA $5A
A4FD   65 0B      ADC $0B
A4FF   85 58      STA $58
A501   A4 2E      LDY $2E
A503   84 5B      STY $5B
A505   90 01      BCC $A508
A507   C8         INY
A508   84 59      STY $59
A50A   20 B8 A3   JSR $A3B8
A50D   A5 14      LDA $14
A50F   A4 15      LDY $15
A511   8D FE 01   STA $01FE
A514   8C FF 01   STY $01FF
A517   A5 31      LDA $31
A519   A4 32      LDY $32
A51B   85 2D      STA $2D
A51D   84 2E      STY $2E
A51F   A4 0B      LDY $0B
A521   88         DEY
A522   B9 FC 01   LDA $01FC,Y
A525   91 5F      STA ($5F),Y
A527   88         DEY
A528   10 F8      BPL $A522
A52A   20 59 A6   JSR $A659
A52D   20 33 A5   JSR $A533
A530   4C 80 A4   JMP $A480

; Relink Basicprogramm

A533   A5 2B      LDA $2B
A535   A4 2C      LDY $2C
A537   85 22      STA $22
A539   84 23      STY $23
A53B   18         CLC
A53C   A0 01      LDY #$01
A53E   B1 22      LDA ($22),Y
A540   F0 1D      BEQ $A55F
A542   A0 04      LDY #$04
A544   C8         INY
A545   B1 22      LDA ($22),Y
A547   D0 FB      BNE $A544
A549   C8         INY
A54A   98         TYA
A54B   65 22      ADC $22
A54D   AA         TAX
A54E   A0 00      LDY #$00
A550   91 22      STA ($22),Y
A552   A5 23      LDA $23
A554   69 00      ADC #$00
A556   C8         INY
A557   91 22      STA ($22),Y
A559   86 22      STX $22
A55B   85 23      STA $23
A55D   90 DD      BCC $A53C
A55F   60         RTS

; Statement in den Puffer schreiben

A560   A2 00      LDX #$00
A562   20 12 E1   JSR $E112
A565   C9 0D      CMP #$0D
A567   F0 0D      BEQ $A576
A569   9D 00 02   STA $0200,X
A56C   E8         INX
A56D   E0 59      CPX #$59
A56F   90 F1      BCC $A562
A571   A2 17      LDX #$17      ; Nummer der Fehlermeldung
A573   4C 37 A4   JMP $A437
A576   4C CA AA   JMP $AACA     ; an das Ende der Zeile gehen


; crunch tokens

A579   6C 04 03   JMP ($0304)   ; normal A57C

; standardmäßiger token cruncher

A57C   A6 7A      LDX $7A
A57E   A0 04      LDY #$04
A580   84 0F      STY $0F
A582   BD 00 02   LDA $0200,X
A585   10 07      BPL $A58E
A587   C9 FF      CMP #$FF      ; PI
A589   F0 3E      BEQ $A5C9
A58B   E8         INX
A58C   D0 F4      BNE $A582
A58E   C9 20      CMP #$20      ; Leerzeichen
A590   F0 37      BEQ $A5C9
A592   85 08      STA $08
A594   C9 22      CMP #$22      ; Anführungszeichen
A596   F0 56      BEQ $A5EE
A598   24 0F      BIT $0F
A59A   70 2D      BVS $A5C9
A59C   C9 3F      CMP #$3F      ; Fragezeichen
A59E   D0 04      BNE $A5A4
A5A0   A9 99      LDA #$99      ; PRINT_Code
A5A2   D0 25      BNE $A5C9
A5A4   C9 30      CMP #$30      ; 0
A5A6   90 04      BCC $A5AC
A5A8   C9 3C      CMP #$3C
A5AA   90 1D      BCC $A5C9
A5AC   84 71      STY $71
A5AE   A0 00      LDY #$00
A5B0   84 0B      STY $0B
A5B2   88         DEY
A5B3   86 7A      STX $7A
A5B5   CA         DEX
A5B6   C8         INY
A5B7   E8         INX
A5B8   BD 00 02   LDA $0200,X
A5BB   38         SEC
A5BC   F9 9E A0   SBC $A09E,Y
A5BF   F0 F5      BEQ $A5B6
A5C1   C9 80      CMP #$80
A5C3   D0 30      BNE $A5F5
A5C5   05 0B      ORA $0B
A5C7   A4 71      LDY $71
A5C9   E8         INX
A5CA   C8         INY
A5CB   99 FB 01   STA $01FB,Y
A5CE   B9 FB 01   LDA $01FB,Y
A5D1   F0 36      BEQ $A609
A5D3   38         SEC
A5D4   E9 3A      SBC #$3A      ; Doppelpunkt
A5D6   F0 04      BEQ $A5DC
A5D8   C9 49      CMP #$49      ; DATA-Code
A5DA   D0 02      BNE $A5DE
A5DC   85 0F      STA $0F
A5DE   38         SEC
A5DF   E9 55      SBC #$55      ; REM-Code
A5E1   D0 9F      BNE $A582
A5E3   85 08      STA $08
A5E5   BD 00 02   LDA $0200,X
A5E8   F0 DF      BEQ $A5C9
A5EA   C5 08      CMP $08
A5EC   F0 DB      BEQ $A5C9
A5EE   C8         INY
A5EF   99 FB 01   STA $01FB,Y
A5F2   E8         INX
A5F3   D0 F0      BNE $A5E5
A5F5   A6 7A      LDX $7A
A5F7   E6 0B      INC $0B
A5F9   C8         INY
A5FA   B9 9D A0   LDA $A09D,Y
A5FD   10 FA      BPL $A5F9
A5FF   B9 9E A0   LDA $A09E,Y
A602   D0 B4      BNE $A5B8
A604   BD 00 02   LDA $0200,X
A607   10 BE      BPL $A5C7
A609   99 FD 01   STA $01FD,Y
A60C   C6 7B      DEC $7B
A60E   A9 FF      LDA #$FF
A610   85 7A      STA $7A
A612   60         RTS

; Suche im Programm nach einer Zeile

A613   A5 2B      LDA $2B
A615   A6 2C      LDX $2C
A617   A0 01      LDY #$01
A619   85 5F      STA $5F
A61B   86 60      STX $60
A61D   B1 5F      LDA ($5F),Y
A61F   F0 1F      BEQ $A640
A621   C8         INY
A622   C8         INY
A623   A5 15      LDA $15
A625   D1 5F      CMP ($5F),Y
A627   90 18      BCC $A641
A629   F0 03      BEQ $A62E
A62B   88         DEY
A62C   D0 09      BNE $A637
A62E   A5 14      LDA $14
A630   88         DEY
A631   D1 5F      CMP ($5F),Y
A633   90 0C      BCC $A641
A635   F0 0A      BEQ $A641
A637   88         DEY
A638   B1 5F      LDA ($5F),Y
A63A   AA         TAX
A63B   88         DEY
A63C   B1 5F      LDA ($5F),Y
A63E   B0 D7      BCS $A617
A640   18         CLC
A641   60         RTS

; NEW-Befehl

A642   D0 FD      BNE $A641
A644   A9 00      LDA #$00
A646   A8         TAY
A647   91 2B      STA ($2B),Y
A649   C8         INY
A64A   91 2B      STA ($2B),Y
A64C   A5 2B      LDA $2B
A64E   18         CLC
A64F   69 02      ADC #$02
A651   85 2D      STA $2D
A653   A5 2C      LDA $2C
A655   69 00      ADC #$00
A657   85 2E      STA $2E
A659   20 8E A6   JSR $A68E
A65C   A9 00      LDA #$00

; CLR-Befehl

A65E   D0 2D      BNE $A68D
A660   20 E7 FF   JSR $FFE7
A663   A5 37      LDA $37
A665   A4 38      LDY $38
A667   85 33      STA $33
A669   84 34      STY $34
A66B   A5 2D      LDA $2D
A66D   A4 2E      LDY $2E
A66F   85 2F      STA $2F
A671   84 30      STY $30
A673   85 31      STA $31
A675   84 32      STY $32
A677   20 1D A8   JSR $A81D

; Stack und Programmzeiger zurücksetzen (reset)

A67A   A2 19      LDX #$19
A67C   86 16      STX $16
A67E   68         PLA
A67F   A8         TAY
A680   68         PLA
A681   A2 FA      LDX #$FA
A683   9A         TXS
A684   48         PHA
A685   98         TYA
A686   48         PHA
A687   A9 00      LDA #$00
A689   85 3E      STA $3E
A68B   85 10      STA $10
A68D   60         RTS

; Setzt aktuellen Zeichenzeiger an den Anfang - 1

A68E   18         CLC
A68F   A5 2B      LDA $2B
A691   69 FF      ADC #$FF
A693   85 7A      STA $7A
A695   A5 2C      LDA $2C
A697   69 FF      ADC #$FF
A699   85 7B      STA $7B
A69B   60         RTS

; LIST-Befehl

A69C   90 06      BCC $A6A4
A69E   F0 04      BEQ $A6A4
A6A0   C9 AB      CMP #$AB
A6A2   D0 E9      BNE $A68D
A6A4   20 6B A9   JSR $A96B
A6A7   20 13 A6   JSR $A613
A6AA   20 79 00   JSR $0079
A6AD   F0 0C      BEQ $A6BB
A6AF   C9 AB      CMP #$AB
A6B1   D0 8E      BNE $A641
A6B3   20 73 00   JSR $0073
A6B6   20 6B A9   JSR $A96B
A6B9   D0 86      BNE $A641
A6BB   68         PLA
A6BC   68         PLA
A6BD   A5 14      LDA $14
A6BF   05 15      ORA $15
A6C1   D0 06      BNE $A6C9
A6C3   A9 FF      LDA #$FF
A6C5   85 14      STA $14
A6C7   85 15      STA $15

; Zeilen von $5F/$60 bis $14/$15 ausgeben

A6C9   A0 01      LDY #$01
A6CB   84 0F      STY $0F
A6CD   B1 5F      LDA ($5F),Y
A6CF   F0 43      BEQ $A714
A6D1   20 2C A8   JSR $A82C
A6D4   20 D7 AA   JSR $AAD7
A6D7   C8         INY
A6D8   B1 5F      LDA ($5F),Y
A6DA   AA         TAX
A6DB   C8         INY
A6DC   B1 5F      LDA ($5F),Y
A6DE   C5 15      CMP $15
A6E0   D0 04      BNE $A6E6
A6E2   E4 14      CPX $14
A6E4   F0 02      BEQ $A6E8
A6E6   B0 2C      BCS $A714
A6E8   84 49      STY $49
A6EA   20 CD BD   JSR $BDCD
A6ED   A9 20      LDA #$20
A6EF   A4 49      LDY $49
A6F1   29 7F      AND #$7F
A6F3   20 47 AB   JSR $AB47
A6F6   C9 22      CMP #$22
A6F8   D0 06      BNE $A700
A6FA   A5 0F      LDA $0F
A6FC   49 FF      EOR #$FF
A6FE   85 0F      STA $0F
A700   C8         INY
A701   F0 11      BEQ $A714
A703   B1 5F      LDA ($5F),Y
A705   D0 10      BNE $A717
A707   A8         TAY
A708   B1 5F      LDA ($5F),Y
A70A   AA         TAX
A70B   C8         INY
A70C   B1 5F      LDA ($5F),Y
A70E   86 5F      STX $5F
A710   85 60      STA $60
A712   D0 B5      BNE $A6C9
A714   4C 86 E3   JMP $E386

; Tokenroutine anzeigen

A717   6C 06 03   JMP ($0306)   ; normal A71A

; standardmäßiger 'Tokenprinter'

A71A   10 D7      BPL $A6F3
A71C   C9 FF      CMP #$FF
A71E   F0 D3      BEQ $A6F3
A720   24 0F      BIT $0F
A722   30 CF      BMI $A6F3
A724   38         SEC
A725   E9 7F      SBC #$7F
A727   AA         TAX
A728   84 49      STY $49
A72A   A0 FF      LDY #$FF
A72C   CA         DEX
A72D   F0 08      BEQ $A737
A72F   C8         INY
A730   B9 9E A0   LDA $A09E,Y
A733   10 FA      BPL $A72F
A735   30 F5      BMI $A72C

; Keyword anzeigen

A737   C8         INY
A738   B9 9E A0   LDA $A09E,Y
A73B   30 B2      BMI $A6EF
A73D   20 47 AB   JSR $AB47
A740   D0 F5      BNE $A737

; FOR-Befehl

A742   A9 80      LDA #$80
A744   85 10      STA $10
A746   20 A5 A9   JSR $A9A5
A749   20 8A A3   JSR $A38A
A74C   D0 05      BNE $A753
A74E   8A         TXA
A74F   69 0F      ADC #$0F
A751   AA         TAX
A752   9A         TXS
A753   68         PLA
A754   68         PLA
A755   A9 09      LDA #$09
A757   20 FB A3   JSR $A3FB
A75A   20 06 A9   JSR $A906
A75D   18         CLC
A75E   98         TYA
A75F   65 7A      ADC $7A
A761   48         PHA
A762   A5 7B      LDA $7B
A764   69 00      ADC #$00
A766   48         PHA
A767   A5 3A      LDA $3A
A769   48         PHA
A76A   A5 39      LDA $39
A76C   48         PHA
A76D   A9 A4      LDA #$A4
A76F   20 FF AE   JSR $AEFF
A772   20 8D AD   JSR $AD8D
A775   20 8A AD   JSR $AD8A
A778   A5 66      LDA $66
A77A   09 7F      ORA #$7F
A77C   25 62      AND $62
A77E   85 62      STA $62
A780   A9 8B      LDA #$8B      ; low  A78B
A782   A0 A7      LDY #$A7      ; high A78B
A784   85 22      STA $22
A786   84 23      STY $23
A788   4C 43 AE   JMP $AE43
A78B   A9 BC      LDA #$BC      ; low  B9BC
A78D   A0 B9      LDY #$B9      ; high B9BC
A78F   20 A2 BB   JSR $BBA2
A792   20 79 00   JSR $0079
A795   C9 A9      CMP #$A9
A797   D0 06      BNE $A79F
A799   20 73 00   JSR $0073
A79C   20 8A AD   JSR $AD8A
A79F   20 2B BC   JSR $BC2B
A7A2   20 38 AE   JSR $AE38
A7A5   A5 4A      LDA $4A
A7A7   48         PHA
A7A8   A5 49      LDA $49
A7AA   48         PHA
A7AB   A9 81      LDA #$81   ; FOR-Blockcode
A7AD   48         PHA

; nächstes Statement ausführen

A7AE   20 2C A8   JSR $A82C
A7B1   A5 7A      LDA $7A
A7B3   A4 7B      LDY $7B
A7B5   C0 02      CPY #$02
A7B7   EA         NOP
A7B8   F0 04      BEQ $A7BE
A7BA   85 3D      STA $3D
A7BC   84 3E      STY $3E
A7BE   A0 00      LDY #$00
A7C0   B1 7A      LDA ($7A),Y
A7C2   D0 43      BNE $A807
A7C4   A0 02      LDY #$02
A7C6   B1 7A      LDA ($7A),Y
A7C8   18         CLC
A7C9   D0 03      BNE $A7CE
A7CB   4C 4B A8   JMP $A84B
A7CE   C8         INY
A7CF   B1 7A      LDA ($7A),Y
A7D1   85 39      STA $39
A7D3   C8         INY
A7D4   B1 7A      LDA ($7A),Y
A7D6   85 3A      STA $3A
A7D8   98         TYA
A7D9   65 7A      ADC $7A
A7DB   85 7A      STA $7A
A7DD   90 02      BCC $A7E1
A7DF   E6 7B      INC $7B
A7E1   6C 08 03   JMP ($0308)   ; normal A7E4

; Statement ausführen

A7E4   20 73 00   JSR $0073
A7E7   20 ED A7   JSR $A7ED
A7EA   4C AE A7   JMP $A7AE

; Befehl in A ausführen

A7ED   F0 3C      BEQ $A82B
A7EF   E9 80      SBC #$80
A7F1   90 11      BCC $A804
A7F3   C9 23      CMP #$23
A7F5   B0 17      BCS $A80E
A7F7   0A         ASL
A7F8   A8         TAY
A7F9   B9 0D A0   LDA $A00D,Y
A7FC   48         PHA
A7FD   B9 0C A0   LDA $A00C,Y
A800   48         PHA
A801   4C 73 00   JMP $0073
A804   4C A5 A9   JMP $A9A5
A807   C9 3A      CMP #$3A      ; Doppelpunkt
A809   F0 D6      BEQ $A7E1
A80B   4C 08 AF   JMP $AF08
A80E   C9 4B      CMP #$4B      ; GO-Code
A810   D0 F9      BNE $A80B
A812   20 73 00   JSR $0073
A815   A9 A4      LDA #$A4      ; TO-Code
A817   20 FF AE   JSR $AEFF
A81A   4C A0 A8   JMP $A8A0     ; GOTO ausführen

; RESTOREBefehl

A81D   38         SEC
A81E   A5 2B      LDA $2B
A820   E9 01      SBC #$01
A822   A4 2C      LDY $2C
A824   B0 01      BCS $A827
A826   88         DEY
A827   85 41      STA $41
A829   84 42      STY $42
A82B   60         RTS
A82C   20 E1 FF   JSR $FFE1     ; überprüft 'stop'-Taste

; STOP-Befehl

A82F   B0 01      BCS $A832

; END-Befehl

A831   18         CLC
A832   D0 3C      BNE $A870
A834   A5 7A      LDA $7A
A836   A4 7B      LDY $7B
A838   A6 3A      LDX $3A
A83A   E8         INX
A83B   F0 0C      BEQ $A849
A83D   85 3D      STA $3D
A83F   84 3E      STY $3E
A841   A5 39      LDA $39
A843   A4 3A      LDY $3A
A845   85 3B      STA $3B
A847   84 3C      STY $3C
A849   68         PLA
A84A   68         PLA
A84B   A9 81      LDA #$81      ; low  A381
A84D   A0 A3      LDY #$A3      ; high A381
A84F   90 03      BCC $A854
A851   4C 69 A4   JMP $A469
A854   4C 86 E3   JMP $E386

; CONT-Befehl

A857   D0 17      BNE $A870
A859   A2 1A      LDX #$1A      ; Fehlernummer
A85B   A4 3E      LDY $3E
A85D   D0 03      BNE $A862
A85F   4C 37 A4   JMP $A437
A862   A5 3D      LDA $3D
A864   85 7A      STA $7A
A866   84 7B      STY $7B
A868   A5 3B      LDA $3B
A86A   A4 3C      LDY $3C
A86C   85 39      STA $39
A86E   84 3A      STY $3A
A870   60         RTS

; RUN-Befehl

A871   08         PHP
A872   A9 00      LDA #$00
A874   20 90 FF   JSR $FF90
A877   28         PLP
A878   D0 03      BNE $A87D
A87A   4C 59 A6   JMP $A659
A87D   20 60 A6   JSR $A660     ; CLR ausführen
A880   4C 97 A8   JMP $A897     ; GOTO ausführen

; GOSUB-Befehl

A883   A9 03      LDA #$03
A885   20 FB A3   JSR $A3FB
A888   A5 7B      LDA $7B
A88A   48         PHA
A88B   A5 7A      LDA $7A
A88D   48         PHA
A88E   A5 3A      LDA $3A
A890   48         PHA
A891   A5 39      LDA $39
A893   48         PHA
A894   A9 8D      LDA #$8D
A896   48         PHA
A897   20 79 00   JSR $0079
A89A   20 A0 A8   JSR $A8A0
A89D   4C AE A7   JMP $A7AE

; GOTO-Befehl

A8A0   20 6B A9   JSR $A96B
A8A3   20 09 A9   JSR $A909
A8A6   38         SEC
A8A7   A5 39      LDA $39
A8A9   E5 14      SBC $14
A8AB   A5 3A      LDA $3A
A8AD   E5 15      SBC $15
A8AF   B0 0B      BCS $A8BC
A8B1   98         TYA
A8B2   38         SEC
A8B3   65 7A      ADC $7A
A8B5   A6 7B      LDX $7B
A8B7   90 07      BCC $A8C0
A8B9   E8         INX
A8BA   B0 04      BCS $A8C0
A8BC   A5 2B      LDA $2B
A8BE   A6 2C      LDX $2C
A8C0   20 17 A6   JSR $A617
A8C3   90 1E      BCC $A8E3
A8C5   A5 5F      LDA $5F
A8C7   E9 01      SBC #$01
A8C9   85 7A      STA $7A
A8CB   A5 60      LDA $60
A8CD   E9 00      SBC #$00
A8CF   85 7B      STA $7B
A8D1   60         RTS

; RETURN-Nefehl

A8D2   D0 FD      BNE $A8D1
A8D4   A9 FF      LDA #$FF
A8D6   85 4A      STA $4A
A8D8   20 8A A3   JSR $A38A
A8DB   9A         TXS
A8DC   C9 8D      CMP #$8D
A8DE   F0 0B      BEQ $A8EB
A8E0   A2 0C      LDX #$0C
A8E2   .BY $2C
A8E3   A2 11      LDX #$11
A8E5   4C 37 A4   JMP $A437
A8E8   4C 08 AF   JMP $AF08

; GOSUB-Block vom Stack entfernen

A8EB   68         PLA
A8EC   68         PLA
A8ED   85 39      STA $39
A8EF   68         PLA
A8F0   85 3A      STA $3A
A8F2   68         PLA
A8F3   85 7A      STA $7A
A8F5   68         PLA
A8F6   85 7B      STA $7B

; DATA-Befehl

A8F8   20 06 A9   JSR $A906
A8FB   98         TYA
A8FC   18         CLC
A8FD   65 7A      ADC $7A
A8FF   85 7A      STA $7A
A901   90 02      BCC $A905
A903   E6 7B      INC $7B
A905   60         RTS

; Ende des Statements holen

A906   A2 3A      LDX #$3A      ; Doppelpunkt
A908   .BY $2C

; Zeilenende holen

A909   A2 00      LDX #$00
A90B   86 07      STX $07
A90D   A0 00      LDY #$00
A90F   84 08      STY $08
A911   A5 08      LDA $08
A913   A6 07      LDX $07
A915   85 07      STA $07
A917   86 08      STX $08
A919   B1 7A      LDA ($7A),Y
A91B   F0 E8      BEQ $A905
A91D   C5 08      CMP $08
A91F   F0 E4      BEQ $A905
A921   C8         INY
A922   C9 22      CMP #$22      ; Anführungszeichen
A924   D0 F3      BNE $A919
A926   F0 E9      BEQ $A911

; IF-Befehl

A928   20 9E AD   JSR $AD9E
A92B   20 79 00   JSR $0079
A92E   C9 89      CMP #$89
A930   F0 05      BEQ $A937
A932   A9 A7      LDA #$A7
A934   20 FF AE   JSR $AEFF
A937   A5 61      LDA $61
A939   D0 05      BNE $A940

; REM-Befehl

A93B   20 09 A9   JSR $A909
A93E   F0 BB      BEQ $A8FB

; THEN-Teil von IF

A940   20 79 00   JSR $0079
A943   B0 03      BCS $A948
A945   4C A0 A8   JMP $A8A0     ; GOTO ausführen
A948   4C ED A7   JMP $A7ED

; ON-Befehl

A94B   20 9E B7   JSR $B79E
A94E   48         PHA
A94F   C9 8D      CMP #$8D      ; GOSUB-Befehlscode
A951   F0 04      BEQ $A957
A953   C9 89      CMP #$89      ; GOTO-Befehlscode
A955   D0 91      BNE $A8E8
A957   C6 65      DEC $65
A959   D0 04      BNE $A95F
A95B   68         PLA
A95C   4C EF A7   JMP $A7EF
A95F   20 73 00   JSR $0073
A962   20 6B A9   JSR $A96B
A965   C9 2C      CMP #$2C      ; Kommer
A967   F0 EE      BEQ $A957
A969   68         PLA
A96A   60         RTS

; dezimale Zahl in $14/$15 schreiben

A96B   A2 00      LDX #$00
A96D   86 14      STX $14
A96F   86 15      STX $15
A971   B0 F7      BCS $A96A
A973   E9 2F      SBC #$2F
A975   85 07      STA $07
A977   A5 15      LDA $15
A979   85 22      STA $22
A97B   C9 19      CMP #$19
A97D   B0 D4      BCS $A953
A97F   A5 14      LDA $14
A981   0A         ASL           ; Mal 2
A982   26 22      ROL $22
A984   0A         ASL           ; Mal 2
A985   26 22      ROL $22
A987   65 14      ADC $14       ; original addieren
A989   85 14      STA $14
A98B   A5 22      LDA $22
A98D   65 15      ADC $15
A98F   85 15      STA $15
A991   06 14      ASL $14       ; Mal 2
A993   26 15      ROL $15       ; = Mal 10 (zusammen)
A995   A5 14      LDA $14
A997   65 07      ADC $07
A999   85 14      STA $14
A99B   90 02      BCC $A99F
A99D   E6 15      INC $15
A99F   20 73 00   JSR $0073
A9A2   4C 71 A9   JMP $A971

; LET-Befehl

A9A5   20 8B B0   JSR $B08B
A9A8   85 49      STA $49
A9AA   84 4A      STY $4A
A9AC   A9 B2      LDA #$B2      ; 'gleich'-Code
A9AE   20 FF AE   JSR $AEFF
A9B1   A5 0E      LDA $0E
A9B3   48         PHA
A9B4   A5 0D      LDA $0D
A9B6   48         PHA
A9B7   20 9E AD   JSR $AD9E
A9BA   68         PLA
A9BB   2A         ROL
A9BC   20 90 AD   JSR $AD90
A9BF   D0 18      BNE $A9D9
A9C1   68         PLA
A9C2   10 12      BPL $A9D6

; einem Integer zuordnen

A9C4   20 1B BC   JSR $BC1B
A9C7   20 BF B1   JSR $B1BF
A9CA   A0 00      LDY #$00
A9CC   A5 64      LDA $64
A9CE   91 49      STA ($49),Y
A9D0   C8         INY
A9D1   A5 65      LDA $65
A9D3   91 49      STA ($49),Y
A9D5   60         RTS

; einem Float zuordnen

A9D6   4C D0 BB   JMP $BBD0

; einem String zuordnen

A9D9   68         PLA
A9DA   A4 4A      LDY $4A
A9DC   C0 BF      CPY #$BF
A9DE   D0 4C      BNE $AA2C

; TI$ zuordnen

A9E0   20 A6 B6   JSR $B6A6
A9E3   C9 06      CMP #$06      ; Länge 6
A9E5   D0 3D      BNE $AA24
A9E7   A0 00      LDY #$00
A9E9   84 61      STY $61
A9EB   84 66      STY $66
A9ED   84 71      STY $71
A9EF   20 1D AA   JSR $AA1D
A9F2   20 E2 BA   JSR $BAE2
A9F5   E6 71      INC $71
A9F7   A4 71      LDY $71
A9F9   20 1D AA   JSR $AA1D
A9FC   20 0C BC   JSR $BC0C
A9FF   AA         TAX
AA00   F0 05      BEQ $AA07
AA02   E8         INX
AA03   8A         TXA
AA04   20 ED BA   JSR $BAED
AA07   A4 71      LDY $71
AA09   C8         INY
AA0A   C0 06      CPY #$06
AA0C   D0 DF      BNE $A9ED
AA0E   20 E2 BA   JSR $BAE2
AA11   20 9B BC   JSR $BC9B
AA14   A6 64      LDX $64
AA16   A4 63      LDY $63
AA18   A5 65      LDA $65
AA1A   4C DB FF   JMP $FFDB

; nächstes Digit zu Float addieren

AA1D   B1 22      LDA ($22),Y
AA1F   20 80 00   JSR $0080
AA22   90 03      BCC $AA27
AA24   4C 48 B2   JMP $B248
AA27   E9 2F      SBC #$2F
AA29   4C 7E BD   JMP $BD7E

; einer Stringvariable zuordnen

AA2C   A0 02      LDY #$02
AA2E   B1 64      LDA ($64),Y
AA30   C5 34      CMP $34
AA32   90 17      BCC $AA4B
AA34   D0 07      BNE $AA3D
AA36   88         DEY
AA37   B1 64      LDA ($64),Y
AA39   C5 33      CMP $33
AA3B   90 0E      BCC $AA4B
AA3D   A4 65      LDY $65
AA3F   C4 2E      CPY $2E
AA41   90 08      BCC $AA4B
AA43   D0 0D      BNE $AA52
AA45   A5 64      LDA $64
AA47   C5 2D      CMP $2D
AA49   B0 07      BCS $AA52
AA4B   A5 64      LDA $64
AA4D   A4 65      LDY $65
AA4F   4C 68 AA   JMP $AA68
AA52   A0 00      LDY #$00
AA54   B1 64      LDA ($64),Y
AA56   20 75 B4   JSR $B475
AA59   A5 50      LDA $50
AA5B   A4 51      LDY $51
AA5D   85 6F      STA $6F
AA5F   84 70      STY $70
AA61   20 7A B6   JSR $B67A
AA64   A9 61      LDA #$61      ; low  0061
AA66   A0 00      LDY #$00      ; high 0061

; Descriptor in Variable schreiben

AA68   85 50      STA $50
AA6A   84 51      STY $51
AA6C   20 DB B6   JSR $B6DB
AA6F   A0 00      LDY #$00
AA71   B1 50      LDA ($50),Y
AA73   91 49      STA ($49),Y
AA75   C8         INY
AA76   B1 50      LDA ($50),Y
AA78   91 49      STA ($49),Y
AA7A   C8         INY
AA7B   B1 50      LDA ($50),Y
AA7D   91 49      STA ($49),Y
AA7F   60         RTS

; PRINT#-Befehl

AA80   20 86 AA   JSR $AA86
AA83   4C B5 AB   JMP $ABB5

; CMD-Befehl

AA86   20 9E B7   JSR $B79E
AA89   F0 05      BEQ $AA90
AA8B   A9 2C      LDA #$2C      ; Kommer
AA8D   20 FF AE   JSR $AEFF
AA90   08         PHP
AA91   86 13      STX $13
AA93   20 18 E1   JSR $E118
AA96   28         PLP
AA97   4C A0 AA   JMP $AAA0     ; PRINT ausführen
AA9A   20 21 AB   JSR $AB21
AA9D   20 79 00   JSR $0079

; PRINT-Befehl

AAA0   F0 35      BEQ $AAD7
AAA2   F0 43      BEQ $AAE7
AAA4   C9 A3      CMP #$A3      ; 'TAB('-Code
AAA6   F0 50      BEQ $AAF8
AAA8   C9 A6      CMP #$A6      ; 'SPC('-Code
AAAA   18         CLC
AAAB   F0 4B      BEQ $AAF8
AAAD   C9 2C      CMP #$2C      ; Kommer
AAAF   F0 37      BEQ $AAE8
AAB1   C9 3B      CMP #$3B      ; Srichpunkt
AAB3   F0 5E      BEQ $AB13
AAB5   20 9E AD   JSR $AD9E
AAB8   24 0D      BIT $0D
AABA   30 DE      BMI $AA9A
AABC   20 DD BD   JSR $BDDD
AABF   20 87 B4   JSR $B487
AAC2   20 21 AB   JSR $AB21
AAC5   20 3B AB   JSR $AB3B
AAC8   D0 D3      BNE $AA9D

; letztes Statement in Puffer und Bildschirm

AACA   A9 00      LDA #$00
AACC   9D 00 02   STA $0200,X
AACF   A2 FF      LDX #$FF
AAD1   A0 01      LDY #$01
AAD3   A5 13      LDA $13
AAD5   D0 10      BNE $AAE7

; letzte Zeile auf CMD output file

AAD7   A9 0D      LDA #$0D
AAD9   20 47 AB   JSR $AB47
AADC   24 13      BIT $13
AADE   10 05      BPL $AAE5
AAE0   A9 0A      LDA #$0A
AAE2   20 47 AB   JSR $AB47
AAE5   49 FF      EOR #$FF
AAE7   60         RTS

; Routine für die Ausgabe von 'TAB(' und 'SPC('

AAE8   38         SEC
AAE9   20 F0 FF   JSR $FFF0
AAEC   98         TYA
AAED   38         SEC
AAEE   E9 0A      SBC #$0A
AAF0   B0 FC      BCS $AAEE
AAF2   49 FF      EOR #$FF
AAF4   69 01      ADC #$01
AAF6   D0 16      BNE $AB0E
AAF8   08         PHP
AAF9   38         SEC
AAFA   20 F0 FF   JSR $FFF0
AAFD   84 09      STY $09
AAFF   20 9B B7   JSR $B79B
AB02   C9 29      CMP #$29      ; )
AB04   D0 59      BNE $AB5F
AB06   28         PLP
AB07   90 06      BCC $AB0F
AB09   8A         TXA
AB0A   E5 09      SBC $09
AB0C   90 05      BCC $AB13
AB0E   AA         TAX
AB0F   E8         INX
AB10   CA         DEX
AB11   D0 06      BNE $AB19
AB13   20 73 00   JSR $0073
AB16   4C A2 AA   JMP $AAA2
AB19   20 3B AB   JSR $AB3B
AB1C   D0 F2      BNE $AB10

; String von AY ausgeben

AB1E   20 87 B4   JSR $B487

; String von $22/$23 ausgaben

AB21   20 A6 B6   JSR $B6A6
AB24   AA         TAX
AB25   A0 00      LDY #$00
AB27   E8         INX
AB28   CA         DEX
AB29   F0 BC      BEQ $AAE7
AB2B   B1 22      LDA ($22),Y
AB2D   20 47 AB   JSR $AB47
AB30   C8         INY
AB31   C9 0D      CMP #$0D
AB33   D0 F3      BNE $AB28
AB35   20 E5 AA   JSR $AAE5
AB38   4C 28 AB   JMP $AB28

; Zeichen aif CMD output file ausgeben

AB3B   A5 13      LDA $13
AB3D   F0 03      BEQ $AB42
AB3F   A9 20      LDA #$20      ; Leerzeichen
AB41   .BY $2C
AB42   A9 1D      LDA #$1D      ; Cursor rechts
AB44   .BY $2C
AB45   A9 3F      LDA #$3F      ; Fragezeichen
AB47   20 0C E1   JSR $E10C
AB4A   29 FF      AND #$FF
AB4C   60         RTS

; Fehler lesen

AB4D   A5 11      LDA $11
AB4F   F0 11      BEQ $AB62
AB51   30 04      BMI $AB57
AB53   A0 FF      LDY #$FF
AB55   D0 04      BNE $AB5B
AB57   A5 3F      LDA $3F
AB59   A4 40      LDY $40
AB5B   85 39      STA $39
AB5D   84 3A      STY $3A
AB5F   4C 08 AF   JMP $AF08
AB62   A5 13      LDA $13
AB64   F0 05      BEQ $AB6B
AB66   A2 18      LDX #$18
AB68   4C 37 A4   JMP $A437
AB6B   A9 0C      LDA #$0C      ; low  AD0C
AB6D   A0 AD      LDY #$AD      ; high AD0C
AB6F   20 1E AB   JSR $AB1E
AB72   A5 3D      LDA $3D
AB74   A4 3E      LDY $3E
AB76   85 7A      STA $7A
AB78   84 7B      STY $7B
AB7A   60         RTS

; GET-Befehl

AB7B   20 A6 B3   JSR $B3A6
AB7E   C9 23      CMP #$23      ; #
AB80   D0 10      BNE $AB92
AB82   20 73 00   JSR $0073
AB85   20 9E B7   JSR $B79E
AB88   A9 2C      LDA #$2C      ; Kommer
AB8A   20 FF AE   JSR $AEFF
AB8D   86 13      STX $13
AB8F   20 1E E1   JSR $E11E
AB92   A2 01      LDX #$01
AB94   A0 02      LDY #$02
AB96   A9 00      LDA #$00
AB98   8D 01 02   STA $0201
AB9B   A9 40      LDA #$40      ; GET-Befehlscode
AB9D   20 0F AC   JSR $AC0F
ABA0   A6 13      LDX $13
ABA2   D0 13      BNE $ABB7
ABA4   60         RTS

; INPUT#-Befehl

ABA5   20 9E B7   JSR $B79E
ABA8   A9 2C      LDA #$2C      ; Kommer
ABAA   20 FF AE   JSR $AEFF
ABAD   86 13      STX $13
ABAF   20 1E E1   JSR $E11E
ABB2   20 CE AB   JSR $ABCE
ABB5   A5 13      LDA $13
ABB7   20 CC FF   JSR $FFCC
ABBA   A2 00      LDX #$00
ABBC   86 13      STX $13
ABBE   60         RTS

; INPUT-Befehl

ABBF   C9 22      CMP #$22      ; Anführungszeichen
ABC1   D0 0B      BNE $ABCE
ABC3   20 BD AE   JSR $AEBD
ABC6   A9 3B      LDA #$3B      ; Srichpunkt
ABC8   20 FF AE   JSR $AEFF
ABCB   20 21 AB   JSR $AB21
ABCE   20 A6 B3   JSR $B3A6
ABD1   A9 2C      LDA #$2C      ; Kommer
ABD3   8D FF 01   STA $01FF
ABD6   20 F9 AB   JSR $ABF9
ABD9   A5 13      LDA $13
ABDB   F0 0D      BEQ $ABEA
ABDD   20 B7 FF   JSR $FFB7
ABE0   29 02      AND #$02
ABE2   F0 06      BEQ $ABEA
ABE4   20 B5 AB   JSR $ABB5
ABE7   4C F8 A8   JMP $A8F8     ; DATA ausführen
ABEA   AD 00 02   LDA $0200
ABED   D0 1E      BNE $AC0D
ABEF   A5 13      LDA $13
ABF1   D0 E3      BNE $ABD6
ABF3   20 06 A9   JSR $A906
ABF6   4C FB A8   JMP $A8FB

; Zeile in Eingabepuffer

ABF9   A5 13      LDA $13
ABFB   D0 06      BNE $AC03
ABFD   20 45 AB   JSR $AB45
AC00   20 3B AB   JSR $AB3B
AC03   4C 60 A5   JMP $A560

; READ-Befehl

AC06   A6 41      LDX $41
AC08   A4 42      LDY $42
AC0A   A9 98      LDA #$98      ; READ-Befehlscode
AC0C   .BY $2C
AC0D   A9 00      LDA #$00
AC0F   85 11      STA $11
AC11   86 43      STX $43
AC13   84 44      STY $44
AC15   20 8B B0   JSR $B08B
AC18   85 49      STA $49
AC1A   84 4A      STY $4A
AC1C   A5 7A      LDA $7A
AC1E   A4 7B      LDY $7B
AC20   85 4B      STA $4B
AC22   84 4C      STY $4C
AC24   A6 43      LDX $43
AC26   A4 44      LDY $44
AC28   86 7A      STX $7A
AC2A   84 7B      STY $7B
AC2C   20 79 00   JSR $0079
AC2F   D0 20      BNE $AC51
AC31   24 11      BIT $11
AC33   50 0C      BVC $AC41
AC35   20 24 E1   JSR $E124
AC38   8D 00 02   STA $0200
AC3B   A2 FF      LDX #$FF
AC3D   A0 01      LDY #$01
AC3F   D0 0C      BNE $AC4D
AC41   30 75      BMI $ACB8
AC43   A5 13      LDA $13
AC45   D0 03      BNE $AC4A
AC47   20 45 AB   JSR $AB45
AC4A   20 F9 AB   JSR $ABF9
AC4D   86 7A      STX $7A
AC4F   84 7B      STY $7B
AC51   20 73 00   JSR $0073
AC54   24 0D      BIT $0D
AC56   10 31      BPL $AC89
AC58   24 11      BIT $11
AC5A   50 09      BVC $AC65
AC5C   E8         INX
AC5D   86 7A      STX $7A
AC5F   A9 00      LDA #$00
AC61   85 07      STA $07
AC63   F0 0C      BEQ $AC71
AC65   85 07      STA $07
AC67   C9 22      CMP #$22      ; Anführungszeichen
AC69   F0 07      BEQ $AC72
AC6B   A9 3A      LDA #$3A      ; Doppelpunkt
AC6D   85 07      STA $07
AC6F   A9 2C      LDA #$2C      ; Kommer
AC71   18         CLC
AC72   85 08      STA $08
AC74   A5 7A      LDA $7A
AC76   A4 7B      LDY $7B
AC78   69 00      ADC #$00
AC7A   90 01      BCC $AC7D
AC7C   C8         INY
AC7D   20 8D B4   JSR $B48D
AC80   20 E2 B7   JSR $B7E2
AC83   20 DA A9   JSR $A9DA
AC86   4C 91 AC   JMP $AC91
AC89   20 F3 BC   JSR $BCF3
AC8C   A5 0E      LDA $0E
AC8E   20 C2 A9   JSR $A9C2
AC91   20 79 00   JSR $0079
AC94   F0 07      BEQ $AC9D
AC96   C9 2C      CMP #$2C      ; Kommer
AC98   F0 03      BEQ $AC9D
AC9A   4C 4D AB   JMP $AB4D
AC9D   A5 7A      LDA $7A
AC9F   A4 7B      LDY $7B
ACA1   85 43      STA $43
ACA3   84 44      STY $44
ACA5   A5 4B      LDA $4B
ACA7   A4 4C      LDY $4C
ACA9   85 7A      STA $7A
ACAB   84 7B      STY $7B
ACAD   20 79 00   JSR $0079
ACB0   F0 2D      BEQ $ACDF
ACB2   20 FD AE   JSR $AEFD
ACB5   4C 15 AC   JMP $AC15
ACB8   20 06 A9   JSR $A906
ACBB   C8         INY
ACBC   AA         TAX
ACBD   D0 12      BNE $ACD1
ACBF   A2 0D      LDX #$0D      ; Fehlermeldung
ACC1   C8         INY
ACC2   B1 7A      LDA ($7A),Y
ACC4   F0 6C      BEQ $AD32
ACC6   C8         INY
ACC7   B1 7A      LDA ($7A),Y
ACC9   85 3F      STA $3F
ACCB   C8         INY
ACCC   B1 7A      LDA ($7A),Y
ACCE   C8         INY
ACCF   85 40      STA $40
ACD1   20 FB A8   JSR $A8FB
ACD4   20 79 00   JSR $0079
ACD7   AA         TAX
ACD8   E0 83      CPX #$83      ; DATA-Befehlscode
ACDA   D0 DC      BNE $ACB8
ACDC   4C 51 AC   JMP $AC51
ACDF   A5 43      LDA $43
ACE1   A4 44      LDY $44
ACE3   A6 11      LDX $11
ACE5   10 03      BPL $ACEA
ACE7   4C 27 A8   JMP $A827
ACEA   A0 00      LDY #$00
ACEC   B1 43      LDA ($43),Y
ACEE   F0 0B      BEQ $ACFB
ACF0   A5 13      LDA $13
ACF2   D0 07      BNE $ACFB
ACF4   A9 FC      LDA #$FC      ; low  ACFC
ACF6   A0 AC      LDY #$AC      ; high ACFC
ACF8   4C 1E AB   JMP $AB1E
ACFB   60         RTS

; Meldungen während der Verwendung von READ

; „?EXTRA IGNORED”

ACFC   .BY $3F,$45,$58,$54,$52,$41
AD02   .BY $20,$49,$47,$4E,$4F,$52,$45,$44
AD0A   .BY $0D,$00

; „?REDO FROM START”

AD0C   .BY $3F,$52,$45,$44,$4F
AD11   .BY $20,$46,$52,$4F,$4D
AD16   .BY $20,$53,$54,$41,$52,$54
AD1C   .BY $0D,$00

; NEXT-Befehl

AD1E   D0 04      BNE $AD24
AD20   A0 00      LDY #$00
AD22   F0 03      BEQ $AD27
AD24   20 8B B0   JSR $B08B
AD27   85 49      STA $49
AD29   84 4A      STY $4A
AD2B   20 8A A3   JSR $A38A
AD2E   F0 05      BEQ $AD35
AD30   A2 0A      LDX #$0A      ; Fehlermeldung
AD32   4C 37 A4   JMP $A437
AD35   9A         TXS
AD36   8A         TXA
AD37   18         CLC
AD38   69 04      ADC #$04
AD3A   48         PHA
AD3B   69 06      ADC #$06
AD3D   85 24      STA $24
AD3F   68         PLA
AD40   A0 01      LDY #$01
AD42   20 A2 BB   JSR $BBA2
AD45   BA         TSX
AD46   BD 09 01   LDA $0109,X
AD49   85 66      STA $66
AD4B   A5 49      LDA $49
AD4D   A4 4A      LDY $4A
AD4F   20 67 B8   JSR $B867
AD52   20 D0 BB   JSR $BBD0
AD55   A0 01      LDY #$01
AD57   20 5D BC   JSR $BC5D
AD5A   BA         TSX
AD5B   38         SEC
AD5C   FD 09 01   SBC $0109,X
AD5F   F0 17      BEQ $AD78
AD61   BD 0F 01   LDA $010F,X
AD64   85 39      STA $39
AD66   BD 10 01   LDA $0110,X
AD69   85 3A      STA $3A
AD6B   BD 12 01   LDA $0112,X
AD6E   85 7A      STA $7A
AD70   BD 11 01   LDA $0111,X
AD73   85 7B      STA $7B
AD75   4C AE A7   JMP $A7AE
AD78   8A         TXA
AD79   69 11      ADC #$11
AD7B   AA         TAX
AD7C   9A         TXS
AD7D   20 79 00   JSR $0079
AD80   C9 2C      CMP #$2C      ; Kommer
AD82   D0 F1      BNE $AD75
AD84   20 73 00   JSR $0073
AD87   20 24 AD   JSR $AD24

; nächste 'nicht-String'-Variable holen

AD8A   20 9E AD   JSR $AD9E
AD8D   18         CLC
AD8E   .BY $24

; Wert auf String testen

AD8F   38         SEC

; überprüft Wert entsprechend dem C-Flag

AD90   24 0D      BIT $0D
AD92   30 03      BMI $AD97
AD94   B0 03      BCS $AD99
AD96   60         RTS
AD97   B0 FD      BCS $AD96
AD99   A2 16      LDX #$16
AD9B   4C 37 A4   JMP $A437

; math. Berechnungsausdruck

AD9E   A6 7A      LDX $7A
ADA0   D0 02      BNE $ADA4
ADA2   C6 7B      DEC $7B
ADA4   C6 7A      DEC $7A
ADA6   A2 00      LDX #$00
ADA8   .BY $24
ADA9   48         PHA
ADAA   8A         TXA
ADAB   48         PHA
ADAC   A9 01      LDA #$01
ADAE   20 FB A3   JSR $A3FB
ADB1   20 83 AE   JSR $AE83
ADB4   A9 00      LDA #$00
ADB6   85 4D      STA $4D
ADB8   20 79 00   JSR $0079
ADBB   38         SEC
ADBC   E9 B1      SBC #$B1      ; Code für 'größer als'
ADBE   90 17      BCC $ADD7
ADC0   C9 03      CMP #$03
ADC2   B0 13      BCS $ADD7
ADC4   C9 01      CMP #$01
ADC6   2A         ROL
ADC7   49 01      EOR #$01
ADC9   45 4D      EOR $4D
ADCB   C5 4D      CMP $4D
ADCD   90 61      BCC $AE30
ADCF   85 4D      STA $4D
ADD1   20 73 00   JSR $0073
ADD4   4C BB AD   JMP $ADBB
ADD7   A6 4D      LDX $4D
ADD9   D0 2C      BNE $AE07
ADDB   B0 7B      BCS $AE58
ADDD   69 07      ADC #$07
ADDF   90 77      BCC $AE58
ADE1   65 0D      ADC $0D
ADE3   D0 03      BNE $ADE8
ADE5   4C 3D B6   JMP $B63D
ADE8   69 FF      ADC #$FF
ADEA   85 22      STA $22
ADEC   0A         ASL
ADED   65 22      ADC $22
ADEF   A8         TAY
ADF0   68         PLA
ADF1   D9 80 A0   CMP $A080,Y
ADF4   B0 67      BCS $AE5D
ADF6   20 8D AD   JSR $AD8D
ADF9   48         PHA
ADFA   20 20 AE   JSR $AE20
ADFD   68         PLA
ADFE   A4 4B      LDY $4B
AE00   10 17      BPL $AE19
AE02   AA         TAX
AE03   F0 56      BEQ $AE5B
AE05   D0 5F      BNE $AE66
AE07   46 0D      LSR $0D
AE09   8A         TXA
AE0A   2A         ROL
AE0B   A6 7A      LDX $7A
AE0D   D0 02      BNE $AE11
AE0F   C6 7B      DEC $7B
AE11   C6 7A      DEC $7A
AE13   A0 1B      LDY #$1B
AE15   85 4D      STA $4D
AE17   D0 D7      BNE $ADF0
AE19   D9 80 A0   CMP $A080,Y
AE1C   B0 48      BCS $AE66
AE1E   90 D9      BCC $ADF9

; rekursiver Eintrag zum Berechnen von math. Ausdrücken

AE20   B9 82 A0   LDA $A082,Y
AE23   48         PHA
AE24   B9 81 A0   LDA $A081,Y
AE27   48         PHA
AE28   20 33 AE   JSR $AE33
AE2B   A5 4D      LDA $4D
AE2D   4C A9 AD   JMP $ADA9
AE30   4C 08 AF   JMP $AF08

; speichert gerundeten Wert des linken Operators

AE33   A5 66      LDA $66
AE35   BE 80 A0   LDX $A080,Y
AE38   A8         TAY
AE39   68         PLA           ; 'pull' Rücksprungadresse
AE3A   85 22      STA $22
AE3C   E6 22      INC $22
AE3E   68         PLA           ; und in $22/$23 speichern
AE3F   85 23      STA $23
AE41   98         TYA
AE42   48         PHA
AE43   20 1B BC   JSR $BC1B
AE46   A5 65      LDA $65
AE48   48         PHA
AE49   A5 64      LDA $64
AE4B   48         PHA
AE4C   A5 63      LDA $63
AE4E   48         PHA
AE4F   A5 62      LDA $62
AE51   48         PHA
AE52   A5 61      LDA $61
AE54   48         PHA
AE55   6C 22 00   JMP ($0022)   ; Rückkehr zur aufrufenden Routine

; Operator verwenden

AE58   A0 FF      LDY #$FF
AE5A   68         PLA
AE5B   F0 23      BEQ $AE80
AE5D   C9 64      CMP #$64
AE5F   F0 03      BEQ $AE64
AE61   20 8D AD   JSR $AD8D
AE64   84 4B      STY $4B
AE66   68         PLA
AE67   4A         LSR
AE68   85 12      STA $12
AE6A   68         PLA
AE6B   85 69      STA $69
AE6D   68         PLA
AE6E   85 6A      STA $6A
AE70   68         PLA
AE71   85 6B      STA $6B
AE73   68         PLA
AE74   85 6C      STA $6C
AE76   68         PLA
AE77   85 6D      STA $6D
AE79   68         PLA
AE7A   85 6E      STA $6E
AE7C   45 66      EOR $66
AE7E   85 6F      STA $6F
AE80   A5 61      LDA $61
AE82   60         RTS

; Arithmetische Elementroutine holen

AE83   6C 0A 03   JMP ($030A)   ; normal AE86

; standardmäßiges arithmetisches Element

AE86   A9 00      LDA #$00
AE88   85 0D      STA $0D
AE8A   20 73 00   JSR $0073
AE8D   B0 03      BCS $AE92
AE8F   4C F3 BC   JMP $BCF3
AE92   20 13 B1   JSR $B113
AE95   90 03      BCC $AE9A
AE97   4C 28 AF   JMP $AF28
AE9A   C9 FF      CMP #$FF      ; PI
AE9C   D0 0F      BNE $AEAD
AE9E   A9 A8      LDA #$A8      ; low  AEA8
AEA0   A0 AE      LDY #$AE      ; high AEA8
AEA2   20 A2 BB   JSR $BBA2
AEA5   4C 73 00   JMP $0073

; Floatwert von PI

AEA8   .BY $82,$49,$0F,$DA,$A1
AEAD   C9 2E      CMP #$2E      ; dezimaler Punkt
AEAF   F0 DE      BEQ $AE8F
AEB1   C9 AB      CMP #$AB      ; Pluszeichen
AEB3   F0 58      BEQ $AF0D
AEB5   C9 AA      CMP #$AA      ; Malzeichen
AEB7   F0 D1      BEQ $AE8A
AEB9   C9 22      CMP #$22      ; Fragezeichen
AEBB   D0 0F      BNE $AECC
AEBD   A5 7A      LDA $7A
AEBF   A4 7B      LDY $7B
AEC1   69 00      ADC #$00
AEC3   90 01      BCC $AEC6
AEC5   C8         INY
AEC6   20 87 B4   JSR $B487
AEC9   4C E2 B7   JMP $B7E2
AECC   C9 A8      CMP #$A8      ; NOT-Code
AECE   D0 13      BNE $AEE3
AED0   A0 18      LDY #$18
AED2   D0 3B      BNE $AF0F

; NOT-Operator

AED4   20 BF B1   JSR $B1BF
AED7   A5 65      LDA $65
AED9   49 FF      EOR #$FF
AEDB   A8         TAY
AEDC   A5 64      LDA $64
AEDE   49 FF      EOR #$FF
AEE0   4C 91 B3   JMP $B391

; GET-Operand

AEE3   C9 A5      CMP #$A5
AEE5   D0 03      BNE $AEEA
AEE7   4C F4 B3   JMP $B3F4
AEEA   C9 B4      CMP #$B4      ; SGN-Code oder höher
AEEC   90 03      BCC $AEF1
AEEE   4C A7 AF   JMP $AFA7
AEF1   20 FA AE   JSR $AEFA
AEF4   20 9E AD   JSR $AD9E

; Zeichen überprüfen und verwerfen

AEF7   A9 29      LDA #$29      ; )
AEF9   .BY 2C
AEFA   A9 28      LDA #$28      ; (
AEFC   .BY 2C
AEFD   A9 2C      LDA #$2C      ; Kommer
AEFF   A0 00      LDY #$00
AF01   D1 7A      CMP ($7A),Y
AF03   D0 03      BNE $AF08
AF05   4C 73 00   JMP $0073
AF08   A2 0B      LDX #$0B      ; Fehlernummer
AF0A   4C 37 A4   JMP $A437

; recursiver Wert

AF0D   A0 15      LDY #$15
AF0F   68         PLA
AF10   68         PLA
AF11   4C FA AD   JMP $ADFA

; variable Zeigerweite überprüfen

AF14   38         SEC
AF15   A5 64      LDA $64
AF17   E9 00      SBC #$00
AF19   A5 65      LDA $65
AF1B   E9 A0      SBC #$A0
AF1D   90 08      BCC $AF27
AF1F   A9 A2      LDA #$A2
AF21   E5 64      SBC $64
AF23   A9 E3      LDA #$E3
AF25   E5 65      SBC $65
AF27   60         RTS

; Wert einer Variable holen

AF28   20 8B B0   JSR $B08B
AF2B   85 64      STA $64
AF2D   84 65      STY $65
AF2F   A6 45      LDX $45
AF31   A4 46      LDY $46
AF33   A5 0D      LDA $0D
AF35   F0 26      BEQ $AF5D
AF37   A9 00      LDA #$00
AF39   85 70      STA $70
AF3B   20 14 AF   JSR $AF14
AF3E   90 1C      BCC $AF5C
AF40   E0 54      CPX #$54      ; T
AF42   D0 18      BNE $AF5C
AF44   C0 C9      CPY #$C9      ; I$
AF46   D0 14      BNE $AF5C
AF48   20 84 AF   JSR $AF84
AF4B   84 5E      STY $5E
AF4D   88         DEY
AF4E   84 71      STY $71
AF50   A0 06      LDY #$06
AF52   84 5D      STY $5D
AF54   A0 24      LDY #$24
AF56   20 68 BE   JSR $BE68
AF59   4C 6F B4   JMP $B46F
AF5C   60         RTS
AF5D   24 0E      BIT $0E
AF5F   10 0D      BPL $AF6E
AF61   A0 00      LDY #$00
AF63   B1 64      LDA ($64),Y
AF65   AA         TAX
AF66   C8         INY
AF67   B1 64      LDA ($64),Y
AF69   A8         TAY
AF6A   8A         TXA
AF6B   4C 91 B3   JMP $B391
AF6E   20 14 AF   JSR $AF14
AF71   90 2D      BCC $AFA0
AF73   E0 54      CPX #$54   ; T
AF75   D0 1B      BNE $AF92
AF77   C0 49      CPY #$49   ; I
AF79   D0 25      BNE $AFA0
AF7B   20 84 AF   JSR $AF84
AF7E   98         TYA
AF7F   A2 A0      LDX #$A0
AF81   4C 4F BC   JMP $BC4F

; time in Float-Akumulator holen

AF84   20 DE FF   JSR $FFDE
AF87   86 64      STX $64
AF89   84 63      STY $63
AF8B   85 65      STA $65
AF8D   A0 00      LDY #$00
AF8F   84 62      STY $62
AF91   60         RTS

; Fortfahren mit dem Wert einer Variable holen

AF92   E0 53      CPX #$53      ; S
AF94   D0 0A      BNE $AFA0
AF96   C0 54      CPY #$54      ; T
AF98   D0 06      BNE $AFA0
AF9A   20 B7 FF   JSR $FFB7
AF9D   4C 3C BC   JMP $BC3C
AFA0   A5 64      LDA $64
AFA2   A4 65      LDY $65
AFA4   4C A2 BB   JMP $BBA2

; Funktion anwenden

AFA7   0A         ASL
AFA8   48         PHA
AFA9   AA         TAX
AFAA   20 73 00   JSR $0073
AFAD   E0 8F      CPX #$8F
AFAF   90 20      BCC $AFD1
AFB1   20 FA AE   JSR $AEFA
AFB4   20 9E AD   JSR $AD9E
AFB7   20 FD AE   JSR $AEFD
AFBA   20 8F AD   JSR $AD8F
AFBD   68         PLA
AFBE   AA         TAX
AFBF   A5 65      LDA $65
AFC1   48         PHA
AFC2   A5 64      LDA $64
AFC4   48         PHA
AFC5   8A         TXA
AFC6   48         PHA
AFC7   20 9E B7   JSR $B79E
AFCA   68         PLA
AFCB   A8         TAY
AFCC   8A         TXA
AFCD   48         PHA
AFCE   4C D6 AF   JMP $AFD6
AFD1   20 F1 AE   JSR $AEF1
AFD4   68         PLA
AFD5   A8         TAY
AFD6   B9 EA 9F   LDA $9FEA,Y
AFD9   85 55      STA $55
AFDB   B9 EB 9F   LDA $9FEB,Y
AFDE   85 56      STA $56
AFE0   20 54 00   JSR $0054
AFE3   4C 8D AD   JMP $AD8D

; OR-Operator

AFE6   A0 FF      LDY #$FF
AFE8   .BY $2C

; AND-Operator

AFE9   A0 00      LDY #$00
AFEB   84 0B      STY $0B
AFED   20 BF B1   JSR $B1BF
AFF0   A5 64      LDA $64
AFF2   45 0B      EOR $0B
AFF4   85 07      STA $07
AFF6   A5 65      LDA $65
AFF8   45 0B      EOR $0B
AFFA   85 08      STA $08
AFFC   20 FC BB   JSR $BBFC
AFFF   20 BF B1   JSR $B1BF
B002   A5 65      LDA $65
B004   45 0B      EOR $0B
B006   25 08      AND $08
B008   45 0B      EOR $0B
B00A   A8         TAY
B00B   A5 64      LDA $64
B00D   45 0B      EOR $0B
B00F   25 07      AND $07
B011   45 0B      EOR $0B
B013   4C 91 B3   JMP $B391

; größer/gleich/kleiner Operator

B016   20 90 AD   JSR $AD90
B019   B0 13      BCS $B02E
B01B   A5 6E      LDA $6E
B01D   09 7F      ORA #$7F
B01F   25 6A      AND $6A
B021   85 6A      STA $6A
B023   A9 69      LDA #$69
B025   A0 00      LDY #$00
B027   20 5B BC   JSR $BC5B
B02A   AA         TAX
B02B   4C 61 B0   JMP $B061
B02E   A9 00      LDA #$00
B030   85 0D      STA $0D
B032   C6 4D      DEC $4D
B034   20 A6 B6   JSR $B6A6
B037   85 61      STA $61
B039   86 62      STX $62
B03B   84 63      STY $63
B03D   A5 6C      LDA $6C
B03F   A4 6D      LDY $6D
B041   20 AA B6   JSR $B6AA
B044   86 6C      STX $6C
B046   84 6D      STY $6D
B048   AA         TAX
B049   38         SEC
B04A   E5 61      SBC $61
B04C   F0 08      BEQ $B056
B04E   A9 01      LDA #$01
B050   90 04      BCC $B056
B052   A6 61      LDX $61
B054   A9 FF      LDA #$FF
B056   85 66      STA $66
B058   A0 FF      LDY #$FF
B05A   E8         INX
B05B   C8         INY
B05C   CA         DEX
B05D   D0 07      BNE $B066
B05F   A6 66      LDX $66
B061   30 0F      BMI $B072
B063   18         CLC
B064   90 0C      BCC $B072
B066   B1 6C      LDA ($6C),Y
B068   D1 62      CMP ($62),Y
B06A   F0 EF      BEQ $B05B
B06C   A2 FF      LDX #$FF
B06E   B0 02      BCS $B072
B070   A2 01      LDX #$01
B072   E8         INX
B073   8A         TXA
B074   2A         ROL
B075   25 12      AND $12
B077   F0 02      BEQ $B07B
B079   A9 FF      LDA #$FF
B07B   4C 3C BC   JMP $BC3C

; DIM-Befehl

B07E   20 FD AE   JSR $AEFD
B081   AA         TAX
B082   20 90 B0   JSR $B090
B085   20 79 00   JSR $0079
B088   D0 F4      BNE $B07E
B08A   60         RTS

; Name und Zeiger auf eine Variable holen

B08B   A2 00      LDX #$00
B08D   20 79 00   JSR $0079
B090   86 0C      STX $0C
B092   85 45      STA $45
B094   20 79 00   JSR $0079
B097   20 13 B1   JSR $B113
B09A   B0 03      BCS $B09F
B09C   4C 08 AF   JMP $AF08
B09F   A2 00      LDX #$00
B0A1   86 0D      STX $0D
B0A3   86 0E      STX $0E
B0A5   20 73 00   JSR $0073
B0A8   90 05      BCC $B0AF
B0AA   20 13 B1   JSR $B113
B0AD   90 0B      BCC $B0BA
B0AF   AA         TAX
B0B0   20 73 00   JSR $0073
B0B3   90 FB      BCC $B0B0
B0B5   20 13 B1   JSR $B113
B0B8   B0 F6      BCS $B0B0
B0BA   C9 24      CMP #$24      ; $
B0BC   D0 06      BNE $B0C4
B0BE   A9 FF      LDA #$FF
B0C0   85 0D      STA $0D
B0C2   D0 10      BNE $B0D4
B0C4   C9 25      CMP #$25      ; %
B0C6   D0 13      BNE $B0DB
B0C8   A5 10      LDA $10
B0CA   D0 D0      BNE $B09C
B0CC   A9 80      LDA #$80
B0CE   85 0E      STA $0E
B0D0   05 45      ORA $45
B0D2   85 45      STA $45
B0D4   8A         TXA
B0D5   09 80      ORA #$80
B0D7   AA         TAX
B0D8   20 73 00   JSR $0073
B0DB   86 46      STX $46
B0DD   38         SEC
B0DE   05 10      ORA $10
B0E0   E9 28      SBC #$28      ; (
B0E2   D0 03      BNE $B0E7
B0E4   4C D1 B1   JMP $B1D1
B0E7   A0 00      LDY #$00
B0E9   84 10      STY $10
B0EB   A5 2D      LDA $2D
B0ED   A6 2E      LDX $2E
B0EF   86 60      STX $60
B0F1   85 5F      STA $5F
B0F3   E4 30      CPX $30
B0F5   D0 04      BNE $B0FB
B0F7   C5 2F      CMP $2F
B0F9   F0 22      BEQ $B11D
B0FB   A5 45      LDA $45
B0FD   D1 5F      CMP ($5F),Y
B0FF   D0 08      BNE $B109
B101   A5 46      LDA $46
B103   C8         INY
B104   D1 5F      CMP ($5F),Y
B106   F0 7D      BEQ $B185
B108   88         DEY
B109   18         CLC
B10A   A5 5F      LDA $5F
B10C   69 07      ADC #$07
B10E   90 E1      BCC $B0F1
B110   E8         INX
B111   D0 DC      BNE $B0EF

; Zeichen in A überprüfen, C=1 wenn alphabetisch, C=0 wenn nicht

B113   C9 41      CMP #$41      ; A
B115   90 05      BCC $B11C
B117   E9 5B      SBC #$5B      ; Z
B119   38         SEC
B11A   E9 A5      SBC #$A5
B11C   60         RTS

; Variable nicht gefunden

B11D   68         PLA
B11E   48         PHA
B11F   C9 2A      CMP #$2A
B121   D0 05      BNE $B128
B123   A9 13      LDA #$13
B125   A0 BF      LDY #$BF
B127   60         RTS
B128   A5 45      LDA $45
B12A   A4 46      LDY $46
B12C   C9 54      CMP #$54      ; T
B12E   D0 0B      BNE $B13B
B130   C0 C9      CPY #$C9      ; I$
B132   F0 EF      BEQ $B123
B134   C0 49      CPY #$49      ; I
B136   D0 03      BNE $B13B
B138   4C 08 AF   JMP $AF08
B13B   C9 53      CMP #$53      ; S
B13D   D0 04      BNE $B143
B13F   C0 54      CPY #$54      ; T
B141   F0 F5      BEQ $B138
B143   A5 2F      LDA $2F
B145   A4 30      LDY $30
B147   85 5F      STA $5F
B149   84 60      STY $60
B14B   A5 31      LDA $31
B14D   A4 32      LDY $32
B14F   85 5A      STA $5A
B151   84 5B      STY $5B
B153   18         CLC
B154   69 07      ADC #$07
B156   90 01      BCC $B159
B158   C8         INY
B159   85 58      STA $58
B15B   84 59      STY $59
B15D   20 B8 A3   JSR $A3B8
B160   A5 58      LDA $58
B162   A4 59      LDY $59
B164   C8         INY
B165   85 2F      STA $2F
B167   84 30      STY $30
B169   A0 00      LDY #$00
B16B   A5 45      LDA $45
B16D   91 5F      STA ($5F),Y
B16F   C8         INY
B170   A5 46      LDA $46
B172   91 5F      STA ($5F),Y
B174   A9 00      LDA #$00
B176   C8         INY
B177   91 5F      STA ($5F),Y
B179   C8         INY
B17A   91 5F      STA ($5F),Y
B17C   C8         INY
B17D   91 5F      STA ($5F),Y
B17F   C8         INY
B180   91 5F      STA ($5F),Y
B182   C8         INY
B183   91 5F      STA ($5F),Y

; Variable gefunden

B185   A5 5F      LDA $5F
B187   18         CLC
B188   69 02      ADC #$02
B18A   A4 60      LDY $60
B18C   90 01      BCC $B18F
B18E   C8         INY
B18F   85 47      STA $47
B191   84 48      STY $48
B193   60         RTS

; Zeiger auf Array-Body berechnen

B194   A5 0B      LDA $0B
B196   0A         ASL
B197   69 05      ADC #$05
B199   65 5F      ADC $5F
B19B   A4 60      LDY $60
B19D   90 01      BCC $B1A0
B19F   C8         INY
B1A0   85 58      STA $58
B1A2   84 59      STY $59
B1A4   60         RTS

; Floatnummer für Konvertierung eines Integers (-32768)

B1A5   .BY $90,$80,$00,$00,$00

; Routine zum Konvertieren eines Float in Fixed-Point

B1AA   20 BF B1   JSR $B1BF
B1AD   A5 64      LDA $64
B1AF   A4 65      LDY $65
B1B1   60         RTS

; Wert eines Statements in einen Integer konertieren

B1B2   20 73 00   JSR $0073
B1B5   20 9E AD   JSR $AD9E
B1B8   20 8D AD   JSR $AD8D
B1BB   A5 66      LDA $66
B1BD   30 0D      BMI $B1CC

; konvertiert Floatnummer in Integer

B1BF   A5 61      LDA $61
B1C1   C9 90      CMP #$90
B1C3   90 09      BCC $B1CE
B1C5   A9 A5      LDA #$A5      ; low  B1A5
B1C7   A0 B1      LDY #$B1      ; high B1A5
B1C9   20 5B BC   JSR $BC5B
B1CC   D0 7A      BNE $B248
B1CE   4C 9B BC   JMP $BC9B

; Zeiger auf dimensionierte Variable holen

B1D1   A5 0C      LDA $0C
B1D3   05 0E      ORA $0E
B1D5   48         PHA
B1D6   A5 0D      LDA $0D
B1D8   48         PHA
B1D9   A0 00      LDY #$00
B1DB   98         TYA
B1DC   48         PHA
B1DD   A5 46      LDA $46
B1DF   48         PHA
B1E0   A5 45      LDA $45
B1E2   48         PHA
B1E3   20 B2 B1   JSR $B1B2
B1E6   68         PLA
B1E7   85 45      STA $45
B1E9   68         PLA
B1EA   85 46      STA $46
B1EC   68         PLA
B1ED   A8         TAY
B1EE   BA         TSX
B1EF   BD 02 01   LDA $0102,X
B1F2   48         PHA
B1F3   BD 01 01   LDA $0101,X
B1F6   48         PHA
B1F7   A5 64      LDA $64
B1F9   9D 02 01   STA $0102,X
B1FC   A5 65      LDA $65
B1FE   9D 01 01   STA $0101,X
B201   C8         INY
B202   20 79 00   JSR $0079
B205   C9 2C      CMP #$2C      ; Kommer
B207   F0 D2      BEQ $B1DB
B209   84 0B      STY $0B
B20B   20 F7 AE   JSR $AEF7
B20E   68         PLA
B20F   85 0D      STA $0D
B211   68         PLA
B212   85 0E      STA $0E
B214   29 7F      AND #$7F
B216   85 0C      STA $0C
B218   A6 2F      LDX $2F
B21A   A5 30      LDA $30
B21C   86 5F      STX $5F
B21E   85 60      STA $60
B220   C5 32      CMP $32
B222   D0 04      BNE $B228
B224   E4 31      CPX $31
B226   F0 39      BEQ $B261
B228   A0 00      LDY #$00
B22A   B1 5F      LDA ($5F),Y
B22C   C8         INY
B22D   C5 45      CMP $45
B22F   D0 06      BNE $B237
B231   A5 46      LDA $46
B233   D1 5F      CMP ($5F),Y
B235   F0 16      BEQ $B24D
B237   C8         INY
B238   B1 5F      LDA ($5F),Y
B23A   18         CLC
B23B   65 5F      ADC $5F
B23D   AA         TAX
B23E   C8         INY
B23F   B1 5F      LDA ($5F),Y
B241   65 60      ADC $60
B243   90 D7      BCC $B21C
B245   A2 12      LDX #$12      ; Fehlernummer
B247   .BY 2C
B248   A2 0E      LDX #$0E      ; Fehlernummer
B24A   4C 37 A4   JMP $A437
B24D   A2 13      LDX #$13      ; Fehlernummer
B24F   A5 0C      LDA $0C
B251   D0 F7      BNE $B24A
B253   20 94 B1   JSR $B194
B256   A5 0B      LDA $0B
B258   A0 04      LDY #$04
B25A   D1 5F      CMP ($5F),Y
B25C   D0 E7      BNE $B245
B25E   4C EA B2   JMP $B2EA

; Array anlegen, Speicher belegen

B261   20 94 B1   JSR $B194
B264   20 08 A4   JSR $A408
B267   A0 00      LDY #$00
B269   84 72      STY $72
B26B   A2 05      LDX #$05
B26D   A5 45      LDA $45
B26F   91 5F      STA ($5F),Y
B271   10 01      BPL $B274
B273   CA         DEX
B274   C8         INY
B275   A5 46      LDA $46
B277   91 5F      STA ($5F),Y
B279   10 02      BPL $B27D
B27B   CA         DEX
B27C   CA         DEX
B27D   86 71      STX $71
B27F   A5 0B      LDA $0B
B281   C8         INY
B282   C8         INY
B283   C8         INY
B284   91 5F      STA ($5F),Y
B286   A2 0B      LDX #$0B
B288   A9 00      LDA #$00
B28A   24 0C      BIT $0C
B28C   50 08      BVC $B296
B28E   68         PLA
B28F   18         CLC
B290   69 01      ADC #$01
B292   AA         TAX
B293   68         PLA
B294   69 00      ADC #$00
B296   C8         INY
B297   91 5F      STA ($5F),Y
B299   C8         INY
B29A   8A         TXA
B29B   91 5F      STA ($5F),Y
B29D   20 4C B3   JSR $B34C
B2A0   86 71      STX $71
B2A2   85 72      STA $72
B2A4   A4 22      LDY $22
B2A6   C6 0B      DEC $0B
B2A8   D0 DC      BNE $B286
B2AA   65 59      ADC $59
B2AC   B0 5D      BCS $B30B
B2AE   85 59      STA $59
B2B0   A8         TAY
B2B1   8A         TXA
B2B2   65 58      ADC $58
B2B4   90 03      BCC $B2B9
B2B6   C8         INY
B2B7   F0 52      BEQ $B30B
B2B9   20 08 A4   JSR $A408
B2BC   85 31      STA $31
B2BE   84 32      STY $32
B2C0   A9 00      LDA #$00
B2C2   E6 72      INC $72
B2C4   A4 71      LDY $71
B2C6   F0 05      BEQ $B2CD
B2C8   88         DEY
B2C9   91 58      STA ($58),Y
B2CB   D0 FB      BNE $B2C8
B2CD   C6 59      DEC $59
B2CF   C6 72      DEC $72
B2D1   D0 F5      BNE $B2C8
B2D3   E6 59      INC $59
B2D5   38         SEC
B2D6   A5 31      LDA $31
B2D8   E5 5F      SBC $5F
B2DA   A0 02      LDY #$02
B2DC   91 5F      STA ($5F),Y
B2DE   A5 32      LDA $32
B2E0   C8         INY
B2E1   E5 60      SBC $60
B2E3   91 5F      STA ($5F),Y
B2E5   A5 0C      LDA $0C
B2E7   D0 62      BNE $B34B
B2E9   C8         INY

; Referenz auf Arrayelement berechnen

B2EA   B1 5F      LDA ($5F),Y
B2EC   85 0B      STA $0B
B2EE   A9 00      LDA #$00
B2F0   85 71      STA $71
B2F2   85 72      STA $72
B2F4   C8         INY
B2F5   68         PLA
B2F6   AA         TAX
B2F7   85 64      STA $64
B2F9   68         PLA
B2FA   85 65      STA $65
B2FC   D1 5F      CMP ($5F),Y
B2FE   90 0E      BCC $B30E
B300   D0 06      BNE $B308
B302   C8         INY
B303   8A         TXA
B304   D1 5F      CMP ($5F),Y
B306   90 07      BCC $B30F
B308   4C 45 B2   JMP $B245
B30B   4C 35 A4   JMP $A435
B30E   C8         INY
B30F   A5 72      LDA $72
B311   05 71      ORA $71
B313   18         CLC
B314   F0 0A      BEQ $B320
B316   20 4C B3   JSR $B34C
B319   8A         TXA
B31A   65 64      ADC $64
B31C   AA         TAX
B31D   98         TYA
B31E   A4 22      LDY $22
B320   65 65      ADC $65
B322   86 71      STX $71
B324   C6 0B      DEC $0B
B326   D0 CA      BNE $B2F2
B328   85 72      STA $72
B32A   A2 05      LDX #$05
B32C   A5 45      LDA $45
B32E   10 01      BPL $B331
B330   CA         DEX
B331   A5 46      LDA $46
B333   10 02      BPL $B337
B335   CA         DEX
B336   CA         DEX
B337   86 28      STX $28
B339   A9 00      LDA #$00
B33B   20 55 B3   JSR $B355
B33E   8A         TXA
B33F   65 58      ADC $58
B341   85 47      STA $47
B343   98         TYA
B344   65 59      ADC $59
B346   85 48      STA $48
B348   A8         TAY
B349   A5 47      LDA $47
B34B   60         RTS

; XY = XA = Länge * Limit der Arraydaten

B34C   84 22      STY $22
B34E   B1 5F      LDA ($5F),Y
B350   85 28      STA $28
B352   88         DEY
B353   B1 5F      LDA ($5F),Y
B355   85 29      STA $29
B357   A9 10      LDA #$10
B359   85 5D      STA $5D
B35B   A2 00      LDX #$00
B35D   A0 00      LDY #$00
B35F   8A         TXA
B360   0A         ASL
B361   AA         TAX
B362   98         TYA
B363   2A         ROL
B364   A8         TAY
B365   B0 A4      BCS $B30B
B367   06 71      ASL $71
B369   26 72      ROL $72
B36B   90 0B      BCC $B378
B36D   18         CLC
B36E   8A         TXA
B36F   65 28      ADC $28
B371   AA         TAX
B372   98         TYA
B373   65 29      ADC $29
B375   A8         TAY
B376   B0 93      BCS $B30B
B378   C6 5D      DEC $5D
B37A   D0 E3      BNE $B35F
B37C   60         RTS

; FRE-Funktion

B37D   A5 0D      LDA $0D
B37F   F0 03      BEQ $B384
B381   20 A6 B6   JSR $B6A6
B384   20 26 B5   JSR $B526
B387   38         SEC
B388   A5 33      LDA $33
B38A   E5 31      SBC $31
B38C   A8         TAY
B38D   A5 34      LDA $34
B38F   E5 32      SBC $32

; Routine zum Konvertieren eines Integers in Float

B391   A2 00      LDX #$00
B393   86 0D      STX $0D
B395   85 62      STA $62
B397   84 63      STY $63
B399   A2 90      LDX #$90
B39B   4C 44 BC   JMP $BC44

; POS-Funktion

B39E   38         SEC
B39F   20 F0 FF   JSR $FFF0
B3A2   A9 00      LDA #$00
B3A4   F0 EB      BEQ $B391

; auf 'non-direct'-Modus überprüfen

B3A6   A6 3A      LDX $3A
B3A8   E8         INX
B3A9   D0 A0      BNE $B34B
B3AB   A2 15      LDX #$15      ; Fehlernummer
B3AD   .BY $2C
B3AE   A2 1B      LDX #$1B      ; Fehlernummer
B3B0   4C 37 A4   JMP $A437

; DEF-Befehl

B3B3   20 E1 B3   JSR $B3E1
B3B6   20 A6 B3   JSR $B3A6
B3B9   20 FA AE   JSR $AEFA
B3BC   A9 80      LDA #$80
B3BE   85 10      STA $10
B3C0   20 8B B0   JSR $B08B
B3C3   20 8D AD   JSR $AD8D
B3C6   20 F7 AE   JSR $AEF7
B3C9   A9 B2      LDA #$B2
B3CB   20 FF AE   JSR $AEFF
B3CE   48         PHA
B3CF   A5 48      LDA $48
B3D1   48         PHA
B3D2   A5 47      LDA $47
B3D4   48         PHA
B3D5   A5 7B      LDA $7B
B3D7   48         PHA
B3D8   A5 7A      LDA $7A
B3DA   48         PHA
B3DB   20 F8 A8   JSR $A8F8
B3DE   4C 4F B4   JMP $B44F

; Funktionsname holen

B3E1   A9 A5      LDA #$A5
B3E3   20 FF AE   JSR $AEFF
B3E6   09 80      ORA #$80
B3E8   85 10      STA $10
B3EA   20 92 B0   JSR $B092
B3ED   85 4E      STA $4E
B3EF   84 4F      STY $4F
B3F1   4C 8D AD   JMP $AD8D

; 'FN call' ausweiten

B3F4   20 E1 B3   JSR $B3E1
B3F7   A5 4F      LDA $4F
B3F9   48         PHA
B3FA   A5 4E      LDA $4E
B3FC   48         PHA
B3FD   20 F1 AE   JSR $AEF1
B400   20 8D AD   JSR $AD8D
B403   68         PLA
B404   85 4E      STA $4E
B406   68         PLA
B407   85 4F      STA $4F
B409   A0 02      LDY #$02
B40B   B1 4E      LDA ($4E),Y
B40D   85 47      STA $47
B40F   AA         TAX
B410   C8         INY
B411   B1 4E      LDA ($4E),Y
B413   F0 99      BEQ $B3AE
B415   85 48      STA $48
B417   C8         INY
B418   B1 47      LDA ($47),Y
B41A   48         PHA
B41B   88         DEY
B41C   10 FA      BPL $B418
B41E   A4 48      LDY $48
B420   20 D4 BB   JSR $BBD4
B423   A5 7B      LDA $7B
B425   48         PHA
B426   A5 7A      LDA $7A
B428   48         PHA
B429   B1 4E      LDA ($4E),Y
B42B   85 7A      STA $7A
B42D   C8         INY
B42E   B1 4E      LDA ($4E),Y
B430   85 7B      STA $7B
B432   A5 48      LDA $48
B434   48         PHA
B435   A5 47      LDA $47
B437   48         PHA
B438   20 8A AD   JSR $AD8A
B43B   68         PLA
B43C   85 4E      STA $4E
B43E   68         PLA
B43F   85 4F      STA $4F
B441   20 79 00   JSR $0079
B444   F0 03      BEQ $B449
B446   4C 08 AF   JMP $AF08
B449   68         PLA
B44A   85 7A      STA $7A
B44C   68         PLA
B44D   85 7B      STA $7B
B44F   A0 00      LDY #$00
B451   68         PLA
B452   91 4E      STA ($4E),Y
B454   68         PLA
B455   C8         INY
B456   91 4E      STA ($4E),Y
B458   68         PLA
B459   C8         INY
B45A   91 4E      STA ($4E),Y
B45C   68         PLA
B45D   C8         INY
B45E   91 4E      STA ($4E),Y
B460   68         PLA
B461   C8         INY
B462   91 4E      STA ($4E),Y
B464   60         RTS

; STR$-Funktion

B465   20 8D AD   JSR $AD8D
B468   A0 00      LDY #$00
B46A   20 DF BD   JSR $BDDF
B46D   68         PLA
B46E   68         PLA
B46F   A9 FF      LDA #$FF
B471   A0 00      LDY #$00
B473   F0 12      BEQ $B487
B475   A6 64      LDX $64
B477   A4 65      LDY $65
B479   86 50      STX $50
B47B   84 51      STY $51

; Speicherbereich entsprechend A rservieren

B47D   20 F4 B4   JSR $B4F4
B480   86 62      STX $62
B482   84 63      STY $63
B484   85 61      STA $61
B486   60         RTS

; Description eines Strings in deb Float-Akumulator

B487   A2 22      LDX #$22      ; Anführungszeichen
B489   86 07      STX $07
B48B   86 08      STX $08
B48D   85 6F      STA $6F
B48F   84 70      STY $70
B491   85 62      STA $62
B493   84 63      STY $63
B495   A0 FF      LDY #$FF
B497   C8         INY
B498   B1 6F      LDA ($6F),Y
B49A   F0 0C      BEQ $B4A8
B49C   C5 07      CMP $07
B49E   F0 04      BEQ $B4A4
B4A0   C5 08      CMP $08
B4A2   D0 F3      BNE $B497
B4A4   C9 22      CMP #$22      ; Anführungszeichen
B4A6   F0 01      BEQ $B4A9
B4A8   18         CLC
B4A9   84 61      STY $61
B4AB   98         TYA
B4AC   65 6F      ADC $6F
B4AE   85 71      STA $71
B4B0   A6 70      LDX $70
B4B2   90 01      BCC $B4B5
B4B4   E8         INX
B4B5   86 72      STX $72
B4B7   A5 70      LDA $70
B4B9   F0 04      BEQ $B4BF
B4BB   C9 02      CMP #$02
B4BD   D0 0B      BNE $B4CA
B4BF   98         TYA
B4C0   20 75 B4   JSR $B475
B4C3   A6 6F      LDX $6F
B4C5   A4 70      LDY $70
B4C7   20 88 B6   JSR $B688

; Descriptor von $61-$63 auf den Stack schreiben

B4CA   A6 16      LDX $16
B4CC   E0 22      CPX #$22
B4CE   D0 05      BNE $B4D5
B4D0   A2 19      LDX #$19
B4D2   4C 37 A4   JMP $A437
B4D5   A5 61      LDA $61
B4D7   95 00      STA $00,X
B4D9   A5 62      LDA $62
B4DB   95 01      STA $01,X
B4DD   A5 63      LDA $63
B4DF   95 02      STA $02,X
B4E1   A0 00      LDY #$00
B4E3   86 64      STX $64
B4E5   84 65      STY $65
B4E7   84 70      STY $70
B4E9   88         DEY
B4EA   84 0D      STY $0D
B4EC   86 17      STX $17
B4EE   E8         INX
B4EF   E8         INX
B4F0   E8         INX
B4F1   86 16      STX $16
B4F3   60         RTS

; Anzahl von Bytes in A reservieren

B4F4   46 0F      LSR $0F
B4F6   48         PHA
B4F7   49 FF      EOR #$FF
B4F9   38         SEC
B4FA   65 33      ADC $33
B4FC   A4 34      LDY $34
B4FE   B0 01      BCS $B501
B500   88         DEY
B501   C4 32      CPY $32
B503   90 11      BCC $B516
B505   D0 04      BNE $B50B
B507   C5 31      CMP $31
B509   90 0B      BCC $B516
B50B   85 33      STA $33
B50D   84 34      STY $34
B50F   85 35      STA $35
B511   84 36      STY $36
B513   AA         TAX
B514   68         PLA
B515   60         RTS
B516   A2 10      LDX #$10
B518   A5 0F      LDA $0F
B51A   30 B6      BMI $B4D2
B51C   20 26 B5   JSR $B526
B51F   A9 80      LDA #$80
B521   85 0F      STA $0F
B523   68         PLA
B524   D0 D0      BNE $B4F6

; Stringgarbage löschen

B526   A6 37      LDX $37
B528   A5 38      LDA $38
B52A   86 33      STX $33
B52C   85 34      STA $34
B52E   A0 00      LDY #$00
B530   84 4F      STY $4F
B532   84 4E      STY $4E
B534   A5 31      LDA $31
B536   A6 32      LDX $32
B538   85 5F      STA $5F
B53A   86 60      STX $60
B53C   A9 19      LDA #$19      ; low  0019
B53E   A2 00      LDX #$00      ; high 0019
B540   85 22      STA $22
B542   86 23      STX $23
B544   C5 16      CMP $16
B546   F0 05      BEQ $B54D
B548   20 C7 B5   JSR $B5C7
B54B   F0 F7      BEQ $B544
B54D   A9 07      LDA #$07
B54F   85 53      STA $53
B551   A5 2D      LDA $2D
B553   A6 2E      LDX $2E
B555   85 22      STA $22
B557   86 23      STX $23
B559   E4 30      CPX $30
B55B   D0 04      BNE $B561
B55D   C5 2F      CMP $2F
B55F   F0 05      BEQ $B566
B561   20 BD B5   JSR $B5BD
B564   F0 F3      BEQ $B559
B566   85 58      STA $58
B568   86 59      STX $59
B56A   A9 03      LDA #$03
B56C   85 53      STA $53
B56E   A5 58      LDA $58
B570   A6 59      LDX $59
B572   E4 32      CPX $32
B574   D0 07      BNE $B57D
B576   C5 31      CMP $31
B578   D0 03      BNE $B57D
B57A   4C 06 B6   JMP $B606
B57D   85 22      STA $22
B57F   86 23      STX $23
B581   A0 00      LDY #$00
B583   B1 22      LDA ($22),Y
B585   AA         TAX
B586   C8         INY
B587   B1 22      LDA ($22),Y
B589   08         PHP
B58A   C8         INY
B58B   B1 22      LDA ($22),Y
B58D   65 58      ADC $58
B58F   85 58      STA $58
B591   C8         INY
B592   B1 22      LDA ($22),Y
B594   65 59      ADC $59
B596   85 59      STA $59
B598   28         PLP
B599   10 D3      BPL $B56E
B59B   8A         TXA
B59C   30 D0      BMI $B56E
B59E   C8         INY
B59F   B1 22      LDA ($22),Y
B5A1   A0 00      LDY #$00
B5A3   0A         ASL
B5A4   69 05      ADC #$05
B5A6   65 22      ADC $22
B5A8   85 22      STA $22
B5AA   90 02      BCC $B5AE
B5AC   E6 23      INC $23
B5AE   A6 23      LDX $23
B5B0   E4 59      CPX $59
B5B2   D0 04      BNE $B5B8
B5B4   C5 58      CMP $58
B5B6   F0 BA      BEQ $B572
B5B8   20 C7 B5   JSR $B5C7
B5BB   F0 F3      BEQ $B5B0

; Stringbereich überprüfen

B5BD   B1 22      LDA ($22),Y
B5BF   30 35      BMI $B5F6
B5C1   C8         INY
B5C2   B1 22      LDA ($22),Y
B5C4   10 30      BPL $B5F6
B5C6   C8         INY

; Stringbereich überprüfen

B5C7   B1 22      LDA ($22),Y
B5C9   F0 2B      BEQ $B5F6
B5CB   C8         INY
B5CC   B1 22      LDA ($22),Y
B5CE   AA         TAX
B5CF   C8         INY
B5D0   B1 22      LDA ($22),Y
B5D2   C5 34      CMP $34
B5D4   90 06      BCC $B5DC
B5D6   D0 1E      BNE $B5F6
B5D8   E4 33      CPX $33
B5DA   B0 1A      BCS $B5F6
B5DC   C5 60      CMP $60
B5DE   90 16      BCC $B5F6
B5E0   D0 04      BNE $B5E6
B5E2   E4 5F      CPX $5F
B5E4   90 10      BCC $B5F6
B5E6   86 5F      STX $5F
B5E8   85 60      STA $60
B5EA   A5 22      LDA $22
B5EC   A6 23      LDX $23
B5EE   85 4E      STA $4E
B5F0   86 4F      STX $4F
B5F2   A5 53      LDA $53
B5F4   85 55      STA $55
B5F6   A5 53      LDA $53
B5F8   18         CLC
B5F9   65 22      ADC $22
B5FB   85 22      STA $22
B5FD   90 02      BCC $B601
B5FF   E6 23      INC $23
B601   A6 23      LDX $23
B603   A0 00      LDY #$00
B605   60         RTS

; Garbagelöschung fortsetzen

B606   A5 4F      LDA $4F
B608   05 4E      ORA $4E
B60A   F0 F5      BEQ $B601
B60C   A5 55      LDA $55
B60E   29 04      AND #$04
B610   4A         LSR
B611   A8         TAY
B612   85 55      STA $55
B614   B1 4E      LDA ($4E),Y
B616   65 5F      ADC $5F
B618   85 5A      STA $5A
B61A   A5 60      LDA $60
B61C   69 00      ADC #$00
B61E   85 5B      STA $5B
B620   A5 33      LDA $33
B622   A6 34      LDX $34
B624   85 58      STA $58
B626   86 59      STX $59
B628   20 BF A3   JSR $A3BF
B62B   A4 55      LDY $55
B62D   C8         INY
B62E   A5 58      LDA $58
B630   91 4E      STA ($4E),Y
B632   AA         TAX
B633   E6 59      INC $59
B635   A5 59      LDA $59
B637   C8         INY
B638   91 4E      STA ($4E),Y
B63A   4C 2A B5   JMP $B52A

; Strings verbinden

B63D   A5 65      LDA $65
B63F   48         PHA
B640   A5 64      LDA $64
B642   48         PHA
B643   20 83 AE   JSR $AE83
B646   20 8F AD   JSR $AD8F
B649   68         PLA
B64A   85 6F      STA $6F
B64C   68         PLA
B64D   85 70      STA $70
B64F   A0 00      LDY #$00
B651   B1 6F      LDA ($6F),Y
B653   18         CLC
B654   71 64      ADC ($64),Y
B656   90 05      BCC $B65D
B658   A2 17      LDX #$17
B65A   4C 37 A4   JMP $A437
B65D   20 75 B4   JSR $B475
B660   20 7A B6   JSR $B67A
B663   A5 50      LDA $50
B665   A4 51      LDY $51
B667   20 AA B6   JSR $B6AA
B66A   20 8C B6   JSR $B68C
B66D   A5 6F      LDA $6F
B66F   A4 70      LDY $70
B671   20 AA B6   JSR $B6AA
B674   20 CA B4   JSR $B4CA
B677   4C B8 AD   JMP $ADB8

; String verschieben

B67A   A0 00      LDY #$00
B67C   B1 6F      LDA ($6F),Y
B67E   48         PHA
B67F   C8         INY
B680   B1 6F      LDA ($6F),Y
B682   AA         TAX
B683   C8         INY
B684   B1 6F      LDA ($6F),Y
B686   A8         TAY
B687   68         PLA

; verschiebt string mit der Länge A, Zeiger in XY

B688   86 22      STX $22
B68A   84 23      STY $23
B68C   A8         TAY
B68D   F0 0A      BEQ $B699
B68F   48         PHA
B690   88         DEY
B691   B1 22      LDA ($22),Y
B693   91 35      STA ($35),Y
B695   98         TYA
B696   D0 F8      BNE $B690
B698   68         PLA
B699   18         CLC
B69A   65 35      ADC $35
B69C   85 35      STA $35
B69E   90 02      BCC $B6A2
B6A0   E6 36      INC $36
B6A2   60         RTS

; temporären String freigeben

B6A3   20 8F AD   JSR $AD8F
B6A6   A5 64      LDA $64
B6A8   A4 65      LDY $65
B6AA   85 22      STA $22
B6AC   84 23      STY $23
B6AE   20 DB B6   JSR $B6DB
B6B1   08         PHP
B6B2   A0 00      LDY #$00
B6B4   B1 22      LDA ($22),Y
B6B6   48         PHA
B6B7   C8         INY
B6B8   B1 22      LDA ($22),Y
B6BA   AA         TAX
B6BB   C8         INY
B6BC   B1 22      LDA ($22),Y
B6BE   A8         TAY
B6BF   68         PLA
B6C0   28         PLP
B6C1   D0 13      BNE $B6D6
B6C3   C4 34      CPY $34
B6C5   D0 0F      BNE $B6D6
B6C7   E4 33      CPX $33
B6C9   D0 0B      BNE $B6D6
B6CB   48         PHA
B6CC   18         CLC
B6CD   65 33      ADC $33
B6CF   85 33      STA $33
B6D1   90 02      BCC $B6D5
B6D3   E6 34      INC $34
B6D5   68         PLA
B6D6   86 22      STX $22
B6D8   84 23      STY $23
B6DA   60         RTS

; Descriptor-Stack überprüfen

B6DB   C4 18      CPY $18
B6DD   D0 0C      BNE $B6EB
B6DF   C5 17      CMP $17
B6E1   D0 08      BNE $B6EB
B6E3   85 16      STA $16
B6E5   E9 03      SBC #$03
B6E7   85 17      STA $17
B6E9   A0 00      LDY #$00
B6EB   60         RTS

; CHR$-Funktion

B6EC   20 A1 B7   JSR $B7A1
B6EF   8A         TXA
B6F0   48         PHA
B6F1   A9 01      LDA #$01
B6F3   20 7D B4   JSR $B47D
B6F6   68         PLA
B6F7   A0 00      LDY #$00
B6F9   91 62      STA ($62),Y
B6FB   68         PLA
B6FC   68         PLA
B6FD   4C CA B4   JMP $B4CA

; LEFT$-Funktion

B700   20 61 B7   JSR $B761
B703   D1 50      CMP ($50),Y
B705   98         TYA
B706   90 04      BCC $B70C
B708   B1 50      LDA ($50),Y
B70A   AA         TAX
B70B   98         TYA
B70C   48         PHA
B70D   8A         TXA
B70E   48         PHA
B70F   20 7D B4   JSR $B47D
B712   A5 50      LDA $50
B714   A4 51      LDY $51
B716   20 AA B6   JSR $B6AA
B719   68         PLA
B71A   A8         TAY
B71B   68         PLA
B71C   18         CLC
B71D   65 22      ADC $22
B71F   85 22      STA $22
B721   90 02      BCC $B725
B723   E6 23      INC $23
B725   98         TYA
B726   20 8C B6   JSR $B68C
B729   4C CA B4   JMP $B4CA

; RIGHT$-Funktion

B72C   20 61 B7   JSR $B761
B72F   18         CLC
B730   F1 50      SBC ($50),Y
B732   49 FF      EOR #$FF
B734   4C 06 B7   JMP $B706

; MID$-Funktion

B737   A9 FF      LDA #$FF      ; default: 3 Parameter
B739   85 65      STA $65
B73B   20 79 00   JSR $0079
B73E   C9 29      CMP #$29      ; )
B740   F0 06      BEQ $B748
B742   20 FD AE   JSR $AEFD
B745   20 9E B7   JSR $B79E
B748   20 61 B7   JSR $B761
B74B   F0 4B      BEQ $B798
B74D   CA         DEX
B74E   8A         TXA
B74F   48         PHA
B750   18         CLC
B751   A2 00      LDX #$00
B753   F1 50      SBC ($50),Y
B755   B0 B6      BCS $B70D
B757   49 FF      EOR #$FF
B759   C5 65      CMP $65
B75B   90 B1      BCC $B70E
B75D   A5 65      LDA $65
B75F   B0 AD      BCS $B70E

; hole die ersten zwei Oarameter für LEFT$, RIGHT$ und MID$

B761   20 F7 AE   JSR $AEF7
B764   68         PLA
B765   A8         TAY
B766   68         PLA
B767   85 55      STA $55
B769   68         PLA
B76A   68         PLA
B76B   68         PLA
B76C   AA         TAX
B76D   68         PLA
B76E   85 50      STA $50
B770   68         PLA
B771   85 51      STA $51
B773   A5 55      LDA $55
B775   48         PHA
B776   98         TYA
B777   48         PHA
B778   A0 00      LDY #$00
B77A   8A         TXA
B77B   60         RTS

; LEN-Funktion

B77C   20 82 B7   JSR $B782
B77F   4C A2 B3   JMP $B3A2
B782   20 A3 B6   JSR $B6A3
B785   A2 00      LDX #$00
B787   86 0D      STX $0D
B789   A8         TAY
B78A   60         RTS

; ASC-Funktion

B78B   20 82 B7   JSR $B782
B78E   F0 08      BEQ $B798
B790   A0 00      LDY #$00
B792   B1 22      LDA ($22),Y
B794   A8         TAY
B795   4C A2 B3   JMP $B3A2
B798   4C 48 B2   JMP $B248

; Integerwert in X bringen und Bereich überprüfen

B79B   20 73 00   JSR $0073
B79E   20 8A AD   JSR $AD8A
B7A1   20 B8 B1   JSR $B1B8
B7A4   A6 64      LDX $64
B7A6   D0 F0      BNE $B798
B7A8   A6 65      LDX $65
B7AA   4C 79 00   JMP $0079

; VAL-Funktion

B7AD   20 82 B7   JSR $B782
B7B0   D0 03      BNE $B7B5
B7B2   4C F7 B8   JMP $B8F7
B7B5   A6 7A      LDX $7A
B7B7   A4 7B      LDY $7B
B7B9   86 71      STX $71
B7BB   84 72      STY $72
B7BD   A6 22      LDX $22
B7BF   86 7A      STX $7A
B7C1   18         CLC
B7C2   65 22      ADC $22
B7C4   85 24      STA $24
B7C6   A6 23      LDX $23
B7C8   86 7B      STX $7B
B7CA   90 01      BCC $B7CD
B7CC   E8         INX
B7CD   86 25      STX $25
B7CF   A0 00      LDY #$00
B7D1   B1 24      LDA ($24),Y
B7D3   48         PHA
B7D4   98         TYA
B7D5   91 24      STA ($24),Y
B7D7   20 79 00   JSR $0079
B7DA   20 F3 BC   JSR $BCF3
B7DD   68         PLA
B7DE   A0 00      LDY #$00
B7E0   91 24      STA ($24),Y
B7E2   A6 71      LDX $71
B7E4   A4 72      LDY $72
B7E6   86 7A      STX $7A
B7E8   84 7B      STY $7B
B7EA   60         RTS

; Adresse in $14/$15 schreiben und Integer in X

B7EB   20 8A AD   JSR $AD8A
B7EE   20 F7 B7   JSR $B7F7
B7F1   20 FD AE   JSR $AEFD
B7F4   4C 9E B7   JMP $B79E

; konvertiert Float-ti-integer in $14/$15

B7F7   A5 66      LDA $66
B7F9   30 9D      BMI $B798
B7FB   A5 61      LDA $61
B7FD   C9 91      CMP #$91
B7FF   B0 97      BCS $B798
B801   20 9B BC   JSR $BC9B
B804   A5 64      LDA $64
B806   A4 65      LDY $65
B808   84 14      STY $14
B80A   85 15      STA $15
B80C   60         RTS

; PEEK-Funktion

B80D   A5 15      LDA $15
B80F   48         PHA
B810   A5 14      LDA $14
B812   48         PHA
B813   20 F7 B7   JSR $B7F7
B816   A0 00      LDY #$00
B818   B1 14      LDA ($14),Y
B81A   A8         TAY
B81B   68         PLA
B81C   85 14      STA $14
B81E   68         PLA
B81F   85 15      STA $15
B821   4C A2 B3   JMP $B3A2

; POKE-Befehl

B824   20 EB B7   JSR $B7EB
B827   8A         TXA
B828   A0 00      LDY #$00
B82A   91 14      STA ($14),Y
B82C   60         RTS

; WAIT-Befehl

B82D   20 EB B7   JSR $B7EB
B830   86 49      STX $49
B832   A2 00      LDX #$00
B834   20 79 00   JSR $0079
B837   F0 03      BEQ $B83C
B839   20 F1 B7   JSR $B7F1
B83C   86 4A      STX $4A
B83E   A0 00      LDY #$00
B840   B1 14      LDA ($14),Y
B842   45 4A      EOR $4A
B844   25 49      AND $49
B846   F0 F8      BEQ $B840
B848   60         RTS

; addiert 0.5 zum Float-Akumulator (gerundet)

B849   A9 11      LDA #$11      ; low  BF11
B84B   A0 BF      LDY #$BF      ; high BF11
B84D   4C 67 B8   JMP $B867

; Minus-Operator

B850   20 8C BA   JSR $BA8C
B853   A5 66      LDA $66
B855   49 FF      EOR #$FF
B857   85 66      STA $66
B859   45 6E      EOR $6E
B85B   85 6F      STA $6F
B85D   A5 61      LDA $61
B85F   4C 6A B8   JMP $B86A
B862   20 99 B9   JSR $B999
B865   90 3C      BCC $B8A3

; addiert Float indiziert bei AY zum Float-Akumulator

B867   20 8C BA   JSR $BA8C

; Plus-Operator

B86A   D0 03      BNE $B86F
B86C   4C FC BB   JMP $BBFC
B86F   A6 70      LDX $70
B871   86 56      STX $56
B873   A2 69      LDX #$69
B875   A5 69      LDA $69
B877   A8         TAY
B878   F0 CE      BEQ $B848
B87A   38         SEC
B87B   E5 61      SBC $61
B87D   F0 24      BEQ $B8A3
B87F   90 12      BCC $B893
B881   84 61      STY $61
B883   A4 6E      LDY $6E
B885   84 66      STY $66
B887   49 FF      EOR #$FF
B889   69 00      ADC #$00
B88B   A0 00      LDY #$00
B88D   84 56      STY $56
B88F   A2 61      LDX #$61
B891   D0 04      BNE $B897
B893   A0 00      LDY #$00
B895   84 70      STY $70
B897   C9 F9      CMP #$F9
B899   30 C7      BMI $B862
B89B   A8         TAY
B89C   A5 70      LDA $70
B89E   56 01      LSR $01,X
B8A0   20 B0 B9   JSR $B9B0
B8A3   24 6F      BIT $6F
B8A5   10 57      BPL $B8FE
B8A7   A0 61      LDY #$61
B8A9   E0 69      CPX #$69
B8AB   F0 02      BEQ $B8AF
B8AD   A0 69      LDY #$69
B8AF   38         SEC
B8B0   49 FF      EOR #$FF
B8B2   65 56      ADC $56
B8B4   85 70      STA $70
B8B6   B9 04 00   LDA $0004,Y
B8B9   F5 04      SBC $04,X
B8BB   85 65      STA $65
B8BD   B9 03 00   LDA $0003,Y
B8C0   F5 03      SBC $03,X
B8C2   85 64      STA $64
B8C4   B9 02 00   LDA $0002,Y
B8C7   F5 02      SBC $02,X
B8C9   85 63      STA $63
B8CB   B9 01 00   LDA $0001,Y
B8CE   F5 01      SBC $01,X
B8D0   85 62      STA $62
B8D2   B0 03      BCS $B8D7
B8D4   20 47 B9   JSR $B947
B8D7   A0 00      LDY #$00
B8D9   98         TYA
B8DA   18         CLC
B8DB   A6 62      LDX $62
B8DD   D0 4A      BNE $B929
B8DF   A6 63      LDX $63
B8E1   86 62      STX $62
B8E3   A6 64      LDX $64
B8E5   86 63      STX $63
B8E7   A6 65      LDX $65
B8E9   86 64      STX $64
B8EB   A6 70      LDX $70
B8ED   86 65      STX $65
B8EF   84 70      STY $70
B8F1   69 08      ADC #$08
B8F3   C9 20      CMP #$20
B8F5   D0 E4      BNE $B8DB
B8F7   A9 00      LDA #$00
B8F9   85 61      STA $61
B8FB   85 66      STA $66
B8FD   60         RTS

; add fractions

B8FE   65 56      ADC $56
B900   85 70      STA $70
B902   A5 65      LDA $65
B904   65 6D      ADC $6D
B906   85 65      STA $65
B908   A5 64      LDA $64
B90A   65 6C      ADC $6C
B90C   85 64      STA $64
B90E   A5 63      LDA $63
B910   65 6B      ADC $6B
B912   85 63      STA $63
B914   A5 62      LDA $62
B916   65 6A      ADC $6A
B918   85 62      STA $62
B91A   4C 36 B9   JMP $B936

; postshift

B91D   69 01      ADC #$01
B91F   06 70      ASL $70
B921   26 65      ROL $65
B923   26 64      ROL $64
B925   26 63      ROL $63
B927   26 62      ROL $62
B929   10 F2      BPL $B91D
B92B   38         SEC
B92C   E5 61      SBC $61
B92E   B0 C7      BCS $B8F7
B930   49 FF      EOR #$FF
B932   69 01      ADC #$01
B934   85 61      STA $61
B936   90 0E      BCC $B946
B938   E6 61      INC $61
B93A   F0 42      BEQ $B97E
B93C   66 62      ROR $62
B93E   66 63      ROR $63
B940   66 64      ROR $64
B942   66 65      ROR $65
B944   66 70      ROR $70
B946   60         RTS

; Float-Akumulator negieren

B947   A5 66      LDA $66
B949   49 FF      EOR #$FF
B94B   85 66      STA $66
B94D   A5 62      LDA $62
B94F   49 FF      EOR #$FF
B951   85 62      STA $62
B953   A5 63      LDA $63
B955   49 FF      EOR #$FF
B957   85 63      STA $63
B959   A5 64      LDA $64
B95B   49 FF      EOR #$FF
B95D   85 64      STA $64
B95F   A5 65      LDA $65
B961   49 FF      EOR #$FF
B963   85 65      STA $65
B965   A5 70      LDA $70
B967   49 FF      EOR #$FF
B969   85 70      STA $70
B96B   E6 70      INC $70
B96D   D0 0E      BNE $B97D

; increment fraction

B96F   E6 65      INC $65
B971   D0 0A      BNE $B97D
B973   E6 64      INC $64
B975   D0 06      BNE $B97D
B977   E6 63      INC $63
B979   D0 02      BNE $B97D
B97B   E6 62      INC $62
B97D   60         RTS
B97E   A2 0F      LDX #$0F      ; Fehlernummer
B980   4C 37 A4   JMP $A437

; preshift

B983   A2 25      LDX #$25
B985   B4 04      LDY $04,X
B987   84 70      STY $70
B989   B4 03      LDY $03,X
B98B   94 04      STY $04,X
B98D   B4 02      LDY $02,X
B98F   94 03      STY $03,X
B991   B4 01      LDY $01,X
B993   94 02      STY $02,X
B995   A4 68      LDY $68
B997   94 01      STY $01,X
B999   69 08      ADC #$08
B99B   30 E8      BMI $B985
B99D   F0 E6      BEQ $B985
B99F   E9 08      SBC #$08
B9A1   A8         TAY
B9A2   A5 70      LDA $70
B9A4   B0 14      BCS $B9BA
B9A6   16 01      ASL $01,X
B9A8   90 02      BCC $B9AC
B9AA   F6 01      INC $01,X
B9AC   76 01      ROR $01,X
B9AE   76 01      ROR $01,X
B9B0   76 02      ROR $02,X
B9B2   76 03      ROR $03,X
B9B4   76 04      ROR $04,X
B9B6   6A         ROR
B9B7   C8         INY
B9B8   D0 EC      BNE $B9A6
B9BA   18         CLC
B9BB   60         RTS

; 1

B9BC   .BY $81,$00,$00,$00,$00

; LOG polynomial Tabelle

B9C1   .BY $03   ; degree 4
B9C2   .BY $7F,$5E,$56,$CB,$79
B9C7   .BY $80,$13,$9B,$0B,$64
B9CC   .BY $80,$76,$38,$93,$16
B9D1   .BY $82,$38,$AA,$3B,$20

; 0,5 * SQR(2)

B9D6   .BY $80,$35,$04,$F3,$34

; SQR(2)

B9DB   .BY $81,$35,$04,$F3,$34

; -0.5

B9E0   .BY $80,$80,$00,$00,$00

; LOG(2)

B9E5   .BY $80,$31,$72,$17,$F8

; LOG-Funktion

B9EA   20 2B BC   JSR $BC2B
B9ED   F0 02      BEQ $B9F1
B9EF   10 03      BPL $B9F4
B9F1   4C 48 B2   JMP $B248
B9F4   A5 61      LDA $61
B9F6   E9 7F      SBC #$7F
B9F8   48         PHA
B9F9   A9 80      LDA #$80
B9FB   85 61      STA $61
B9FD   A9 D6      LDA #$D6     ; low  B9D6
B9FF   A0 B9      LDY #$B9     ; high B9D6
BA01   20 67 B8   JSR $B867
BA04   A9 DB      LDA #$DB     ; low  B9DB
BA06   A0 B9      LDY #$B9     ; high B9DB
BA08   20 0F BB   JSR $BB0F
BA0B   A9 BC      LDA #$BC     ; low  B9BC
BA0D   A0 B9      LDY #$B9     ; high B9BC
BA0F   20 50 B8   JSR $B850
BA12   A9 C1      LDA #$C1     ; low  B9C1
BA14   A0 B9      LDY #$B9     ; high B9C1
BA16   20 43 E0   JSR $E043
BA19   A9 E0      LDA #$E0     ; low  B9E0
BA1B   A0 B9      LDY #$B9     ; high B9E0
BA1D   20 67 B8   JSR $B867
BA20   68         PLA
BA21   20 7E BD   JSR $BD7E
BA24   A9 E5      LDA #$E5      ; low  B9E5
BA26   A0 B9      LDY #$B9      ; high B9E5
BA28   20 8C BA   JSR $BA8C

; Mal-Operator

BA2B   D0 03      BNE $BA30
BA2D   4C 8B BA   JMP $BA8B
BA30   20 B7 BA   JSR $BAB7
BA33   A9 00      LDA #$00
BA35   85 26      STA $26
BA37   85 27      STA $27
BA39   85 28      STA $28
BA3B   85 29      STA $29
BA3D   A5 70      LDA $70
BA3F   20 59 BA   JSR $BA59
BA42   A5 65      LDA $65
BA44   20 59 BA   JSR $BA59
BA47   A5 64      LDA $64
BA49   20 59 BA   JSR $BA59
BA4C   A5 63      LDA $63
BA4E   20 59 BA   JSR $BA59
BA51   A5 62      LDA $62
BA53   20 5E BA   JSR $BA5E
BA56   4C 8F BB   JMP $BB8F
BA59   D0 03      BNE $BA5E
BA5B   4C 83 B9   JMP $B983
BA5E   4A         LSR
BA5F   09 80      ORA #$80
BA61   A8         TAY
BA62   90 19      BCC $BA7D
BA64   18         CLC
BA65   A5 29      LDA $29
BA67   65 6D      ADC $6D
BA69   85 29      STA $29
BA6B   A5 28      LDA $28
BA6D   65 6C      ADC $6C
BA6F   85 28      STA $28
BA71   A5 27      LDA $27
BA73   65 6B      ADC $6B
BA75   85 27      STA $27
BA77   A5 26      LDA $26
BA79   65 6A      ADC $6A
BA7B   85 26      STA $26
BA7D   66 26      ROR $26
BA7F   66 27      ROR $27
BA81   66 28      ROR $28
BA83   66 29      ROR $29
BA85   66 70      ROR $70
BA87   98         TYA
BA88   4A         LSR
BA89   D0 D6      BNE $BA61
BA8B   60         RTS

; Float indiziert bei AY in den sekundären Float-Akumulator verschieben

BA8C   85 22      STA $22
BA8E   84 23      STY $23
BA90   A0 04      LDY #$04
BA92   B1 22      LDA ($22),Y
BA94   85 6D      STA $6D
BA96   88         DEY
BA97   B1 22      LDA ($22),Y
BA99   85 6C      STA $6C
BA9B   88         DEY
BA9C   B1 22      LDA ($22),Y
BA9E   85 6B      STA $6B
BAA0   88         DEY
BAA1   B1 22      LDA ($22),Y
BAA3   85 6E      STA $6E
BAA5   45 66      EOR $66
BAA7   85 6F      STA $6F
BAA9   A5 6E      LDA $6E
BAAB   09 80      ORA #$80
BAAD   85 6A      STA $6A
BAAF   88         DEY
BAB0   B1 22      LDA ($22),Y
BAB2   85 69      STA $69
BAB4   A5 61      LDA $61
BAB6   60         RTS

; add exponents

BAB7   A5 69      LDA $69
BAB9   F0 1F      BEQ $BADA
BABB   18         CLC
BABC   65 61      ADC $61
BABE   90 04      BCC $BAC4
BAC0   30 1D      BMI $BADF
BAC2   18         CLC
BAC3   .BY $2C
BAC4   10 14      BPL $BADA
BAC6   69 80      ADC #$80
BAC8   85 61      STA $61
BACA   D0 03      BNE $BACF
BACC   4C FB B8   JMP $B8FB
BACF   A5 6F      LDA $6F
BAD1   85 66      STA $66
BAD3   60         RTS
BAD4   A5 66      LDA $66
BAD6   49 FF      EOR #$FF
BAD8   30 05      BMI $BADF
BADA   68         PLA
BADB   68         PLA
BADC   4C F7 B8   JMP $B8F7
BADF   4C 7E B9   JMP $B97E

; Float-Akumulator mit 10 multiplizieren

BAE2   20 0C BC   JSR $BC0C
BAE5   AA         TAX
BAE6   F0 10      BEQ $BAF8
BAE8   18         CLC
BAE9   69 02      ADC #$02
BAEB   B0 F2      BCS $BADF
BAED   A2 00      LDX #$00
BAEF   86 6F      STX $6F
BAF1   20 77 B8   JSR $B877
BAF4   E6 61      INC $61
BAF6   F0 E7      BEQ $BADF
BAF8   60         RTS

; Konstante 10 für Division

BAF9   .BY $84,$20,$00,$00,$00

; divitiert Float durch 10

BAFE   20 0C BC   JSR $BC0C
BB01   A9 F9      LDA #$F9      ; low  BAF9
BB03   A0 BA      LDY #$BA      ; high BAF9
BB05   A2 00      LDX #$00
BB07   86 6F      STX $6F
BB09   20 A2 BB   JSR $BBA2
BB0C   4C 12 BB   JMP $BB12

; dividiert Zahl indiziert bei AY un dem Float-akumulator

BB0F   20 8C BA   JSR $BA8C

; dividiert Operator

BB12   F0 76      BEQ $BB8A
BB14   20 1B BC   JSR $BC1B
BB17   A9 00      LDA #$00
BB19   38         SEC
BB1A   E5 61      SBC $61
BB1C   85 61      STA $61
BB1E   20 B7 BA   JSR $BAB7
BB21   E6 61      INC $61
BB23   F0 BA      BEQ $BADF
BB25   A2 FC      LDX #$FC
BB27   A9 01      LDA #$01
BB29   A4 6A      LDY $6A
BB2B   C4 62      CPY $62
BB2D   D0 10      BNE $BB3F
BB2F   A4 6B      LDY $6B
BB31   C4 63      CPY $63
BB33   D0 0A      BNE $BB3F
BB35   A4 6C      LDY $6C
BB37   C4 64      CPY $64
BB39   D0 04      BNE $BB3F
BB3B   A4 6D      LDY $6D
BB3D   C4 65      CPY $65
BB3F   08         PHP
BB40   2A         ROL
BB41   90 09      BCC $BB4C
BB43   E8         INX
BB44   95 29      STA $29,X
BB46   F0 32      BEQ $BB7A
BB48   10 34      BPL $BB7E
BB4A   A9 01      LDA #$01
BB4C   28         PLP
BB4D   B0 0E      BCS $BB5D
BB4F   06 6D      ASL $6D
BB51   26 6C      ROL $6C
BB53   26 6B      ROL $6B
BB55   26 6A      ROL $6A
BB57   B0 E6      BCS $BB3F
BB59   30 CE      BMI $BB29
BB5B   10 E2      BPL $BB3F
BB5D   A8         TAY
BB5E   A5 6D      LDA $6D
BB60   E5 65      SBC $65
BB62   85 6D      STA $6D
BB64   A5 6C      LDA $6C
BB66   E5 64      SBC $64
BB68   85 6C      STA $6C
BB6A   A5 6B      LDA $6B
BB6C   E5 63      SBC $63
BB6E   85 6B      STA $6B
BB70   A5 6A      LDA $6A
BB72   E5 62      SBC $62
BB74   85 6A      STA $6A
BB76   98         TYA
BB77   4C 4F BB   JMP $BB4F
BB7A   A9 40      LDA #$40
BB7C   D0 CE      BNE $BB4C
BB7E   0A         ASL
BB7F   0A         ASL
BB80   0A         ASL
BB81   0A         ASL
BB82   0A         ASL
BB83   0A         ASL
BB84   85 70      STA $70
BB86   28         PLP
BB87   4C 8F BB   JMP $BB8F
BB8A   A2 14      LDX #$14      ; Fehlernummer
BB8C   4C 37 A4   JMP $A437
BB8F   A5 26      LDA $26
BB91   85 62      STA $62
BB93   A5 27      LDA $27
BB95   85 63      STA $63
BB97   A5 28      LDA $28
BB99   85 64      STA $64
BB9B   A5 29      LDA $29
BB9D   85 65      STA $65
BB9F   4C D7 B8   JMP $B8D7
BBA2   85 22      STA $22
BBA4   84 23      STY $23
BBA6   A0 04      LDY #$04
BBA8   B1 22      LDA ($22),Y
BBAA   85 65      STA $65
BBAC   88         DEY
BBAD   B1 22      LDA ($22),Y
BBAF   85 64      STA $64
BBB1   88         DEY
BBB2   B1 22      LDA ($22),Y
BBB4   85 63      STA $63
BBB6   88         DEY
BBB7   B1 22      LDA ($22),Y
BBB9   85 66      STA $66
BBBB   09 80      ORA #$80
BBBD   85 62      STA $62
BBBF   88         DEY
BBC0   B1 22      LDA ($22),Y
BBC2   85 61      STA $61
BBC4   84 70      STY $70
BBC6   60         RTS

; Float-Akumulator in $5C-$60 speichern

BBC7   A2 5C      LDX #$5C      ; low  005C
BBC9   .BY $2C

; Float-Akumulator in $57-$5B speichern

BBCA   A2 57      LDX #$57      ; low  0057
BBCC   A0 00      LDY #$00      ; high 0057
BBCE   F0 04      BEQ $BBD4

; speichert Float-Akumulator auf Index in $49/$4A

BBD0   A6 49      LDX $49
BBD2   A4 4A      LDY $4A

; speichert Float-Akumulator in Index in XY

BBD4   20 1B BC   JSR $BC1B
BBD7   86 22      STX $22
BBD9   84 23      STY $23
BBDB   A0 04      LDY #$04
BBDD   A5 65      LDA $65
BBDF   91 22      STA ($22),Y
BBE1   88         DEY
BBE2   A5 64      LDA $64
BBE4   91 22      STA ($22),Y
BBE6   88         DEY
BBE7   A5 63      LDA $63
BBE9   91 22      STA ($22),Y
BBEB   88         DEY
BBEC   A5 66      LDA $66
BBEE   09 7F      ORA #$7F
BBF0   25 62      AND $62
BBF2   91 22      STA ($22),Y
BBF4   88         DEY
BBF5   A5 61      LDA $61
BBF7   91 22      STA ($22),Y
BBF9   84 70      STY $70
BBFB   60         RTS

; verschiebt sekundären Float-Akumulator in den primären

BBFC   A5 6E      LDA $6E
BBFE   85 66      STA $66
BC00   A2 05      LDX #$05
BC02   B5 68      LDA $68,X
BC04   95 60      STA $60,X
BC06   CA         DEX
BC07   D0 F9      BNE $BC02
BC09   86 70      STX $70
BC0B   60         RTS

; verschiebt gerundeten Float-Akumulator in den sekundären

BC0C   20 1B BC   JSR $BC1B
BC0F   A2 06      LDX #$06
BC11   B5 60      LDA $60,X
BC13   95 68      STA $68,X
BC15   CA         DEX
BC16   D0 F9      BNE $BC11
BC18   86 70      STX $70
BC1A   60         RTS

; rundet Float-Akumulator entsprechend 'guard bit'

BC1B   A5 61      LDA $61
BC1D   F0 FB      BEQ $BC1A
BC1F   06 70      ASL $70
BC21   90 F7      BCC $BC1A
BC23   20 6F B9   JSR $B96F
BC26   D0 F2      BNE $BC1A
BC28   4C 38 B9   JMP $B938

; Vorzeichen des Float-Akumulators in A holen

BC2B   A5 61      LDA $61
BC2D   F0 09      BEQ $BC38
BC2F   A5 66      LDA $66
BC31   2A         ROL
BC32   A9 FF      LDA #$FF
BC34   B0 02      BCS $BC38
BC36   A9 01      LDA #$01
BC38   60         RTS

; SGN-Funktion

BC39   20 2B BC   JSR $BC2B

; signed Wert von A in den Float-Akumulator vercshieben

BC3C   85 62      STA $62
BC3E   A9 00      LDA #$00
BC40   85 63      STA $63
BC42   A2 88      LDX #$88
BC44   A5 62      LDA $62
BC46   49 FF      EOR #$FF
BC48   2A         ROL
BC49   A9 00      LDA #$00
BC4B   85 65      STA $65
BC4D   85 64      STA $64
BC4F   86 61      STX $61
BC51   85 70      STA $70
BC53   85 66      STA $66
BC55   4C D2 B8   JMP $B8D2

; ABS-Funktion

BC58   46 66      LSR $66
BC5A   60         RTS

; vergleicht Float-Akumulator mit Float indiziert bei XY

BC5B   85 24      STA $24
BC5D   84 25      STY $25
BC5F   A0 00      LDY #$00
BC61   B1 24      LDA ($24),Y
BC63   C8         INY
BC64   AA         TAX
BC65   F0 C4      BEQ $BC2B
BC67   B1 24      LDA ($24),Y
BC69   45 66      EOR $66
BC6B   30 C2      BMI $BC2F
BC6D   E4 61      CPX $61
BC6F   D0 21      BNE $BC92
BC71   B1 24      LDA ($24),Y
BC73   09 80      ORA #$80
BC75   C5 62      CMP $62
BC77   D0 19      BNE $BC92
BC79   C8         INY
BC7A   B1 24      LDA ($24),Y
BC7C   C5 63      CMP $63
BC7E   D0 12      BNE $BC92
BC80   C8         INY
BC81   B1 24      LDA ($24),Y
BC83   C5 64      CMP $64
BC85   D0 0B      BNE $BC92
BC87   C8         INY
BC88   A9 7F      LDA #$7F
BC8A   C5 70      CMP $70
BC8C   B1 24      LDA ($24),Y
BC8E   E5 65      SBC $65
BC90   F0 28      BEQ $BCBA
BC92   A5 66      LDA $66
BC94   90 02      BCC $BC98
BC96   49 FF      EOR #$FF
BC98   4C 31 BC   JMP $BC31

; konvertiert Float in ein 4 Byte signed Integer

BC9B   A5 61      LDA $61
BC9D   F0 4A      BEQ $BCE9
BC9F   38         SEC
BCA0   E9 A0      SBC #$A0
BCA2   24 66      BIT $66
BCA4   10 09      BPL $BCAF
BCA6   AA         TAX
BCA7   A9 FF      LDA #$FF
BCA9   85 68      STA $68
BCAB   20 4D B9   JSR $B94D
BCAE   8A         TXA
BCAF   A2 61      LDX #$61
BCB1   C9 F9      CMP #$F9
BCB3   10 06      BPL $BCBB
BCB5   20 99 B9   JSR $B999
BCB8   84 68      STY $68
BCBA   60         RTS
BCBB   A8         TAY
BCBC   A5 66      LDA $66
BCBE   29 80      AND #$80
BCC0   46 62      LSR $62
BCC2   05 62      ORA $62
BCC4   85 62      STA $62
BCC6   20 B0 B9   JSR $B9B0
BCC9   84 68      STY $68
BCCB   60         RTS

; INT-Funktion

BCCC   A5 61      LDA $61
BCCE   C9 A0      CMP #$A0
BCD0   B0 20      BCS $BCF2
BCD2   20 9B BC   JSR $BC9B
BCD5   84 70      STY $70
BCD7   A5 66      LDA $66
BCD9   84 66      STY $66
BCDB   49 80      EOR #$80
BCDD   2A         ROL
BCDE   A9 A0      LDA #$A0
BCE0   85 61      STA $61
BCE2   A5 65      LDA $65
BCE4   85 07      STA $07
BCE6   4C D2 B8   JMP $B8D2

; Float-Akumulator löschen

BCE9   85 62      STA $62
BCEB   85 63      STA $63
BCED   85 64      STA $64
BCEF   85 65      STA $65
BCF1   A8         TAY
BCF2   60         RTS

; konvertiert String in Float und schreibt ihn in den Float-Akumulator

BCF3   A0 00      LDY #$00
BCF5   A2 0A      LDX #$0A
BCF7   94 5D      STY $5D,X
BCF9   CA         DEX
BCFA   10 FB      BPL $BCF7
BCFC   90 0F      BCC $BD0D
BCFE   C9 2D      CMP #$2D      ; Minus
BD00   D0 04      BNE $BD06
BD02   86 67      STX $67
BD04   F0 04      BEQ $BD0A
BD06   C9 2B      CMP #$2B      ; Plus
BD08   D0 05      BNE $BD0F
BD0A   20 73 00   JSR $0073
BD0D   90 5B      BCC $BD6A
BD0F   C9 2E      CMP #$2E      ; dezimaler Punkt
BD11   F0 2E      BEQ $BD41
BD13   C9 45      CMP #$45      ; E
BD15   D0 30      BNE $BD47
BD17   20 73 00   JSR $0073
BD1A   90 17      BCC $BD33
BD1C   C9 AB      CMP #$AB      ; Minus-Code
BD1E   F0 0E      BEQ $BD2E
BD20   C9 2D      CMP #$2D      ; Minus
BD22   F0 0A      BEQ $BD2E
BD24   C9 AA      CMP #$AA      ; Plus-Code
BD26   F0 08      BEQ $BD30
BD28   C9 2B      CMP #$2B      ; Plus
BD2A   F0 04      BEQ $BD30
BD2C   D0 07      BNE $BD35
BD2E   66 60      ROR $60
BD30   20 73 00   JSR $0073
BD33   90 5C      BCC $BD91
BD35   24 60      BIT $60
BD37   10 0E      BPL $BD47
BD39   A9 00      LDA #$00
BD3B   38         SEC
BD3C   E5 5E      SBC $5E
BD3E   4C 49 BD   JMP $BD49
BD41   66 5F      ROR $5F
BD43   24 5F      BIT $5F
BD45   50 C3      BVC $BD0A
BD47   A5 5E      LDA $5E
BD49   38         SEC
BD4A   E5 5D      SBC $5D
BD4C   85 5E      STA $5E
BD4E   F0 12      BEQ $BD62
BD50   10 09      BPL $BD5B
BD52   20 FE BA   JSR $BAFE
BD55   E6 5E      INC $5E
BD57   D0 F9      BNE $BD52
BD59   F0 07      BEQ $BD62
BD5B   20 E2 BA   JSR $BAE2
BD5E   C6 5E      DEC $5E
BD60   D0 F9      BNE $BD5B
BD62   A5 67      LDA $67
BD64   30 01      BMI $BD67
BD66   60         RTS
BD67   4C B4 BF   JMP $BFB4
BD6A   48         PHA
BD6B   24 5F      BIT $5F
BD6D   10 02      BPL $BD71
BD6F   E6 5D      INC $5D
BD71   20 E2 BA   JSR $BAE2
BD74   68         PLA
BD75   38         SEC
BD76   E9 30      SBC #$30      ; 0
BD78   20 7E BD   JSR $BD7E
BD7B   4C 0A BD   JMP $BD0A

; addiert signed Integer von A zum Float-Akumulator

BD7E   48         PHA
BD7F   20 0C BC   JSR $BC0C
BD82   68         PLA
BD83   20 3C BC   JSR $BC3C
BD86   A5 6E      LDA $6E
BD88   45 66      EOR $66
BD8A   85 6F      STA $6F
BD8C   A6 61      LDX $61
BD8E   4C 6A B8   JMP $B86A

; holt die Anzahl der Werte aus einem String

BD91   A5 5E      LDA $5E
BD93   C9 0A      CMP #$0A
BD95   90 09      BCC $BDA0
BD97   A9 64      LDA #$64
BD99   24 60      BIT $60
BD9B   30 11      BMI $BDAE
BD9D   4C 7E B9   JMP $B97E
BDA0   0A         ASL
BDA1   0A         ASL
BDA2   18         CLC
BDA3   65 5E      ADC $5E
BDA5   0A         ASL
BDA6   18         CLC
BDA7   A0 00      LDY #$00
BDA9   71 7A      ADC ($7A),Y
BDAB   38         SEC
BDAC   E9 30      SBC #$30      ; 0
BDAE   85 5E      STA $5E
BDB0   4C 30 BD   JMP $BD30

; Konstanten für Float in String Konvertierung

BDB3   .BY $9B,$3E,$BC,$1F,$FD
BDB8   .BY $9E,$6E,$6B,$27,$FD
BDBD   .BY $9E,$6E,$6B,$28,$00

; gibt IN, gefolgt von der Zeilennummer aus

BDC2   A9 71      LDA #$71      ; low  A371
BDC4   A0 A3      LDY #$A3      ; high A371
BDC6   20 DA BD   JSR $BDDA
BDC9   A5 3A      LDA $3A
BDCB   A6 39      LDX $39

; gibt Zahl von AX aus

BDCD   85 62      STA $62
BDCF   86 63      STX $63
BDD1   A2 90      LDX #$90
BDD3   38         SEC
BDD4   20 49 BC   JSR $BC49
BDD7   20 DF BD   JSR $BDDF
BDDA   4C 1E AB   JMP $AB1E

; konvertiert Zahl im Float-Akumulator in einen String

BDDD   A0 01      LDY #$01
BDDF   A9 20      LDA #$20
BDE1   24 66      BIT $66
BDE3   10 02      BPL $BDE7
BDE5   A9 2D      LDA #$2D      ; Minus
BDE7   99 FF 00   STA $00FF,Y
BDEA   85 66      STA $66
BDEC   84 71      STY $71
BDEE   C8         INY
BDEF   A9 30      LDA #$30      ; 0
BDF1   A6 61      LDX $61
BDF3   D0 03      BNE $BDF8
BDF5   4C 04 BF   JMP $BF04
BDF8   A9 00      LDA #$00
BDFA   E0 80      CPX #$80
BDFC   F0 02      BEQ $BE00
BDFE   B0 09      BCS $BE09
BE00   A9 BD      LDA #$BD      ; low  BDBD
BE02   A0 BD      LDY #$BD      ; high BDBD
BE04   20 28 BA   JSR $BA28
BE07   A9 F7      LDA #$F7
BE09   85 5D      STA $5D
BE0B   A9 B8      LDA #$B8      ; low  BDB8
BE0D   A0 BD      LDY #$BD      ; high BDB8
BE0F   20 5B BC   JSR $BC5B
BE12   F0 1E      BEQ $BE32
BE14   10 12      BPL $BE28
BE16   A9 B3      LDA #$B3      ; low  BDB3
BE18   A0 BD      LDY #$BD      ; high BDB3
BE1A   20 5B BC   JSR $BC5B
BE1D   F0 02      BEQ $BE21
BE1F   10 0E      BPL $BE2F
BE21   20 E2 BA   JSR $BAE2
BE24   C6 5D      DEC $5D
BE26   D0 EE      BNE $BE16
BE28   20 FE BA   JSR $BAFE
BE2B   E6 5D      INC $5D
BE2D   D0 DC      BNE $BE0B
BE2F   20 49 B8   JSR $B849
BE32   20 9B BC   JSR $BC9B
BE35   A2 01      LDX #$01
BE37   A5 5D      LDA $5D
BE39   18         CLC
BE3A   69 0A      ADC #$0A
BE3C   30 09      BMI $BE47
BE3E   C9 0B      CMP #$0B
BE40   B0 06      BCS $BE48
BE42   69 FF      ADC #$FF
BE44   AA         TAX
BE45   A9 02      LDA #$02
BE47   38         SEC
BE48   E9 02      SBC #$02
BE4A   85 5E      STA $5E
BE4C   86 5D      STX $5D
BE4E   8A         TXA
BE4F   F0 02      BEQ $BE53
BE51   10 13      BPL $BE66
BE53   A4 71      LDY $71
BE55   A9 2E      LDA #$2E      ; dezimaler Punkt
BE57   C8         INY
BE58   99 FF 00   STA $00FF,Y
BE5B   8A         TXA
BE5C   F0 06      BEQ $BE64
BE5E   A9 30      LDA #$30      ; 0
BE60   C8         INY
BE61   99 FF 00   STA $00FF,Y
BE64   84 71      STY $71
BE66   A0 00      LDY #$00
BE68   A2 80      LDX #$80
BE6A   A5 65      LDA $65
BE6C   18         CLC
BE6D   79 19 BF   ADC $BF19,Y
BE70   85 65      STA $65
BE72   A5 64      LDA $64
BE74   79 18 BF   ADC $BF18,Y
BE77   85 64      STA $64
BE79   A5 63      LDA $63
BE7B   79 17 BF   ADC $BF17,Y
BE7E   85 63      STA $63
BE80   A5 62      LDA $62
BE82   79 16 BF   ADC $BF16,Y
BE85   85 62      STA $62
BE87   E8         INX
BE88   B0 04      BCS $BE8E
BE8A   10 DE      BPL $BE6A
BE8C   30 02      BMI $BE90
BE8E   30 DA      BMI $BE6A
BE90   8A         TXA
BE91   90 04      BCC $BE97
BE93   49 FF      EOR #$FF
BE95   69 0A      ADC #$0A
BE97   69 2F      ADC #$2F
BE99   C8         INY
BE9A   C8         INY
BE9B   C8         INY
BE9C   C8         INY
BE9D   84 47      STY $47
BE9F   A4 71      LDY $71
BEA1   C8         INY
BEA2   AA         TAX
BEA3   29 7F      AND #$7F
BEA5   99 FF 00   STA $00FF,Y
BEA8   C6 5D      DEC $5D
BEAA   D0 06      BNE $BEB2
BEAC   A9 2E      LDA #$2E
BEAE   C8         INY
BEAF   99 FF 00   STA $00FF,Y
BEB2   84 71      STY $71
BEB4   A4 47      LDY $47
BEB6   8A         TXA
BEB7   49 FF      EOR #$FF
BEB9   29 80      AND #$80
BEBB   AA         TAX
BEBC   C0 24      CPY #$24
BEBE   F0 04      BEQ $BEC4
BEC0   C0 3C      CPY #$3C
BEC2   D0 A6      BNE $BE6A
BEC4   A4 71      LDY $71
BEC6   B9 FF 00   LDA $00FF,Y
BEC9   88         DEY
BECA   C9 30      CMP #$30      ; 0
BECC   F0 F8      BEQ $BEC6
BECE   C9 2E      CMP #$2E      ; dezimaler Punkt
BED0   F0 01      BEQ $BED3
BED2   C8         INY
BED3   A9 2B      LDA #$2B      ; Plus
BED5   A6 5E      LDX $5E
BED7   F0 2E      BEQ $BF07
BED9   10 08      BPL $BEE3
BEDB   A9 00      LDA #$00
BEDD   38         SEC
BEDE   E5 5E      SBC $5E
BEE0   AA         TAX
BEE1   A9 2D      LDA #$2D      ; Minus
BEE3   99 01 01   STA $0101,Y
BEE6   A9 45      LDA #$45
BEE8   99 00 01   STA $0100,Y
BEEB   8A         TXA
BEEC   A2 2F      LDX #$2F
BEEE   38         SEC
BEEF   E8         INX
BEF0   E9 0A      SBC #$0A
BEF2   B0 FB      BCS $BEEF
BEF4   69 3A      ADC #$3A
BEF6   99 03 01   STA $0103,Y
BEF9   8A         TXA
BEFA   99 02 01   STA $0102,Y
BEFD   A9 00      LDA #$00
BEFF   99 04 01   STA $0104,Y
BF02   F0 08      BEQ $BF0C
BF04   99 FF 00   STA $00FF,Y
BF07   A9 00      LDA #$00
BF09   99 00 01   STA $0100,Y
BF0C   A9 00      LDA #$00      ; low  0100
BF0E   A0 01      LDY #$01      ; high 0100
BF10   60         RTS

; 0.5

BF11   .BY $80,$00,$00,$00,$00

; Divisors für dezimale Konvertierung

BF16   .BY $FA,$0A,$1F,$00
BF1A   .BY $00,$98,$96,$80
BF1E   .BY $FF,$F0,$BD,$C0
BF22   .BY $00,$01,$86,$A0
BF26   .BY $FF,$FF,$D8,$F0
BF2A   .BY $00,$00,$03,$E8
BF2E   .BY $FF,$FF,$FF,$9C
BF32   .BY $00,$00,$00,$0A
BF36   .BY $FF,$FF,$FF,$FF

; Divisors für Mal-Konvertierung

BF3A   .BY $FF,$DF,$0A,$80
BF3E   .BY $00,$03,$4B,$C0
BF42   .BY $FF,$FF,$73,$60
BF46   .BY $00,$00,$0E,$10
BF4A   .BY $FF,$FF,$FD,$A8
BF4E   .BY $00,$00,$00,$3C

; offiziell unbenutzt, möglicherweise eine Versions-ID

BF52   .BY $EC

; unbenutzt

BF53   .BY $AA,$AA,$AA,$AA,$AA,$AA,$AA,$AA
BF5B   .BY $AA,$AA,$AA,$AA,$AA,$AA,$AA,$AA
BF63   .BY $AA,$AA,$AA,$AA,$AA,$AA,$AA,$AA
BF6B   .BY $AA,$AA,$AA,$AA,$AA,$AA

; SQR-Funktion

BF71   20 0C BC   JSR $BC0C
BF74   A9 11      LDA #$11
BF76   A0 BF      LDY #$BF
BF78   20 A2 BB   JSR $BBA2

; Hoch-Operator

BF7B   F0 70      BEQ $BFED
BF7D   A5 69      LDA $69
BF7F   D0 03      BNE $BF84
BF81   4C F9 B8   JMP $B8F9
BF84   A2 4E      LDX #$4E      ; low  004E
BF86   A0 00      LDY #$00      ; high 004E
BF88   20 D4 BB   JSR $BBD4
BF8B   A5 6E      LDA $6E
BF8D   10 0F      BPL $BF9E
BF8F   20 CC BC   JSR $BCCC
BF92   A9 4E      LDA #$4E      ; low  004E
BF94   A0 00      LDY #$00      ; high 004E
BF96   20 5B BC   JSR $BC5B
BF99   D0 03      BNE $BF9E
BF9B   98         TYA
BF9C   A4 07      LDY $07
BF9E   20 FE BB   JSR $BBFE
BFA1   98         TYA
BFA2   48         PHA
BFA3   20 EA B9   JSR $B9EA
BFA6   A9 4E      LDA #$4E      ; low  004E
BFA8   A0 00      LDY #$00      ; high 004E
BFAA   20 28 BA   JSR $BA28
BFAD   20 ED BF   JSR $BFED
BFB0   68         PLA
BFB1   4A         LSR
BFB2   90 0A      BCC $BFBE

; Minus-Operator

BFB4   A5 61      LDA $61
BFB6   F0 06      BEQ $BFBE
BFB8   A5 66      LDA $66
BFBA   49 FF      EOR #$FF
BFBC   85 66      STA $66
BFBE   60         RTS

; Floatingpoint Konstanten für EXP

; 1/LOG(2)

BFBF   .BY $81,$38,$AA,$3B,$29

; EXP polynomial Tabelle

BFC4   .BY $07                  ; degree 8
BFC5   .BY $71,$34,$58,$3E,$56
BFCA   .BY $74,$16,$7E,$B3,$1B
BFCF   .BY $77,$2F,$EE,$E3,$85
BFD4   .BY $7A,$1D,$84,$1C,$2A
BFD9   .BY $7C,$63,$59,$58,$0A
BFDE   .BY $7E,$75,$FD,$E7,$C6
BFE3   .BY $80,$31,$72,$18,$10
BFE8   .BY $81,$00,$00,$00,$00

; EXP-Befehl

BFED   A9 BF      LDA #$BF
BFEF   A0 BF      LDY #$BF
BFF1   20 28 BA   JSR $BA28
BFF4   A5 70      LDA $70
BFF6   69 50      ADC #$50
BFF8   90 03      BCC $BFFD
BFFA   20 23 BC   JSR $BC23
BFFD   4C 00 E0   JMP $E000     ; weiter im Kernal-ROM