// Apple 1 Basic 1976
// 2002 captured from a tape sound file and 
// disassembled by Achim Breidenbach achim@boinx.com
// Thanks to Larry Nelson for the sound-file

// Choose "Load Memory.." in File menu to laad the programm

// Echo to screen:
//#type "e000R"+<ENTER> to run the Basic


// Adress 0x0200 + is used as input-buffer for the command line interpreter
// 0xF1 => Length of Input Buffer + 1
// own stack at CF??
// e0/e1 pointer to ?
// e2/e3 Pointer to?
// e4/e5 Pointer with relation to e2/e3-pointer
// e6/e7 Pointer with relation to e2/e3-pointer
// ca/cb Pointer with relation to e2/e3-pointer
// 4c/4d Pointer with relation to e6/e7-pointer
// dc/dd Program-Counter of basic line numbers??

E000: 4C B0 E2 //Start:      JMP  E2B0     Jump to new location

E003: AD 11 D0 //Input:      LDA  D011     Load accumulator with keyboard register
E006: 10 FB    //            BPL  Input    was a key pressed?
E008: AD 10 D0 //            LDA  D010     Load key into accumulator
E00B: 60       //            RTS           Return from subroutine

E00C: 8A       //            TXA           Transfer index X to accumulator
E00D: 29 20    //            AND #20       'AND' memory with accumulator
E00F: F0 23    //            BEQ  Return   Branch on result zero
E011: A9 A0    //            LDA #A0       Load accumulator with memory
E013: 85 E4    //            STA  E4       Store accumulator in memory
E015: 4C C9 E3 //            JMP  CharOut  Jump to new location

E018: A9 20    //OutpSmthng: LDA #20       if Memory(0x24)=Space then goto GetNext??
E01A: C5 24    //            CMP  24       
E01C: B0 0C    //            BCS  GetNext??
E01E: A9 8D    //            LDA #8D       Load accumulator with <RETURN>
E020: A0 07    //            LDY #07       Load index Y with 7
E022: 20 C9 E3 //DoNext:     JSR  CharOut  Jump to new location saving return address
E025: A9 A0    //            LDA #A0       Load accumulator with memory
E027: 88       //            DEY           y=y-1
E028: D0 F8    //            BNE  DoNext   repeat until y=0
E02A: A0 00    //GetNext??:  LDY #00       y=0
E02C: B1 E2    //            LDA (E2),Y    Load accumulator with memory
E02E: E6 E2    //            INC  E2       Increment memory by one
E030: D0 02    //            BNE  02       Branch on result not zero
E032: E6 E3    //            INC  E3       Increment memory by one
E034: 60       //Return:     RTS           Return from subroutine

E035: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E038: 20 76 E5 //            JSR  E576     Jump to new location saving return address
E03B: A5 E2    //Loop:       LDA  E2       Load accumulator with memory
E03D: C5 E6    //            CMP  E6       Compare memory and accumulator
E03F: A5 E3    //            LDA  E3       Load accumulator with memory
E041: E5 E7    //            SBC  E7       Subtrac memory from accumulator with borrow
E043: B0 EF    //            BCS  EF       Branch on carry set
E045: 20 6D E0 //            JSR  E06D     Jump to new location saving return address
E048: 4C 3B E0 //            JMP  Loop     Jump to new location

E04B: A5 CA    //            LDA  CA       Copy ca/cb-Pointer to e2/e3
E04D: 85 E2    //            STA  E2       
E04F: A5 CB    //            LDA  CB       
E051: 85 E3    //            STA  E3       
E053: A5 4C    //            LDA  4C       Copy 4c/4d-Pointer to e6/e7
E055: 85 E6    //            STA  E6       
E057: A5 4D    //            LDA  4D       
E059: 85 E7    //            STA  E7       
E05B: D0 DE    //            BNE  DE       Branch on result not zero (to E036????)
E05D: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E060: 20 6D E5 //            JSR  E56D     Jump to new location saving return address
E063: A5 E4    //            LDA  E4       Copy e4/e5-Pointer to e2/e3
E065: 85 E2    //            STA  E2       
E067: A5 E5    //            LDA  E5       
E069: 85 E3    //            STA  E3       
E06B: B0 C7    //            BCS  Return   Branch on carry set
E06D: 86 D8    //            STX  D8       Store index X in memory
E06F: A9 A0    //            LDA #A0       Load accumulator with memory
E071: 85 FA    //            STA  FA       Store accumulator in memory
E073: 20 2A E0 //            JSR  GetNext??  Get Next ??? and increment e2/e3 Pointer
E076: 98       //            TYA           Transfer index Y to accumulator
E077: 85 E4    //            STA  E4       Store accumulator in memory
E079: 20 2A E0 //            JSR  GetNext??  Get Next ??? and increment e2/e3 Pointer
E07C: AA       //            TAX           Transfer accumulator to index X
E07D: 20 2A E0 //            JSR  GetNext??  Get Next ??? and increment e2/e3 Pointer
E080: 20 1B E5 //            JSR  E51B     Jump to new location saving return address
E083: 20 18 E0 //            JSR  OutpSmthng Jump to new location saving return address
E086: 84 FA    //            STY  FA       Store index Y in memory
E088: AA       //            TAX           Transfer accumulator to index X
E089: 10 18    //            BPL  18       Branch on result plus
E08B: 0A       //            ASL           Shift accumulator left one bit
E08C: 10 E9    //            BPL  E9       Branch on result plus
E08E: A5 E4    //            LDA  E4       Load accumulator with memory
E090: D0 03    //            BNE  03       Branch on result not zero
E092: 20 11 E0 //            JSR  E011     Jump to new location saving return address
E095: 8A       //            TXA           Transfer index X to accumulator
E096: 20 C9 E3 //            JSR  CharOut  Jump to new location saving return address
E099: A9 25    //            LDA #25       Load accumulator with memory
E09B: 20 1A E0 //            JSR  E01A     Jump to new location saving return address
E09E: AA       //            TAX           Transfer accumulator to index X
E09F: 30 F5    //            BMI  F5       Branch on result minus
E0A1: 85 E4    //            STA  E4       Store accumulator in memory
E0A3: C9 01    //            CMP #01       Compare memory and accumulator
E0A5: D0 05    //            BNE  05       Branch on result not zero
E0A7: A6 D8    //            LDX  D8       Load index X with memory
E0A9: 4C CD E3 //            JMP  E3CD     Jump to new location

E0AC: 48       //            PHA           Push accumulator on stack
E0AD: 84 CE    //            STY  CE       Store index Y in memory
E0AF: A2 ED    //            LDX #ED       Load index X with memory
E0B1: 86 CF    //            STX  CF       Store index X in memory
E0B3: C9 51    //            CMP #51       Compare memory and accumulator
E0B5: 90 04    //            BCC  04       Branch on carry clear
E0B7: C6 CF    //            DEC  CF       Decrement memory by one
E0B9: E9 50    //            SBC #50       Subtrac memory from accumulator with borrow
E0BB: 48       //            PHA           Push accumulator on stack
E0BC: B1 CE    //            LDA (CE),Y    Load accumulator with memory
E0BE: AA       //            TAX           Transfer accumulator to index X
E0BF: 88       //            DEY           Dekrement index Y by one
E0C0: B1 CE    //            LDA (CE),Y    Load accumulator with memory
E0C2: 10 FA    //            BPL  FA       Branch on result plus
E0C4: E0 C0    //            CPX #C0       Compare memory and index X
E0C6: B0 04    //            BCS  04       Branch on carry set
E0C8: E0 00    //            CPX #00       Compare memory and index X
E0CA: 30 F2    //            BMI  F2       Branch on result minus
E0CC: AA       //            TAX           Transfer accumulator to index X
E0CD: 68       //            PLA           Pull accumulator from stack**
E0CE: E9 01    //            SBC #01       Subtrac memory from accumulator with borrow
E0D0: D0 E9    //            BNE  E9       Branch on result not zero
E0D2: 24 E4    //            BIT  E4       Test bits in memory with accumulator
E0D4: 30 03    //            BMI  03       Branch on result minus
E0D6: 20 F8 EF //            JSR  EFF8     Jump to new location saving return address

	       // Print a command (given by ce/cf-pointer)

E0D9: B1 CE    //CommandOut: LDA (CE),Y    Load accumulator with memory
E0DB: 10 10    //            BPL  10       Branch on result plus
E0DD: AA       //            TAX           Transfer accumulator to index X
E0DE: 29 3F    //            AND #3F       mask 00111111 lower 6 bit
E0E0: 85 E4    //            STA  E4       Store accumulator in memory
E0E2: 18       //            CLC           Clear carry flag
E0E3: 69 A0    //            ADC #A0       shift accu to printable ASCII-Char
E0E5: 20 C9 E3 //            JSR  CharOut  Jump to new location saving return address
E0E8: 88       //            DEY           Dekrement index Y by one
E0E9: E0 C0    //            CPX #C0       Compare memory and index X
E0EB: 90 EC    //            BCC  CommandOut       Branch on carry clear
E0ED: 20 0C E0 //            JSR  E00C     Jump to new location saving return address
E0F0: 68       //            PLA           Pull accumulator from stack**
E0F1: C9 5D    //            CMP #5D       Compare memory and accumulator
E0F3: F0 A4    //            BEQ  A4       Branch on result zero
E0F5: C9 28    //            CMP #28       Compare memory and accumulator
E0F7: D0 8A    //            BNE  8A       Branch on result not zero
E0F9: F0 9E    //            BEQ  9E       Branch on result zero
E0FB: 20 18 E1 //            JSR  E118     Jump to new location saving return address
E0FE: 95 50    //            STA  50,X     Store accumulator in memory
E100: D5 78    //            CMP  78,X     Compare memory and accumulator
E102: 90 11    //            BCC  11       Branch on carry clear
E104: A0 2B    //            LDY #2B       Load index Y with memory
E106: 4C E0 E3 //            JMP  E3E0     Jump to new location

E109: 20 34 EE //            JSR  EE34     Jump to new location saving return address
E10C: D5 50    //            CMP  50,X     Compare memory and accumulator
E10E: 90 F4    //            BCC  F4       Branch on carry clear
E110: 20 E4 EF //            JSR  EFE4     Jump to new location saving return address
E113: 95 78    //            STA  78,X     Store accumulator in memory
E115: 4C 23 E8 //            JMP  E823     Jump to new location

E118: 20 34 EE //            JSR  EE34     Jump to new location saving return address
E11B: F0 E7    //            BEQ  E7       Branch on result zero
E11D: 38       //            SEC           Set carry flag
E11E: E9 01    //            SBC #01       Subtrac memory from accumulator with borrow
E120: 60       //            RTS           Return from subroutine

E121: 20 18 E1 //            JSR  E118     Jump to new location saving return address
E124: 95 50    //            STA  50,X     Store accumulator in memory
E126: 18       //            CLC           Clear carry flag
E127: F5 78    //            SBC  78,X     Subtrac memory from accumulator with borrow
E129: 4C 02 E1 //            JMP  E102     Jump to new location

E12C: A0 14    //            LDY #14       Load index Y with memory
E12E: D0 D6    //            BNE  D6       Branch on result not zero
E130: 20 18 E1 //            JSR  E118     Jump to new location saving return address
E133: E8       //            INX           Increment index X by one
E134: B5 50    //            LDA  50,X     Load accumulator with memory
E136: 85 DA    //            STA  DA       Store accumulator in memory
E138: 65 CE    //            ADC  CE       Add memory to accumulator with carry
E13A: 48       //            PHA           Push accumulator on stack
E13B: A8       //            TAY           Transfer accumulator to index Y
E13C: B5 78    //            LDA  78,X     Load accumulator with memory
E13E: 85 DB    //            STA  DB       Store accumulator in memory
E140: 65 CF    //            ADC  CF       Add memory to accumulator with carry
E142: 48       //            PHA           Push accumulator on stack
E143: C4 CA    //            CPY  CA       Compare memory and index Y
E145: E5 CB    //            SBC  CB       Subtrac memory from accumulator with borrow
E147: B0 E3    //            BCS  E3       Branch on carry set
E149: A5 DA    //            LDA  DA       Load accumulator with memory
E14B: 69 FE    //            ADC #FE       Add memory to accumulator with carry
E14D: 85 DA    //            STA  DA       Store accumulator in memory
E14F: A9 FF    //            LDA #FF       Load accumulator with memory
E151: A8       //            TAY           Transfer accumulator to index Y
E152: 65 DB    //            ADC  DB       Add memory to accumulator with carry
E154: 85 DB    //            STA  DB       Store accumulator in memory
E156: C8       //            INY           Increment index Y by one
E157: B1 DA    //            LDA (DA),Y    Load accumulator with memory
E159: D9 CC 00 //            CMP  00CC,Y   Compare memory and accumulator
E15C: D0 0F    //            BNE  0F       Branch on result not zero
E15E: 98       //            TYA           Transfer index Y to accumulator
E15F: F0 F5    //            BEQ  F5       Branch on result zero
E161: 68       //            PLA           Pull accumulator from stack**
E162: 91 DA    //            STA (DA),Y    Store accumulator in memory
E164: 99 CC 00 //            STA  00CC,Y   Store accumulator in memory
E167: 88       //            DEY           Dekrement index Y by one
E168: 10 F7    //            BPL  F7       Branch on result plus
E16A: E8       //            INX           Increment index X by one
E16B: 60       //            RTS           Return from subroutine

E16C: EA       //            NOP           No operation
E16D: A0 80    //            LDY #80       Load index Y with memory
E16F: D0 95    //            BNE  95       Branch on result not zero
E171: A9 00    //            LDA #00       Load accumulator with memory
E173: 20 0A E7 //            JSR  E70A     Jump to new location saving return address
E176: A0 02    //            LDY #02       Load index Y with memory
E178: 94 78    //            STY  78,X     Store index Y in memory
E17A: 20 0A E7 //            JSR  E70A     Jump to new location saving return address
E17D: A9 BF    //            LDA #BF       Print "?"
E17F: 20 C9 E3 //            JSR  	   CharOut  
E182: A0 00    //            LDY #00       Load index Y with memory
E184: 20 9E E2 //            JSR  E29E     Jump to new location saving return address
E187: 94 78    //            STY  78,X     Store index Y in memory
E189: EA       //            NOP           No operation
E18A: EA       //            NOP           No operation
E18B: EA       //            NOP           No operation
E18C: B5 51    //            LDA  51,X     Load accumulator with memory
E18E: 85 CE    //            STA  CE       Store accumulator in memory
E190: B5 79    //            LDA  79,X     Load accumulator with memory
E192: 85 CF    //            STA  CF       Store accumulator in memory
E194: E8       //            INX           Increment index X by one
E195: E8       //            INX           Increment index X by one
E196: 20 BC E1 //            JSR  E1BC     Jump to new location saving return address
E199: B5 4E    //            LDA  4E,X     Load accumulator with memory
E19B: D5 76    //            CMP  76,X     Compare memory and accumulator
E19D: B0 15    //            BCS  15       Branch on carry set
E19F: F6 4E    //            INC  4E,X     Increment memory by one
E1A1: A8       //            TAY           Transfer accumulator to index Y
E1A2: B1 CE    //            LDA (CE),Y    Load accumulator with memory
E1A4: B4 50    //            LDY  50,X     Load index Y with memory
E1A6: C4 E4    //            CPY  E4       Compare memory and index Y
E1A8: 90 04    //            BCC  04       Branch on carry clear
E1AA: A0 83    //            LDY #83       Load index Y with memory
E1AC: D0 C1    //            BNE  C1       Branch on result not zero
E1AE: 91 DA    //            STA (DA),Y    Store accumulator in memory
E1B0: F6 50    //            INC  50,X     Increment memory by one
E1B2: 90 E5    //            BCC  E5       Branch on carry clear
E1B4: B4 50    //            LDY  50,X     Load index Y with memory
E1B6: 8A       //            TXA           Transfer index X to accumulator
E1B7: 91 DA    //            STA (DA),Y    Store accumulator in memory
E1B9: E8       //            INX           Increment index X by one
E1BA: E8       //            INX           Increment index X by one
E1BB: 60       //            RTS           Return from subroutine

E1BC: B5 51    //            LDA  51,X     Load accumulator with memory
E1BE: 85 DA    //            STA  DA       Store accumulator in memory
E1C0: 38       //            SEC           Set carry flag
E1C1: E9 02    //            SBC #02       Subtrac memory from accumulator with borrow
E1C3: 85 E4    //            STA  E4       Store accumulator in memory
E1C5: B5 79    //            LDA  79,X     Load accumulator with memory
E1C7: 85 DB    //            STA  DB       Store accumulator in memory
E1C9: E9 00    //            SBC #00       Subtrac memory from accumulator with borrow
E1CB: 85 E5    //            STA  E5       Store accumulator in memory
E1CD: A0 00    //            LDY #00       Load index Y with memory
E1CF: B1 E4    //            LDA (E4),Y    Load accumulator with memory
E1D1: 18       //            CLC           Clear carry flag
E1D2: E5 DA    //            SBC  DA       Subtrac memory from accumulator with borrow
E1D4: 85 E4    //            STA  E4       Store accumulator in memory
E1D6: 60       //            RTS           Return from subroutine

E1D7: B5 53    //            LDA  53,X     Load accumulator with memory
E1D9: 85 CE    //            STA  CE       Store accumulator in memory
E1DB: B5 7B    //            LDA  7B,X     Load accumulator with memory
E1DD: 85 CF    //            STA  CF       Store accumulator in memory
E1DF: B5 51    //            LDA  51,X     Load accumulator with memory
E1E1: 85 DA    //            STA  DA       Store accumulator in memory
E1E3: B5 79    //            LDA  79,X     Load accumulator with memory
E1E5: 85 DB    //            STA  DB       Store accumulator in memory
E1E7: E8       //            INX           Increment index X by one
E1E8: E8       //            INX           Increment index X by one
E1E9: E8       //            INX           Increment index X by one
E1EA: A0 00    //            LDY #00       Load index Y with memory
E1EC: 94 78    //            STY  78,X     Store index Y in memory
E1EE: 94 A0    //            STY  A0,X     Store index Y in memory
E1F0: C8       //            INY           Increment index Y by one
E1F1: 94 50    //            STY  50,X     Store index Y in memory
E1F3: B5 4D    //            LDA  4D,X     Load accumulator with memory
E1F5: D5 75    //            CMP  75,X     Compare memory and accumulator
E1F7: 08       //            PHP           Push prozessor status on stack
E1F8: 48       //            PHA           Push accumulator on stack
E1F9: B5 4F    //            LDA  4F,X     Load accumulator with memory
E1FB: D5 77    //            CMP  77,X     Compare memory and accumulator
E1FD: 90 07    //            BCC  07       Branch on carry clear
E1FF: 68       //            PLA           Pull accumulator from stack**
E200: 28       //            PLP           Pull prozessor status from stack
E201: B0 02    //            BCS  02       Branch on carry set
E203: 56 50    //            LSR  50,X     Shift right one bit
E205: 60       //            RTS           Return from subroutine

E206: A8       //            TAY           Transfer accumulator to index Y
E207: B1 CE    //            LDA (CE),Y    Load accumulator with memory
E209: 85 E4    //            STA  E4       Store accumulator in memory
E20B: 68       //            PLA           Pull accumulator from stack**
E20C: A8       //            TAY           Transfer accumulator to index Y
E20D: 28       //            PLP           Pull prozessor status from stack
E20E: B0 F3    //            BCS  F3       Branch on carry set
E210: B1 DA    //            LDA (DA),Y    Load accumulator with memory
E212: C5 E4    //            CMP  E4       Compare memory and accumulator
E214: D0 ED    //            BNE  ED       Branch on result not zero
E216: F6 4F    //            INC  4F,X     Increment memory by one
E218: F6 4D    //            INC  4D,X     Increment memory by one
E21A: B0 D7    //            BCS  D7       Branch on carry set
E21C: 20 D7 E1 //            JSR  E1D7     Jump to new location saving return address
E21F: 4C 36 E7 //            JMP  E736     Jump to new location

E222: 20 54 E2 //            JSR  E254     Jump to new location saving return address
E225: 06 CE    //            ASL  CE       Shift left one Bit (memory or accumulator)
E227: 26 CF    //            ROL  CF       Rotate one bit left
E229: 90 0D    //            BCC  0D       Branch on carry clear
E22B: 18       //            CLC           Clear carry flag
E22C: A5 E6    //            LDA  E6       add da/db-pointer to e6/e7-pointer
E22E: 65 DA    //            ADC  DA
E230: 85 E6    //            STA  E6
E232: A5 E7    //            LDA  E7
E234: 65 DB    //            ADC  DB
E236: 85 E7    //            STA  E7
E238: 88       //            DEY           Dekrement index Y by one
E239: F0 09    //            BEQ  09       Branch on result zero
E23B: 06 E6    //            ASL  E6       Shift left one Bit (memory or accumulator)
E23D: 26 E7    //            ROL  E7       Rotate one bit left
E23F: 10 E4    //            BPL  E4       Branch on result plus
E241: 4C 7E E7 //            JMP  E77E     Jump to new location

E244: A5 E6    //            LDA  E6       Load accumulator with memory
E246: 20 08 E7 //            JSR  E708     Jump to new location saving return address
E249: A5 E7    //            LDA  E7       Load accumulator with memory
E24B: 95 A0    //            STA  A0,X     Store accumulator in memory
E24D: 06 E5    //            ASL  E5       Shift left one Bit (memory or accumulator)
E24F: 90 28    //            BCC  28       Branch on carry clear
E251: 4C 6F E7 //            JMP  E76F     Jump to new location

E254: A9 55    //            LDA #55       Load accumulator with memory
E256: 85 E5    //            STA  E5       Store accumulator in memory
E258: 20 5B E2 //            JSR  E25B     Jump to new location saving return address
E25B: A5 CE    //            LDA  CE       Load accumulator with memory
E25D: 85 DA    //            STA  DA       Store accumulator in memory
E25F: A5 CF    //            LDA  CF       Load accumulator with memory
E261: 85 DB    //            STA  DB       Store accumulator in memory
E263: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E266: 84 E6    //            STY  E6       Store index Y in memory
E268: 84 E7    //            STY  E7       Store index Y in memory
E26A: A5 CF    //            LDA  CF       Load accumulator with memory
E26C: 10 09    //            BPL  09       Branch on result plus
E26E: CA       //            DEX           Decrement index X by one
E26F: 06 E5    //            ASL  E5       Shift left one Bit (memory or accumulator)
E271: 20 6F E7 //            JSR  E76F     Jump to new location saving return address
E274: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E277: A0 10    //            LDY #10       Load index Y with memory
E279: 60       //            RTS           Return from subroutine

E27A: 20 6C EE //            JSR  EE6C     Jump to new location saving return address
E27D: F0 C5    //            BEQ  C5       Branch on result zero
E27F: FF       //            ''
E280: C9 84    //            CMP #84       Compare memory and accumulator
E282: D0 02    //            BNE  02       Branch on result not zero
E284: 46 F8    //            LSR  F8       Shift right one bit
E286: C9 DF    //            CMP #DF       Compare memory and accumulator
E288: F0 11    //            BEQ  11       Branch on result zero
E28A: C9 9B    //            CMP #9B       Compare memory and accumulator
E28C: F0 06    //            BEQ  06       Branch on result zero
E28E: 99 00 02 //            STA  0200,Y   Store accumulator in memory
E291: C8       //            INY           Increment index Y by one
E292: 10 0A    //            BPL  0A       Branch on result plus
E294: A0 8B    //            LDY #8B       Print "\"+<RETURN>
E296: 20 C4 E3 //            JSR  ErrorOutp
E299: A0 01    //            LDY #01       Load index Y with memory
E29B: 88       //            DEY           Dekrement index Y by one
E29C: 30 F6    //            BMI  F6       Branch on result minus
E29E: 20 03 E0 // InputLine: JSR  Input    Jump to new location saving return address
E2A1: EA       //            NOP           No operation
E2A2: EA       //            NOP           No operation
E2A3: 20 C9 E3 //            JSR  CharOut  Jump to new location saving return address
E2A6: C9 8D    //            CMP #8D       Compare memory and accumulator
E2A8: D0 D6    //            BNE  D6       Branch on result not zero
E2AA: A9 DF    //            LDA #DF       Load accumulator with memory
E2AC: 99 00 02 //            STA  0200,Y   Store accumulator in memory
E2AF: 60       //            RTS           Return from subroutine

E2B0: 20 D3 EF //            JSR  EFD3     Jump to new location saving return address
E2B3: 20 CD E3 // Reenter:   JSR  E3CD     Jump to new location saving return address
E2B6: 46 D9    //            LSR  D9       Shift right one bit
E2B8: A9 BE    //            LDA #BE       Load accumulator with memory
E2BA: 20 C9 E3 //            JSR  CharOut  Jump to new location saving return address
E2BD: A0 00    //            LDY #00       Load index Y with memory
E2BF: 84 FA    //            STY  FA       Store index Y in memory
E2C1: 24 F8    //            BIT  F8       Test bits in memory with accumulator
E2C3: 10 0C    //            BPL  0C       Branch on result plus
E2C5: A6 F6    //            LDX  F6       Load index X with memory
E2C7: A5 F7    //            LDA  F7       Load accumulator with memory
E2C9: 20 1B E5 //            JSR  E51B     Jump to new location saving return address
E2CC: A9 A0    //            LDA #A0       Load accumulator with memory
E2CE: 20 C9 E3 //            JSR  CharOut  Jump to new location saving return address
E2D1: A2 FF    //            LDX #FF       x = 0xFF
E2D3: 9A       //            TXS           Reset stackpointer to 0xFF
E2D4: 20 9E E2 //            JSR  InputLine Jump to new location saving return address
E2D7: 84 F1    //            STY  F1       Store index Y in memory
E2D9: 8A       //            TXA           Transfer index X to accumulator
E2DA: 85 C8    //            STA  C8       Store accumulator in memory
E2DC: A2 20    //            LDX #20       Load index X with memory
E2DE: 20 91 E4 //            JSR  E491     Jump to new location saving return address
E2E1: A5 C8    //            LDA  C8       Load accumulator with memory
E2E3: 69 00    //            ADC #00       Add memory to accumulator with carry
E2E5: 85 E0    //            STA  E0       Store accumulator in memory
E2E7: A9 00    //            LDA #00       Load accumulator with memory
E2E9: AA       //            TAX           Transfer accumulator to index X
E2EA: 69 02    //            ADC #02       Add memory to accumulator with carry
E2EC: 85 E1    //            STA  E1       Store accumulator in memory
E2EE: A1 E0    //            LDA (E0,X)    Load accumulator with memory
E2F0: 29 F0    //            AND #F0       'AND' memory with accumulator
E2F2: C9 B0    //            CMP #B0       Compare memory and accumulator
E2F4: F0 03    //            BEQ  03       Branch on result zero
E2F6: 4C 83 E8 //            JMP  E883     Jump to new location

E2F9: A0 02    //            LDY #02       Load index Y with memory
E2FB: B1 E0    //            LDA (E0),Y    Load accumulator with memory
E2FD: 99 CD 00 //            STA  00CD,Y   Store accumulator in memory
E300: 88       //            DEY           Dekrement index Y by one
E301: D0 F8    //            BNE  F8       Branch on result not zero
E303: 20 8A E3 //            JSR  E38A     Jump to new location saving return address
E306: A5 F1    //            LDA  F1       Load accumulator with memory
E308: E5 C8    //            SBC  C8       Subtrac memory from accumulator with borrow
E30A: C9 04    //            CMP #04       Compare memory and accumulator
E30C: F0 A8    //            BEQ  A8       Branch on result zero
E30E: 91 E0    //            STA (E0),Y    Store accumulator in memory
E310: A5 CA    //            LDA  CA       Load accumulator with memory
E312: F1 E0    //            SBC (E0),Y    Subtrac memory from accumulator with borrow
E314: 85 E4    //            STA  E4       Store accumulator in memory
E316: A5 CB    //            LDA  CB       Load accumulator with memory
E318: E9 00    //            SBC #00       Subtrac memory from accumulator with borrow
E31A: 85 E5    //            STA  E5       Store accumulator in memory
E31C: A5 E4    //            LDA  E4       Load accumulator with memory
E31E: C5 CC    //            CMP  CC       Compare memory and accumulator
E320: A5 E5    //            LDA  E5       Load accumulator with memory
E322: E5 CD    //            SBC  CD       Subtrac memory from accumulator with borrow
E324: 90 45    //            BCC  45       Branch on carry clear
E326: A5 CA    //            LDA  CA       Load accumulator with memory
E328: F1 E0    //            SBC (E0),Y    Subtrac memory from accumulator with borrow
E32A: 85 E6    //            STA  E6       Store accumulator in memory
E32C: A5 CB    //            LDA  CB       Load accumulator with memory
E32E: E9 00    //            SBC #00       Subtrac memory from accumulator with borrow
E330: 85 E7    //            STA  E7       Store accumulator in memory
E332: B1 CA    //            LDA (CA),Y    Load accumulator with memory
E334: 91 E6    //            STA (E6),Y    Store accumulator in memory
E336: E6 CA    //            INC  CA       increment ca/cb-pointer
E338: D0 02    //            BNE  02       
E33A: E6 CB    //            INC  CB       
E33C: A5 E2    //            LDA  E2       Load accumulator with memory
E33E: C5 CA    //            CMP  CA       Compare memory and accumulator
E340: A5 E3    //            LDA  E3       Load accumulator with memory
E342: E5 CB    //            SBC  CB       Subtrac memory from accumulator with borrow
E344: B0 E0    //            BCS  E0       Branch on carry set
E346: B5 E4    //            LDA  E4,X     Load accumulator with memory
E348: 95 CA    //            STA  CA,X     Store accumulator in memory
E34A: CA       //            DEX           Decrement index X by one
E34B: 10 F9    //            BPL  F9       Branch on result plus
E34D: B1 E0    //            LDA (E0),Y    Load accumulator with memory
E34F: A8       //            TAY           Transfer accumulator to index Y
E350: 88       //            DEY           Dekrement index Y by one
E351: B1 E0    //            LDA (E0),Y    Load accumulator with memory
E353: 91 E6    //            STA (E6),Y    Store accumulator in memory
E355: 98       //            TYA           Transfer index Y to accumulator
E356: D0 F8    //            BNE  F8       Branch on result not zero
E358: 24 F8    //            BIT  F8       Test bits in memory with accumulator
E35A: 10 09    //            BPL  09       Branch on result plus
E35C: B5 F7    //            LDA  F7,X     Load accumulator with memory
E35E: 75 F5    //            ADC  F5,X     Add memory to accumulator with carry
E360: 95 F7    //            STA  F7,X     Store accumulator in memory
E362: E8       //            INX           Increment index X by one
E363: F0 F7    //            BEQ  F7       Branch on result zero
E365: 10 7E    //            BPL  7E       Branch on result plus
E367: 00       //            BRK           Force Break
E368: 00       //            BRK           Force Break
E369: 00       //            BRK           Force Break
E36A: 00       //            BRK           Force Break
E36B: A0 14    //            LDY #14       Load index Y with memory
E36D: D0 71    //            BNE  71       Branch on result not zero
E36F: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E372: A5 E2    //            LDA  E2       copy e2/e3-pointer to e6/e7-pointer
E374: 85 E6    //            STA  E6
E376: A5 E3    //            LDA  E3
E378: 85 E7    //            STA  E7
E37A: 20 75 E5 //            JSR  E575     Jump to new location saving return address
E37D: A5 E2    //            LDA  E2       copy e2/e3-pointer to e4/e5-pointer
E37F: 85 E4    //            STA  E4
E381: A5 E3    //            LDA  E3
E383: 85 E5    //            STA  E5
E385: D0 0E    //            BNE  0E       Branch on result not zero
E387: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E38A: 20 6D E5 //            JSR  E56D     Jump to new location saving return address
E38D: A5 E6    //            LDA  E6       copy e6/e7-pointer to e2/e3-pointer
E38F: 85 E2    //            STA  E2
E391: A5 E7    //            LDA  E7
E393: 85 E3    //            STA  E3
E395: A0 00    //            LDY #00       y = 0
E397: A5 CA    //            LDA  CA       Load accumulator with memory
E399: C5 E4    //            CMP  E4       Compare memory and accumulator
E39B: A5 CB    //            LDA  CB       Load accumulator with memory
E39D: E5 E5    //            SBC  E5       Subtrac memory from accumulator with borrow
E39F: B0 16    //            BCS  16       Branch on carry set
E3A1: A5 E4    //            LDA  E4       decrement e4/e5-pointer
E3A3: D0 02    //            BNE  02       
E3A5: C6 E5    //            DEC  E5       
E3A7: C6 E4    //            DEC  E4       
E3A9: A5 E6    //            LDA  E6       decrement e6/e7-pointer
E3AB: D0 02    //            BNE  02       
E3AD: C6 E7    //            DEC  E7       
E3AF: C6 E6    //            DEC  E6       
E3B1: B1 E4    //            LDA (E4),Y    copy byte from e4/e5-pointer to e6/e7-pointer
E3B3: 91 E6    //            STA (E6),Y    
E3B5: 90 E0    //            BCC  E0       Branch on carry clear
E3B7: A5 E6    //            LDA  E6       copy e6/e7-pointer to ca/cb-pointer
E3B9: 85 CA    //            STA  CA       
E3BB: A5 E7    //            LDA  E7       
E3BD: 85 CB    //            STA  CB       
E3BF: 60       //            RTS           Return from subroutine

E3C0: 20 C9 E3 // String:    JSR  CharOut  Jump to new location saving return address
E3C3: C8       //            INY           Increment index Y by one
E3C4: B9 00 EB // ErrorOutp: LDA  EB00,Y   Load accumulator with memory
E3C7: 30 F7    //            BMI  String   Char for output? ( No? then last char of string)
E3C9: C9 8D    // CharOut:   CMP #8D       is accumulator = <RETURN>?
E3CB: D0 06    //            BNE  Next     No? jump over to Next
E3CD: A9 00    //            LDA #00       Store 0 into Byte 0x24
E3CF: 85 24    //            STA  24       
E3D1: A9 8D    //            LDA #8D       put <RETURN> into accumulator, ready for output
E3D3: E6 24    // Next:      INC  24       Increment memory by one
E3D5: 2C 12 D0 // Wait:      BIT  D012     Is there a character waiting for output?
E3D8: 30 FB    //            BMI  Wait     yes? wait again
E3DA: 8D 12 D0 //            STA  D012     put new character to output
E3DD: 60       //            RTS           Return from subroutine

E3DE: A0 06    //            LDY #06       Print "*** TOO LONG"
E3E0: 20 D3 EE //            JSR           PrintErr
E3E3: 24 D9    //            BIT  D9       Test bits in memory with accumulator
E3E5: 30 03    //            BMI  03       Branch on result minus
E3E7: 4C B6 E2 //            JMP  E2B6     Jump to new location
E3EA: 4C 9A EB //            JMP  EB9A     Jump to new location

E3ED: 2A       //            ROL           Rotate one bit left
E3EE: 69 A0    //            ADC #A0       <SPACE> & BIT8
E3F0: DD 00 02 //            CMP  0200,X   Compare memory and accumulator
E3F3: D0 53    //            BNE  53       Branch on result not zero (E448)
E3F5: B1 FE    //            LDA (FE),Y    Load accumulator with memory
E3F7: 0A       //            ASL           Shift accumulator left one bit
E3F8: 30 06    //            BMI  06       Branch on result minus
E3FA: 88       //            DEY           Dekrement index Y by one
E3FB: B1 FE    //            LDA (FE),Y    Load accumulator with memory
E3FD: 30 29    //            BMI  29       Branch on result minus
E3FF: C8       //            INY           Increment index Y by one
E400: 86 C8    //            STX  C8       Store index X in memory
E402: 98       //            TYA           Transfer index Y to accumulator
E403: 48       //            PHA           Push accumulator on stack
E404: A2 00    //            LDX #00       x = 0
E406: A1 FE    //            LDA (FE,X)    Load accumulator with memory
E408: AA       //            TAX           Transfer accumulator to index X
E409: 4A       //            LSR           Shift right one bit
E40A: 49 48    //            EOR #48       'Exclusive-Or' "1001000" with accumulator
E40C: 11 FE    //            ORA (FE),Y    'Or' memory with accumulator
E40E: C9 C0    //            CMP #C0       Compare memory and accumulator
E410: 90 01    //            BCC  01       Branch on carry clear
E412: E8       //            INX           Increment index X by one
E413: C8       //            INY           Increment index Y by one
E414: D0 F3    //            BNE  F3       Branch on result not zero
E416: 68       //            PLA           Pull accumulator from stack
E417: A8       //            TAY           Transfer accumulator to index Y
E418: 8A       //            TXA           Transfer index X to accumulator
E419: 4C C0 E4 //            JMP  E4C0     Jump to new location

E41C: E6 F1    //            INC  F1       Increment memory by one
E41E: A6 F1    //            LDX  F1       Load index X with memory
E420: F0 BC    //            BEQ  BC       Branch on result zero
E422: 9D 00 02 //            STA  0200,X   Store accumulator in memory
E425: 60       //            RTS           Return from subroutine

E426: A6 C8    //            LDX  C8       Load index X with memory
E428: A9 A0    //            LDA #A0       Load accumulator with memory
	       // get rid of trailing spaces
E42A: E8       // CompLine:  INX           Increment index X by one
E42B: DD 00 02 //            CMP  0200,X   Compare memory and accumulator
E42E: B0 FA    //            BCS  CompLine Branch on carry set
E430: B1 FE    //            LDA (FE),Y    Load accumulator with memory
E432: 29 3F    //            AND #3F       'AND' memory with accumulator (00111111)
E434: 4A       //            LSR           Shift right one bit
E435: D0 B6    //            BNE  B6       Branch on result not zero
E437: BD 00 02 //            LDA  0200,X   Load accumulator with memory
E43A: B0 06    //            BCS  06       Branch on carry set
E43C: 69 3F    //            ADC #3F       Add memory to accumulator with carry
E43E: C9 1A    //            CMP #1A       Compare memory and accumulator
E440: 90 6F    //            BCC  6F       Branch on carry clear
E442: 69 4F    //            ADC #4F        Add memory to accumulator with carry
E444: C9 0A    //            CMP #0A       Compare memory and accumulator
E446: 90 69    //            BCC  69       Branch on carry clear
E448: A6 FD    //            LDX  FD       Load index X with memory
E44A: C8       //            INY           Increment index Y by one
E44B: B1 FE    //            LDA (FE),Y    Load accumulator with memory
E44D: 29 E0    //            AND #E0       'AND' memory with accumulator
E44F: C9 20    //            CMP #20       Compare memory and accumulator
E451: F0 7A    //            BEQ  7A       Branch on result zero
E453: B5 A8    //            LDA  A8,X     Load accumulator with memory
E455: 85 C8    //            STA  C8       Store accumulator in memory
E457: B5 D1    //            LDA  D1,X     Load accumulator with memory
E459: 85 F1    //            STA  F1       Store accumulator in memory
E45B: 88       //            DEY           Dekrement index Y by one
E45C: B1 FE    //            LDA (FE),Y    Load accumulator with memory
E45E: 0A       //            ASL           Shift accumulator left one bit
E45F: 10 FA    //            BPL  FA       Branch on result plus
E461: 88       //            DEY           Dekrement index Y by one
E462: B0 38    //            BCS  38       Branch on carry set
E464: 0A       //            ASL           Shift accumulator left one bit
E465: 30 35    //            BMI  35       Branch on result minus
E467: B4 58    //            LDY  58,X     Load index Y with memory
E469: 84 FF    //            STY  FF       Store index Y in memory
E46B: B4 80    //            LDY  80,X     Load index Y with memory
E46D: E8       //            INX           Increment index X by one
E46E: 10 DA    //            BPL  DA       Branch on result plus
E470: F0 B3    //            BEQ  B3       Branch on result zero
E472: C9 7E    //            CMP #7E       Compare memory and accumulator
E474: B0 22    //            BCS  22       Branch on carry set
E476: CA       //            DEX           Decrement index X by one
E477: 10 04    //            BPL  04       Branch on result plus
E479: A0 06    //            LDY #06       Load index Y with memory
E47B: 10 29    //            BPL  29       Branch on result plus
E47D: 94 80    //            STY  80,X     Store index Y in memory
E47F: A4 FF    //            LDY  FF       Load index Y with memory
E481: 94 58    //            STY  58,X     Store index Y in memory
E483: A4 C8    //            LDY  C8       Load index Y with memory
E485: 94 A8    //            STY  A8,X     Store index Y in memory
E487: A4 F1    //            LDY  F1       Load index Y with memory
E489: 94 D1    //            STY  D1,X     Store index Y in memory
E48B: 29 1F    //            AND #1F       'AND' memory with accumulator
E48D: A8       //            TAY           Transfer accumulator to index Y
E48E: B9 20 EC //            LDA  EC20,Y   Load accumulator with memory
E491: 0A       //            ASL           Shift accumulator left one bit
E492: A8       //            TAY           Transfer accumulator to index Y
E493: A9 76    //            LDA #76       Load accumulator with memory
E495: 2A       //            ROL           Rotate one bit left
E496: 85 FF    //            STA  FF       Store accumulator in memory
E498: D0 01    //            BNE  01       Branch on result not zero
E49A: C8       //            INY           Increment index Y by one
E49B: C8       //            INY           Increment index Y by one
E49C: 86 FD    //            STX  FD       Store index X in memory
E49E: B1 FE    //            LDA (FE),Y    Load accumulator with memory
E4A0: 30 84    //            BMI  84       Branch on result minus
E4A2: D0 05    //            BNE  05       Branch on result not zero
E4A4: A0 0E    //            LDY #0E       Load index Y with memory
E4A6: 4C E0 E3 //            JMP  E3E0     Jump to new location
E4A9: C9 03    //            CMP #03       Compare memory and accumulator
E4AB: B0 C3    //            BCS  C3       Branch on carry set
E4AD: 4A       //            LSR           Shift right one bit
E4AE: A6 C8    //            LDX  C8       Load index X with memory
E4B0: E8       //            INX           Increment index X by one
E4B1: BD 00 02 //            LDA  0200,X   Load accumulator with memory
E4B4: 90 04    //            BCC  04       Branch on carry clear
E4B6: C9 A2    //            CMP #A2       Compare memory and accumulator
E4B8: F0 0A    //            BEQ  0A       Branch on result zero
E4BA: C9 DF    //            CMP #DF       Compare memory and accumulator
E4BC: F0 06    //            BEQ  06       Branch on result zero
E4BE: 86 C8    //            STX  C8       Store index X in memory
E4C0: 20 1C E4 //            JSR  E41C     Jump to new location saving return address
E4C3: C8       //            INY           Increment index Y by one
E4C4: 88       //            DEY           Dekrement index Y by one
E4C5: A6 FD    //            LDX  FD       Load index X with memory
E4C7: B1 FE    //            LDA (FE),Y    Load accumulator with memory
E4C9: 88       //            DEY           Dekrement index Y by one
E4CA: 0A       //            ASL           Shift accumulator left one bit
E4CB: 10 CF    //            BPL  CF       Branch on result plus
E4CD: B4 58    //            LDY  58,X     Load index Y with memory
E4CF: 84 FF    //            STY  FF       Store index Y in memory
E4D1: B4 80    //            LDY  80,X     Load index Y with memory
E4D3: E8       //            INX           Increment index X by one
E4D4: B1 FE    //            LDA (FE),Y    Load accumulator with memory
E4D6: 29 9F    //            AND #9F       'AND' memory with accumulator
E4D8: D0 ED    //            BNE  ED       Branch on result not zero
E4DA: 85 F2    //            STA  F2       Store accumulator in memory
E4DC: 85 F3    //            STA  F3       Store accumulator in memory
E4DE: 98       //            TYA           Transfer index Y to accumulator
E4DF: 48       //            PHA           Push accumulator on stack
E4E0: 86 FD    //            STX  FD       Store index X in memory
E4E2: B4 D0    //            LDY  D0,X     Load index Y with memory
E4E4: 84 C9    //            STY  C9       Store index Y in memory
E4E6: 18       //            CLC           Clear carry flag
E4E7: A9 0A    //            LDA #0A       Load accumulator with memory
E4E9: 85 F9    //            STA  F9       Store accumulator in memory
E4EB: A2 00    //            LDX #00       Load index X with memory
E4ED: C8       //            INY           Increment index Y by one
E4EE: B9 00 02 //            LDA  0200,Y   Load accumulator with memory
E4F1: 29 0F    //            AND #0F       'AND' memory with accumulator
E4F3: 65 F2    //            ADC  F2       Add memory to accumulator with carry
E4F5: 48       //            PHA           Push accumulator on stack
E4F6: 8A       //            TXA           Transfer index X to accumulator
E4F7: 65 F3    //            ADC  F3       Add memory to accumulator with carry
E4F9: 30 1C    //            BMI  1C       Branch on result minus
E4FB: AA       //            TAX           Transfer accumulator to index X
E4FC: 68       //            PLA           Pull accumulator from stack**
E4FD: C6 F9    //            DEC  F9       Decrement memory by one
E4FF: D0 F2    //            BNE  F2       Branch on result not zero
E501: 85 F2    //            STA  F2       Store accumulator in memory
E503: 86 F3    //            STX  F3       Store index X in memory
E505: C4 F1    //            CPY  F1       Compare memory and index Y
E507: D0 DE    //            BNE  DE       Branch on result not zero
E509: A4 C9    //            LDY  C9       Load index Y with memory
E50B: C8       //            INY           Increment index Y by one
E50C: 84 F1    //            STY  F1       Store index Y in memory
E50E: 20 1C E4 //            JSR  E41C     Jump to new location saving return address
E511: 68       //            PLA           Pull accumulator from stack**
E512: A8       //            TAY           Transfer accumulator to index Y
E513: A5 F3    //            LDA  F3       Load accumulator with memory
E515: B0 A9    //            BCS  A9       Branch on carry set
E517: A0 00    //            LDY #00       Load index Y with memory
E519: 10 8B    //            BPL  8B       Branch on result plus

// Output Line number???
E51B: 85 F3    //            STA  F3       Store accumulator in memory
E51D: 86 F2    //            STX  F2       Store index X in memory
E51F: A2 04    //            LDX #04       Load index X with memory
E521: 86 C9    //            STX  C9       Store index X in memory
E523: A9 B0    //            LDA #B0       Load accumulator with memory
E525: 85 F9    //            STA  F9       Store accumulator in memory
E527: A5 F2    //            LDA  F2       Load accumulator with memory
E529: DD 63 E5 //            CMP  E563,X   Compare memory and accumulator
E52C: A5 F3    //            LDA  F3       Load accumulator with memory
E52E: FD 68 E5 //            SBC  E568,X   Subtrac memory from accumulator with borrow
E531: 90 0D    //            BCC  0D       Branch on carry clear
E533: 85 F3    //            STA  F3       Store accumulator in memory
E535: A5 F2    //            LDA  F2       Load accumulator with memory
E537: FD 63 E5 //            SBC  E563,X   Subtrac memory from accumulator with borrow
E53A: 85 F2    //            STA  F2       Store accumulator in memory
E53C: E6 F9    //            INC  F9       Increment memory by one
E53E: D0 E7    //            BNE  E7       Branch on result not zero
E540: A5 F9    //            LDA  F9       Load accumulator with memory
E542: E8       //            INX           Increment index X by one
E543: CA       //            DEX           Decrement index X by one

//####### somewhere here must be the output routine for the line number

E544: F0 0E    //            BEQ  DigitOut Branch on result zero
E546: C9 B0    //            CMP #B0       Compare memory and accumulator
E548: F0 02    //            BEQ  02       Branch on result zero
E54A: 85 C9    //            STA  C9       Store accumulator in memory
E54C: 24 C9    //            BIT  C9       Test bits in memory with accumulator
E54E: 30 04    //            BMI  04       Branch on result minus
E550: A5 FA    //            LDA  FA       Load accumulator with memory
E552: F0 0B    //            BEQ  0B       Branch on result zero
E554: 20 C9 E3 // DigitOut:  JSR  CharOut  Jump to new location saving return address
E557: 24 F8    //            BIT  F8       Test bits in memory with accumulator
E559: 10 04    //            BPL  04       Branch on result plus
E55B: 99 00 02 //            STA  0200,Y   Store accumulator in memory
E55E: C8       //            INY           Increment index Y by one
E55F: CA       //            DEX           Decrement index X by one
E560: 10 C1    //            BPL  C1       Branch on result plus
E562: 60       //            RTS           Return from subroutine

// Data for the routine:
E563: 01 0A 64 E8 10 00
E569: 00 00 03 27

E56D: A5 CA    //            LDA  CA       copy ca/cb-pointer to e6/e7-pointer
E56F: 85 E6    //            STA  E6
E571: A5 CB    //            LDA  CB
E573: 85 E7    //            STA  E7
E575: E8       //            INX           Increment index X by one
E576: A5 E7    //            LDA  E7       copy e6/e7-pointer to e4/e5-pointer
E578: 85 E5    //            STA  E5
E57A: A5 E6    //            LDA  E6
E57C: 85 E4    //            STA  E4
E57E: C5 4C    //            CMP  4C       Compare memory and accumulator
E580: A5 E5    //            LDA  E5       Load accumulator with memory
E582: E5 4D    //            SBC  4D       Subtrac memory from accumulator with borrow
E584: B0 26    //            BCS  26       Branch on carry set
E586: A0 01    //            LDY #01       Load index Y with memory
E588: B1 E4    //            LDA (E4),Y    Load accumulator with memory
E58A: E5 CE    //            SBC  CE       Subtrac memory from accumulator with borrow
E58C: C8       //            INY           Increment index Y by one
E58D: B1 E4    //            LDA (E4),Y    Load accumulator with memory
E58F: E5 CF    //            SBC  CF       Subtrac memory from accumulator with borrow
E591: B0 19    //            BCS  19       Branch on carry set
E593: A0 00    //            LDY #00       Load index Y with memory
E595: A5 E6    //            LDA  E6       Load accumulator with memory
E597: 71 E4    //            ADC (E4),Y    Add memory to accumulator with carry
E599: 85 E6    //            STA  E6       Store accumulator in memory
E59B: 90 03    //            BCC  03       Branch on carry clear
E59D: E6 E7    //            INC  E7       Increment memory by one
E59F: 18       //            CLC           Clear carry flag
E5A0: C8       //            INY           Increment index Y by one
E5A1: A5 CE    //            LDA  CE       Load accumulator with memory
E5A3: F1 E4    //            SBC (E4),Y    Subtrac memory from accumulator with borrow
E5A5: C8       //            INY           Increment index Y by one
E5A6: A5 CF    //            LDA  CF       Load accumulator with memory
E5A8: F1 E4    //            SBC (E4),Y    Subtrac memory from accumulator with borrow
E5AA: B0 CA    //            BCS  CA       Branch on carry set
E5AC: 60       //            RTS           Return from subroutine

E5AD: 46 F8    //            LSR  F8       Shift right one bit
E5AF: A5 4C    //            LDA  4C       copy 4c/4d-pointer to ca/cb-pointer
E5B1: 85 CA    //            STA  CA
E5B3: A5 4D    //            LDA  4D
E5B5: 85 CB    //            STA  CB
E5B7: A5 4A    //            LDA  4A       copy 4a/4b-pointer to cc/cd-pointer
E5B9: 85 CC    //            STA  CC
E5BB: A5 4B    //            LDA  4B
E5BD: 85 CD    //            STA  CD
E5BF: A9 00    //            LDA #00       fill 0000 to fb/fc-pointer
E5C1: 85 FB    //            STA  FB
E5C3: 85 FC    //            STA  FC
E5C5: 85 FE    //            STA  FE       Store accumulator in memory
E5C7: A9 00    //            LDA #00       Load accumulator with memory
E5C9: 85 1D    //            STA  1D       Store accumulator in memory
E5CB: 60       //            RTS           Return from subroutine

E5CC: A5 D0    //            LDA  D0       d2/d3-point = d0/d1-pointer + 5
E5CE: 69 05    //            ADC #05
E5D0: 85 D2    //            STA  D2
E5D2: A5 D1    //            LDA  D1
E5D4: 69 00    //            ADC #00
E5D6: 85 D3    //            STA  D3
E5D8: A5 D2    //            LDA  D2       Load accumulator with memory
E5DA: C5 CA    //            CMP  CA       Compare memory and accumulator
E5DC: A5 D3    //            LDA  D3       Load accumulator with memory
E5DE: E5 CB    //            SBC  CB       Subtrac memory from accumulator with borrow
E5E0: 90 03    //            BCC  03       Branch on carry clear
E5E2: 4C 6B E3 //            JMP  E36B     Jump to new location
E5E5: A5 CE    //            LDA  CE       copy ce/cf-pointer to (d0/d1-pointer)+y
E5E7: 91 D0    //            STA (D0),Y 
E5E9: A5 CF    //            LDA  CF
E5EB: C8       //            INY
E5EC: 91 D0    //            STA (D0),Y
E5EE: A5 D2    //            LDA  D2       copy d2/d3-pointer to next position
E5F0: C8       //            INY
E5F1: 91 D0    //            STA (D0),Y
E5F3: A5 D3    //            LDA  D3
E5F5: C8       //            INY
E5F6: 91 D0    //            STA (D0),Y
E5F8: A9 00    //            LDA #00       fill 0000 to next position
E5FA: C8       //            INY
E5FB: 91 D0    //            STA (D0),Y
E5FD: C8       //            INY
E5FE: 91 D0    //            STA (D0),Y
E600: A5 D2    //            LDA  D2       copy d2/d3-pointer to cc/cd-pointer
E602: 85 CC    //            STA  CC
E604: A5 D3    //            LDA  D3
E606: 85 CD    //            STA  CD
E608: A5 D0    //            LDA  D0       Load accumulator with memory
E60A: 90 43    //            BCC  43       Branch on carry clear
E60C: 85 CE    //            STA  CE       set ce/cf-pointer to D0 and y
E60E: 84 CF    //            STY  CF
E610: 20 FF E6 //            JSR  E6FF     Jump to new location saving return address
E613: 30 0E    //            BMI  0E       Branch on result minus
E615: C9 40    //            CMP #40       Compare memory and accumulator
E617: F0 0A    //            BEQ  0A       Branch on result zero
E619: 4C 28 E6 //            JMP  E628     Jump to new location
E61C: 06 C9    //            ASL  C9       Shift left one Bit (memory or accumulator)
E61E: 49 D0    //            EOR #D0       'Exclusive-Or' memory with accumulator
E620: 07
E621: A9 49    //            LDA #49       Load accumulator with memory
E623: 85 CF    //            STA  CF       Store accumulator in memory
E625: 20 FF E6 //            JSR  E6FF     Jump to new location saving return address
E628: A5 4B    //            LDA  4B       copy 4a/4b-pointer to d0/d1-pointer
E62A: 85 D1    //            STA  D1
E62C: A5 4A    //            LDA  4A
E62E: 85 D0    //            STA  D0
E630: C5 CC    //            CMP  CC       Compare memory and accumulator
E632: A5 D1    //            LDA  D1       Load accumulator with memory
E634: E5 CD    //            SBC  CD       Subtrac memory from accumulator with borrow
E636: B0 94    //            BCS  94       Branch on carry set
E638: B1 D0    //            LDA (D0),Y    Load accumulator with memory
E63A: C8       //            INY           Increment index Y by one
E63B: C5 CE    //            CMP  CE       Compare memory and accumulator
E63D: D0 06    //            BNE  06       Branch on result not zero
E63F: B1 D0    //            LDA (D0),Y    Load accumulator with memory
E641: C5 CF    //            CMP  CF       Compare memory and accumulator
E643: F0 0E    //            BEQ  0E       Branch on result zero
E645: C8       //            INY           Increment index Y by one
E646: B1 D0    //            LDA (D0),Y    Load accumulator with memory
E648: 48       //            PHA           Push accumulator on stack
E649: C8       //            INY           Increment index Y by one
E64A: B1 D0    //            LDA (D0),Y    Load accumulator with memory
E64C: 85 D1    //            STA  D1       Store accumulator in memory
E64E: 68       //            PLA           Pull accumulator from stack**
E64F: A0 00    //            LDY #00       Load index Y with memory
E651: F0 DB    //            BEQ  DB       Branch on result zero
E653: A5 D0    //            LDA  D0       Load accumulator with memory
E655: 69 03    //            ADC #03       Add memory to accumulator with carry
E657: 20 0A E7 //            JSR  E70A     Jump to new location saving return address
E65A: A5 D1    //            LDA  D1       Load accumulator with memory
E65C: 69 00    //            ADC #00       Add memory to accumulator with carry
E65E: 95 78    //            STA  78,X     Store accumulator in memory
E660: A5 CF    //            LDA  CF       Load accumulator with memory
E662: C9 40    //            CMP #40       Compare memory and accumulator
E664: D0 1C    //            BNE  1C       Branch on result not zero
E666: 88       //            DEY           Dekrement index Y by one
E667: 98       //            TYA           Transfer index Y to accumulator
E668: 20 0A E7 //            JSR  E70A     Jump to new location saving return address
E66B: 88       //            DEY           Dekrement index Y by one
E66C: 94 78    //            STY  78,X     Store index Y in memory
E66E: A0 03    //            LDY #03       Load index Y with memory
E670: F6 78    //            INC  78,X     Increment memory by one
E672: C8       //            INY           Increment index Y by one
E673: B1 D0    //            LDA (D0),Y    Load accumulator with memory
E675: 30 F9    //            BMI  F9       Branch on result minus
E677: 10 09    //            BPL  09       Branch on result plus
E679: A9 00    //            LDA #00       Load accumulator with memory
E67B: 85 D4    //            STA  D4       Store accumulator in memory
E67D: 85 D5    //            STA  D5       Store accumulator in memory
E67F: A2 20    //            LDX #20       Load index X with memory
E681: 48       //            PHA           Push accumulator on stack
E682: A0 00    //            LDY #00       Load index Y with memory
E684: B1 E0    //            LDA (E0),Y    Load accumulator with memory
E686: 10 18    //            BPL  18       Branch on result plus
E688: 0A       //            ASL           Shift accumulator left one bit
E689: 30 81    //            BMI  81       Branch on result minus
E68B: 20 FF E6 //            JSR  E6FF     Jump to new location saving return address
E68E: 20 08 E7 //            JSR  E708     Jump to new location saving return address
E691: 20 FF E6 //            JSR  E6FF     Jump to new location saving return address
E694: 95 A0    //            STA  A0,X     Store accumulator in memory
E696: 24 D4    //            BIT  D4       Test bits in memory with accumulator
E698: 10 01    //            BPL  01       Branch on result plus
E69A: CA       //            DEX           Decrement index X by one
E69B: 20 FF E6 //            JSR  E6FF     Jump to new location saving return address
E69E: B0 E6    //            BCS  E6       Branch on carry set
E6A0: C9 28    //            CMP #28       Compare memory and accumulator
E6A2: D0 1F    //            BNE  1F       Branch on result not zero
E6A4: A5 E0    //            LDA  E0       Load accumulator with memory
E6A6: 20 0A E7 //            JSR  E70A     Jump to new location saving return address
E6A9: A5 E1    //            LDA  E1       Load accumulator with memory
E6AB: 95 78    //            STA  78,X     Store accumulator in memory
E6AD: 24 D4    //            BIT  D4       Test bits in memory with accumulator
E6AF: 30 0B    //            BMI  0B       Branch on result minus
E6B1: A9 01    //            LDA #01       Load accumulator with memory
E6B3: 20 0A E7 //            JSR  E70A     Jump to new location saving return address
E6B6: A9 00    //            LDA #00       Load accumulator with memory
E6B8: 95 78    //            STA  78,X     Store accumulator in memory
E6BA: F6 78    //            INC  78,X     Increment memory by one
E6BC: 20 FF E6 //            JSR  E6FF     Jump to new location saving return address
E6BF: 30 F9    //            BMI  F9       Branch on result minus
E6C1: B0 D3    //            BCS  D3       Branch on carry set
E6C3: 24 D4    //            BIT  D4       Test bits in memory with accumulator
E6C5: 10 06    //            BPL  06       Branch on result plus
E6C7: C9 04    //            CMP #04       Compare memory and accumulator
E6C9: B0 D0    //            BCS  D0       Branch on carry set
E6CB: 46 D4    //            LSR  D4       Shift right one bit
E6CD: A8       //            TAY           Transfer accumulator to index Y
E6CE: 85 D6    //            STA  D6       Store accumulator in memory
E6D0: B9 98 E9 //            LDA  E998,Y   Load accumulator with memory
E6D3: 29 55    //            AND #55       'AND' memory with accumulator
E6D5: 0A       //            ASL           Shift accumulator left one bit
E6D6: 85 D7    //            STA  D7       Store accumulator in memory
E6D8: 68       //            PLA           Pull accumulator from stack**
E6D9: A8       //            TAY           Transfer accumulator to index Y
E6DA: B9 98 E9 //            LDA  E998,Y   Load accumulator with memory
E6DD: 29 AA    //            AND #AA       'AND' memory with accumulator
E6DF: C5 D7    //            CMP  D7       Compare memory and accumulator
E6E1: B0 09    //            BCS  09       Branch on carry set
E6E3: 98       //            TYA           Transfer index Y to accumulator
E6E4: 48       //            PHA           Push accumulator on stack
E6E5: 20 FF E6 //            JSR  E6FF     Jump to new location saving return address
E6E8: A5 D6    //            LDA  D6       Load accumulator with memory
E6EA: 90 95    //            BCC  95       Branch on carry clear
E6EC: B9 10 EA //            LDA  EA10,Y   Load accumulator with memory
E6EF: 85 CE    //            STA  CE       Store accumulator in memory
E6F1: B9 88 EA //            LDA  EA88,Y   Load accumulator with memory
E6F4: 85 CF    //            STA  CF       Store accumulator in memory
E6F6: 20 FC E6 //            JSR  E6FC     Jump to new location saving return address
E6F9: 4C D8 E6 //            JMP  E6D8     Jump to new location
E6FC: 6C CE 00 //            JMP (00CE)    Jump to new location
E6FF: E6 E0    //            INC  E0       Increment memory by one
E701: D0 02    //            BNE  02       Branch on result not zero
E703: E6 E1    //            INC  E1       Increment memory by one
E705: B1 E0    //            LDA (E0),Y    Load accumulator with memory
E707: 60       //            RTS           Return from subroutine

E708: 94 77    //            STY  77,X     Store index Y in memory
E70A: CA       //            DEX           Decrement index X by one
E70B: 30 03    //            BMI  03       Branch on result minus
E70D: 95 50    //            STA  50,X     Store accumulator in memory
E70F: 60       //            RTS           Return from subroutine

E710: A0 66    //            LDY #66       Load index Y with memory
E712: 4C E0 E3 //            JMP  E3E0     Jump to new location

E715: A0 00    //            LDY #00       Load index Y with memory
E717: B5 50    //            LDA  50,X     Load accumulator with memory
E719: 85 CE    //            STA  CE       Store accumulator in memory
E71B: B5 A0    //            LDA  A0,X     Load accumulator with memory
E71D: 85 CF    //            STA  CF       Store accumulator in memory
E71F: B5 78    //            LDA  78,X     Load accumulator with memory
E721: F0 0E    //            BEQ  0E       Branch on result zero
E723: 85 CF    //            STA  CF       Store accumulator in memory
E725: B1 CE    //            LDA (CE),Y    Load accumulator with memory
E727: 48       //            PHA           Push accumulator on stack
E728: C8       //            INY           Increment index Y by one
E729: B1 CE    //            LDA (CE),Y    Load accumulator with memory
E72B: 85 CF    //            STA  CF       Store accumulator in memory
E72D: 68       //            PLA           Pull accumulator from stack**
E72E: 85 CE    //            STA  CE       Store accumulator in memory
E730: 88       //            DEY           Dekrement index Y by one
E731: E8       //            INX           Increment index X by one
E732: 60       //            RTS           Return from subroutine

E733: 20 4A E7 //            JSR  E74A     Jump to new location saving return address
E736: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E739: 98       //            TYA           Transfer index Y to accumulator
E73A: 20 08 E7 //            JSR  E708     Jump to new location saving return address
E73D: 95 A0    //            STA  A0,X     Store accumulator in memory
E73F: C5 CE    //            CMP  CE       Compare memory and accumulator
E741: D0 06    //            BNE  06       Branch on result not zero
E743: C5 CF    //            CMP  CF       Compare memory and accumulator
E745: D0 02    //            BNE  02       Branch on result not zero
E747: F6 50    //            INC  50,X     Increment memory by one
E749: 60       //            RTS           Return from subroutine

E74A: 20 82 E7 //            JSR  E782     Jump to new location saving return address
E74D: 20 59 E7 //            JSR  E759     Jump to new location saving return address
E750: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E753: 24 CF    //            BIT  CF       Test bits in memory with accumulator
E755: 30 1B    //            BMI  1B       Branch on result minus
E757: CA       //            DEX           Decrement index X by one
E758: 60       //            RTS           Return from subroutine

E759: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E75C: A5 CF    //            LDA  CF       Load accumulator with memory
E75E: D0 04    //            BNE  04       Branch on result not zero
E760: A5 CE    //            LDA  CE       Load accumulator with memory
E762: F0 F3    //            BEQ  F3       Branch on result zero
E764: A9 FF    //            LDA #FF       Load accumulator with memory
E766: 20 08 E7 //            JSR  E708     Jump to new location saving return address
E769: 95 A0    //            STA  A0,X     Store accumulator in memory
E76B: 24 CF    //            BIT  CF       Test bits in memory with accumulator
E76D: 30 E9    //            BMI  E9       Branch on result minus
E76F: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E772: 98       //            TYA           Transfer index Y to accumulator
E773: 38       //            SEC           Set carry flag
E774: E5 CE    //            SBC  CE       Subtrac memory from accumulator with borrow
E776: 20 08 E7 //            JSR  E708     Jump to new location saving return address
E779: 98       //            TYA           Transfer index Y to accumulator
E77A: E5 CF    //            SBC  CF       Subtrac memory from accumulator with borrow
E77C: 50 23    //            BVC  23       Branch on overflow clear
E77E: A0 00    //            LDY #00       Load index Y with memory
E780: 10 90    //            BPL  90       Branch on result plus
E782: 20 6F E7 //            JSR  E76F     Jump to new location saving return address
E785: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E788: A5 CE    //            LDA  CE       Load accumulator with memory
E78A: 85 DA    //            STA  DA       Store accumulator in memory
E78C: A5 CF    //            LDA  CF       Load accumulator with memory
E78E: 85 DB    //            STA  DB       Store accumulator in memory
E790: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E793: 18       //            CLC           Clear carry flag
E794: A5 CE    //            LDA  CE       Load accumulator with memory
E796: 65 DA    //            ADC  DA       Add memory to accumulator with carry
E798: 20 08 E7 //            JSR  E708     Jump to new location saving return address
E79B: A5 CF    //            LDA  CF       Load accumulator with memory
E79D: 65 DB    //            ADC  DB       Add memory to accumulator with carry
E79F: 70 DD    //            BVS  DD       Branch on overflow set
E7A1: 95 A0    //            STA  A0,X     Store accumulator in memory
E7A3: 60       //            RTS           Return from subroutine

E7A4: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E7A7: A4 CE    //            LDY  CE       Load index Y with memory
E7A9: F0 05    //            BEQ  05       Branch on result zero
E7AB: 88       //            DEY           Dekrement index Y by one
E7AC: A5 CF    //            LDA  CF       Load accumulator with memory
E7AE: F0 0C    //            BEQ  0C       Branch on result zero
E7B0: 60       //            RTS           Return from subroutine

E7B1: A5 24    //            LDA  24       Load accumulator with memory
E7B3: 09 07    //            ORA #07       'Or' memory with accumulator
E7B5: A8       //            TAY           Transfer accumulator to index Y
E7B6: C8       //            INY           Increment index Y by one
E7B7: A9 A0    //            LDA #A0       Load accumulator with memory
E7B9: 20 C9 E3 //            JSR  CharOut  Jump to new location saving return address
E7BC: C4 24    //            CPY  24       Compare memory and index Y
E7BE: B0 F7    //            BCS  F7       Branch on carry set
E7C0: 60       //            RTS           Return from subroutine

E7C1: 20 B1 E7 //            JSR  E7B1     Jump to new location saving return address
E7C4: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E7C7: A5 CF    //            LDA  CF       Load accumulator with memory
E7C9: 10 0A    //            BPL  0A       Branch on result plus
E7CB: A9 AD    //            LDA #AD       Load accumulator with memory
E7CD: 20 C9 E3 //            JSR  CharOut  Jump to new location saving return address
E7D0: 20 72 E7 //            JSR  E772     Jump to new location saving return address
E7D3: 50 EF    //            BVC  EF       Branch on overflow clear
E7D5: 88       //            DEY           Dekrement index Y by one
E7D6: 84 D5    //            STY  D5       Store index Y in memory
E7D8: 86 CF    //            STX  CF       Store index X in memory
E7DA: A6 CE    //            LDX  CE       Load index X with memory
E7DC: 20 1B E5 //            JSR  E51B     Jump to new location saving return address
E7DF: A6 CF    //            LDX  CF       Load index X with memory
E7E1: 60       //            RTS           Return from subroutine

E7E2: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E7E5: A5 CE    //            LDA  CE       Load accumulator with memory
E7E7: 85 F6    //            STA  F6       Store accumulator in memory
E7E9: A5 CF    //            LDA  CF       Load accumulator with memory
E7EB: 85 F7    //            STA  F7       Store accumulator in memory
E7ED: 88       //            DEY           Dekrement index Y by one
E7EE: 84 F8    //            STY  F8       Store index Y in memory
E7F0: C8       //            INY           Increment index Y by one
E7F1: A9 0A    //            LDA #0A       Load accumulator with memory
E7F3: 85 F4    //            STA  F4       Store accumulator in memory
E7F5: 84 F5    //            STY  F5       Store index Y in memory
E7F7: 60       //            RTS           Return from subroutine

E7F8: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E7FB: A5 CE    //            LDA  CE       Load accumulator with memory
E7FD: A4 CF    //            LDY  CF       Load index Y with memory
E7FF: 10 F2    //            BPL  F2       Branch on result plus
E801: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E804: B5 50    //            LDA  50,X     Load accumulator with memory
E806: 85 DA    //            STA  DA       Store accumulator in memory
E808: B5 78    //            LDA  78,X     Load accumulator with memory
E80A: 85 DB    //            STA  DB       Store accumulator in memory
E80C: A5 CE    //            LDA  CE       Load accumulator with memory
E80E: 91 DA    //            STA (DA),Y    Store accumulator in memory
E810: C8       //            INY           Increment index Y by one
E811: A5 CF    //            LDA  CF       Load accumulator with memory
E813: 91 DA    //            STA (DA),Y    Store accumulator in memory
E815: E8       //            INX           Increment index X by one
E816: 60       //            RTS           Return from subroutine

E817: 68       //            PLA           Pull accumulator from stack**
E818: 68       //            PLA           Pull accumulator from stack**
E819: 24 D5    //            BIT  D5       Test bits in memory with accumulator
E81B: 10 05    //            BPL  05       Branch on result plus
E81D: 20 CD E3 //            JSR  E3CD     Jump to new location saving return address
E820: 46 D5    //            LSR  D5       Shift right one bit
E822: 60       //            RTS           Return from subroutine
E823: A0 FF    //            LDY #FF       Load index Y with memory
E825: 84 D7    //            STY  D7       Store index Y in memory
E827: 60       //            RTS           Return from subroutine

E828: 20 CD EF //            JSR  EFCD     Jump to new location saving return address
E82B: F0 07    //            BEQ  07       Branch on result zero
E82D: A9 25    //            LDA #25       Load accumulator with memory
E82F: 85 D6    //            STA  D6       Store accumulator in memory
E831: 88       //            DEY           Dekrement index Y by one
E832: 84 D4    //            STY  D4       Store index Y in memory
E834: E8       //            INX           Increment index X by one
E835: 60       //            RTS           Return from subroutine

E836: A5 CA    //            LDA  CA       Load accumulator with memory
E838: A4 CB    //            LDY  CB       Load index Y with memory
E83A: D0 5A    //            BNE  5A       Branch on result not zero
E83C: A0 41    //            LDY #41       Load index Y with memory
E83E: A5 FC    //            LDA  FC       Load accumulator with memory
E840: C9 08    //            CMP #08       Compare memory and accumulator
E842: B0 5E    //            BCS  5E       Branch on carry set
E844: A8       //            TAY           Transfer accumulator to index Y
E845: E6 FC    //            INC  FC       Increment memory by one
E847: A5 E0    //            LDA  E0       Load accumulator with memory
E849: 99 00 01 //            STA  0100,Y   Store accumulator in memory
E84C: A5 E1    //            LDA  E1       Load accumulator with memory
E84E: 99 08 01 //            STA  0108,Y   Store accumulator in memory
E851: A5 DC    //            LDA  DC       Load accumulator with memory
E853: 99 10 01 //            STA  0110,Y   Store accumulator in memory
E856: A5 DD    //            LDA  DD       Load accumulator with memory
E858: 99 18 01 //            STA  0118,Y   Store accumulator in memory
E85B: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E85E: 20 6D E5 //            JSR  E56D     Jump to new location saving return address
E861: 90 04    //            BCC  04       Branch on carry clear
E863: A0 37    //            LDY #37       Load index Y with memory
E865: D0 3B    //            BNE  3B       Branch on result not zero
E867: A5 E4    //            LDA  E4       copy e4/e5-pointer to dc/dd-pointer
E869: A4 E5    //            LDY  E5
E86B: 85 DC    //            STA  DC
E86D: 84 DD    //            STY  DD
E86F: 2C 11 D0 //            BIT  D011     Keyboard input?
E872: 30 4F    //            BMI  4F       Branch on result minus
E874: 18       //            CLC           Clear carry flag
E875: 69 03    //            ADC #03       Add memory to accumulator with carry
E877: 90 01    //            BCC  01       Branch on carry clear
E879: C8       //            INY           Increment index Y by one
E87A: A2 FF    //            LDX #FF       x=ff
E87C: 86 D9    //            STX  D9       Memory(d9)=x -> 0xff
E87E: 9A       //            TXS           reset stackpointer (0xff)
E87F: 85 E0    //            STA  E0       Store accumulator in memory
E881: 84 E1    //            STY  E1       Store index Y in memory
E883: 20 79 E6 //            JSR  E679     Jump to new location saving return address
E886: 24 D9    //            BIT  D9       Test bits in memory with accumulator
E888: 10 49    //            BPL  49       Branch on result plus
E88A: 18       //            CLC           Clear carry flag
E88B: A0 00    //            LDY #00       Load index Y with memory
E88D: A5 DC    //            LDA  DC       Load accumulator with memory
E88F: 71 DC    //            ADC (DC),Y    Add memory to accumulator with carry
E891: A4 DD    //            LDY  DD       Load index Y with memory
E893: 90 01    //            BCC  01       Branch on carry clear
E895: C8       //            INY           Increment index Y by one
E896: C5 4C    //            CMP  4C       Compare memory and accumulator
E898: D0 D1    //            BNE  D1       Branch on result not zero
E89A: C4 4D    //            CPY  4D       Compare memory and index Y
E89C: D0 CD    //            BNE  CD       Branch on result not zero
E89E: A0 34    //            LDY #34       Load index Y with memory
E8A0: 46 D9    //            LSR  D9       Shift right one bit
E8A2: 4C E0 E3 //            JMP  E3E0     Compare memory and accumulator
E8A5: A0 4A    //            LDY #4A       Load index Y with memory
E8A7: A5 FC    //            LDA  FC       Load accumulator with memory
E8A9: F0 F7    //            BEQ  F7       Branch on result zero
E8AB: C6 FC    //            DEC  FC       Decrement memory by one
E8AD: A8       //            TAY           Transfer accumulator to index Y
E8AE: B9 0F 01 //            LDA  010F,Y   Load accumulator with memory
E8B1: 85 DC    //            STA  DC       Store accumulator in memory
E8B3: B9 17 01 //            LDA  0117,Y   Load accumulator with memory
E8B6: 85 DD    //            STA  DD       Store accumulator in memory
E8B8: BE FF 00 //            LDX  00FF,Y   Load index X with memory
E8BB: B9 07 01 //            LDA  0107,Y   Load accumulator with memory
E8BE: A8       //            TAY           Transfer accumulator to index Y
E8BF: 8A       //            TXA           Transfer index X to accumulator
E8C0: 4C 7A E8 //            JMP  E87A     Jump to new location

E8C3: A0 63    //            LDY #63       Print "STOPPED AT "
E8C5: 20 C4 E3 //            JSR           ErrorOutp
E8C8: A0 01    //            LDY #01       y = 1
E8CA: B1 DC    //            LDA (DC),Y    Load low-byte of address to x
E8CC: AA       //            TAX           
E8CD: C8       //            INY           load hi-byte of address to accu
E8CE: B1 DC    //            LDA (DC),Y    
E8D0: 20 1B E5 //            JSR  E51B     Output Line number???
E8D3: 4C B3 E2 //            JMP  Reenter  Jump to new location

E8D6: C6 FB    //            DEC  FB       Decrement memory by one
E8D8: A0 5B    //            LDY #5B       Load index Y with memory
E8DA: A5 FB    //            LDA  FB       Load accumulator with memory
E8DC: F0 C4    //            BEQ  C4       Branch on result zero
E8DE: A8       //            TAY           Transfer accumulator to index Y
E8DF: B5 50    //            LDA  50,X     Load accumulator with memory
E8E1: D9 1F 01 //            CMP  011F,Y   Compare memory and accumulator
E8E4: D0 F0    //            BNE  F0       Branch on result not zero
E8E6: B5 78    //            LDA  78,X     Load accumulator with memory
E8E8: D9 27 01 //            CMP  0127,Y   Compare memory and accumulator
E8EB: D0 E9    //            BNE  E9       Branch on result not zero
E8ED: B9 2F 01 //            LDA  012F,Y   Load accumulator with memory
E8F0: 85 DA    //            STA  DA       Store accumulator in memory
E8F2: B9 37 01 //            LDA  0137,Y   Load accumulator with memory
E8F5: 85 DB    //            STA  DB       Store accumulator in memory
E8F7: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E8FA: CA       //            DEX           Decrement index X by one
E8FB: 20 93 E7 //            JSR  E793     Jump to new location saving return address
E8FE: 20 01 E8 //            JSR  E801     Jump to new location saving return address
E901: CA       //            DEX           Decrement index X by one
E902: A4 FB    //            LDY  FB       Load index Y with memory
E904: B9 67 01 //            LDA  0167,Y   Load accumulator with memory
E907: 95 9F    //            STA  9F,X     Store accumulator in memory
E909: B9 5F 01 //            LDA  015F,Y   Load accumulator with memory
E90C: A0 00    //            LDY #00       Load index Y with memory
E90E: 20 08 E7 //            JSR  E708     Jump to new location saving return address
E911: 20 82 E7 //            JSR  E782     Jump to new location saving return address
E914: 20 59 E7 //            JSR  E759     Jump to new location saving return address
E917: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E91A: A4 FB    //            LDY  FB       Load index Y with memory
E91C: A5 CE    //            LDA  CE       Load accumulator with memory
E91E: F0 05    //            BEQ  05       Branch on result zero
E920: 59 37 01 //            EOR  0137,Y   'Exclusive-Or' memory with accumulator
E923: 10 12    //            BPL  12       Branch on result plus
E925: B9 3F 01 //            LDA  013F,Y   Load accumulator with memory
E928: 85 DC    //            STA  DC       Store accumulator in memory
E92A: B9 47 01 //            LDA  0147,Y   Load accumulator with memory
E92D: 85 DD    //            STA  DD       Store accumulator in memory
E92F: BE 4F 01 //            LDX  014F,Y   Load index X with memory
E932: B9 57 01 //            LDA  0157,Y   Load accumulator with memory
E935: D0 87    //            BNE  87       Branch on result not zero
E937: C6 FB    //            DEC  FB       Decrement memory by one
E939: 60       //            RTS           Return from subroutine

E93A: A0 54    //            LDY #54       Load index Y with memory
E93C: A5 FB    //            LDA  FB       Load accumulator with memory
E93E: C9 08    //            CMP #08       Compare memory and accumulator
E940: F0 9A    //            BEQ  9A       Branch on result zero
E942: E6 FB    //            INC  FB       Increment memory by one
E944: A8       //            TAY           Transfer accumulator to index Y
E945: B5 50    //            LDA  50,X     Load accumulator with memory
E947: 99 20 01 //            STA  0120,Y   Store accumulator in memory
E94A: B5 78    //            LDA  78,X     Load accumulator with memory
E94C: 99 28 01 //            STA  0128,Y   Store accumulator in memory
E94F: 60       //            RTS           Return from subroutine

// Saving Basic-State to Basic-Stackpointer??
E950: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E953: A4 FB    //            LDY  FB       Load index Y with memory
E955: A5 CE    //            LDA  CE       copy ce/cf-pointer to ???
E957: 99 5F 01 //            STA  015F,Y
E95A: A5 CF    //            LDA  CF
E95C: 99 67 01 //            STA  0167,Y
E95F: A9 01    //            LDA #01       fill 0001 to ???
E961: 99 2F 01 //            STA  012F,Y
E964: A9 00    //            LDA #00
E966: 99 37 01 //            STA  0137,Y
E969: A5 DC    //            LDA  DC       copy dc/dd-pointer to ???
E96B: 99 3F 01 //            STA  013F,Y
E96E: A5 DD    //            LDA  DD
E970: 99 47 01 //            STA  0147,Y
E973: A5 E0    //            LDA  E0       copy e0/e1-pointer to ???
E975: 99 4F 01 //            STA  014F,Y
E978: A5 E1    //            LDA  E1
E97A: 99 57 01 //            STA  0157,Y
E97D: 60       //            RTS           Return from subroutine

E97E: 20 15 E7 //            JSR  E715     Jump to new location saving return address
E981: A4 FB    //            LDY  FB       Load index Y with memory
E983: A5 CE    //            LDA  CE       Load accumulator with memory
E985: 99 2F 01 //            STA  012F,Y   Store accumulator in memory
E988: A5 CF    //            LDA  CF       Load accumulator with memory
E98A: 4C 66 E9 //            JMP  E966     Jump to new location

E98D: 00 00 00
E990: 00 00 00 00 00 00 00 00    //  ........
E998: 00 00 00 AB 03 03 03 03    //  ...+....
E9A0: 03 03 03 03 03 03 03 03    //  ........
E9A8: 03 03 3F 3F C0 C0 3C 3C    //  ..??@@<<
E9B0: 3C 3C 3C 3C 3C 30 0F C0    //  <<<<<0.@
E9B8: CC FF 55 00 AB AB 03 03    //  L.U.++..
E9C0: FF FF 55 FF FF 55 CF CF    //  ..U..UOO
E9C8: CF CF CF FF 55 C3 C3 C3    //  OOO.UCCC
E9D0: 55 F0 F0 CF 56 56 56 55    //  UppOVVVU
E9D8: FF FF 55 03 03 03 03 03    //  ..U.....
E9E0: 03 03 FF FF FF 03 03 03    //  ........
E9E8: 03 03 03 03 03 03 03 03    //  ........
E9F0: 03 03 03 03 03 00 AB 03    //  ......+.
E9F8: 57 03 03 03 03 07 03 03    //  W.......
EA00: 03 03 03 03 03 03 03 03    //  ........
EA08: 03 03 AA FF FF FF FF FF    //  ..*.....
EA10: 17 FF FF 19 5D 35 4B F2    //  ....]5Kr
EA18: EC 87 6F AD B7 E2 F8 54    //  l.o-7bxT
EA20: 80 96 85 82 22 10 33 4A    //  ....".3J
EA28: 13 06 0B 4A 01 40 47 7A    //  ...J.@G.
EA30: 00 FF 23 09 5B 16 B6 CB    //  ..#.[.6K
EA38: FF FF FB FF FF 24 F6 4E    //  .....$vN
EA40: 59 50 00 FF 23 A3 6F 36    //  YP..##o6
EA48: 23 D7 1C 22 C2 AE BA 23    //  #W."B.:#
EA50: FF FF 21 30 1E 03 C4 20    //  ..!0..D 
EA58: 00 C1 FF FF FF A0 30 1E    //  .A... 0.
EA60: A4 D3 B6 BC AA 3A 01 50    //  $S6<*:.P
EA68: 7E D8 D8 A5 3C FF 16 5B    //  .XX%<..[
EA70: 28 03 C4 1D 00 0C 4E 00    //  (.D...N.
EA78: 3E 00 A6 B0 00 BC C6 57    //  >.&0.<FW
EA80: 8C 01 27 FF FF FF FF FF    //  ..'.....
EA88: E8 FF FF E8 E0 E0 E0 EF    //  h..h```o
EA90: EF E3 E3 E5 E5 E7 E7 EE    //  occeeggn
EA98: EF EF E7 E7 E2 EF E7 E7    //  ooggbogg
EAA0: EC EC EC E7 EC EC EC E2    //  lllglllb
EAA8: 00 FF E8 E1 E8 E8 EF EB    //  ..hahhok
EAB0: FF FF E0 FF FF EF EE EF    //  ..`..ono
EAB8: E7 E7 00 FF E8 E7 E7 E7    //  gg..hggg
EAC0: E8 E1 E2 EE EE EE EE E8    //  habnnnnh
EAC8: FF FF E1 E1 EF EE E7 E8    //  ..aaongh
EAD0: EE E7 FF FF FF EE E1 EF    //  ng...nao
EAD8: E7 E8 EF EF EB E9 E8 E9    //  ghookihi
EAE0: E9 E8 E8 E8 E8 FF E8 E8    //  ihhhh.hh
EAE8: E8 EE E7 E8 EF EF EE EF    //  hnghoono
EAF0: EE EF EE EE EF EE EE EE    //  nonnonnn
EAF8: E1 E8 E8 FF FF FF FF FF    //  ahh.....

EB00: BE B3 B2 B7 B6 37                //            ">32767"
EB06: D4 CF CF A0 CC CF CE 47          //            "TOO LONG"
EB0E: D3 D9 CE D4 C1 58                //            "SYNTAX"
EB14: CD C5 CD A0 C6 D5 CC 4C          //            "MEM FULL 
EB1C: D4 CF CF A0 CD C1 CE D9          //            "TOO MANY
EB24: A0 D0 C1 D2 C5 CE 53             //            "PARENS"
EB2B: D3 D4 D2 C9 CE 47                //            "STRING"
EB31: CE CF A0 C5 CE 44                //            "NO END"
EB37: C2 C1 C4 A0 C2 D2 C1 CE C3 48    //            "BAD BRANCH"
EB41: BE B8 A0 C7 CF D3 D5 C2 53       //            ">8 GOSUBS"
EB4A: C2 C1 C4 A0 D2 C5 D4 D5 D2 4E    //            "BAD RETURN"
EB54: BE B8 A0 C6 CF D2 53             //            ">8 FORS"
EB5B: C2 C1 C4 A0 CE C5 D8 54          //            "BAD NEXT"
EB63: D3 D4 CF D0 D0 C5 C4 A0 C1 D4 20 //            "STOPPED AT "
EB6E: AA AA AA 20                      //            "*** "
EB73: A0 C5 D2 D2 0D                   //            " ERR"
EB77: BE B2 B5 35                      //            ">255"
EB7B: D2 C1 CE C7 45                   //            "RANGE"
EB80: C4 C9 4D                         //            "DIM"
EB83: D3 D4 D2 A0 CF D6 C6 4C          //            "STR OVFL"
E88B: DC 0D                            //            "\"+<RETURN>
EB8D: D2 C5 D4 D9 D0 C5 A0 CC C9 CE C5 8D //         "RETYPE LINE"
EB99: 3F                               //            "?"

EB9A: 46 D9    //            LSR  D9       Shift right one bit
EB9C: 90 03    //            BCC  03       Branch on carry clear
EB9E: 4C C3 E8 //            JMP  E8C3     Jump to new location

EBA1: A6 CF    //            LDX  CF       x = 0xCF
EBA3: 9A       //            TXS           stackpointer = 0xCF
EBA4: A6 CE    //            LDX  CE       Load index X with memory
EBA6: A0 8D    //            LDY #8D       Load index Y with memory
EBA8: D0 02    //            BNE  02       Branch on result not zero
EBAA: A0 99    //            LDY #99       Print "?"
EBAC: 20 C4 E3 //            JSR  ErrorOutp
EBAF: 86 CE    //            STX  CE       Store index X in memory
EBB1: BA       //            TSX           Transfer stack pointer to index X
EBB2: 86 CF    //            STX  CF       Store index X in memory
EBB4: A0 FE    //            LDY #FE       Load index Y with memory
EBB6: 84 D9    //            STY  D9       Store index Y in memory
EBB8: C8       //            INY           Increment index Y by one
EBB9: 84 C8    //            STY  C8       Store index Y in memory
EBBB: 20 99 E2 //            JSR  E299     Jump to new location saving return address
EBBE: 84 F1    //            STY  F1       Store index Y in memory
EBC0: A2 20    //            LDX #20       Load index X with memory
EBC2: A9 30    //            LDA #30       Load accumulator with memory
EBC4: 20 91 E4 //            JSR  E491     Jump to new location saving return address
EBC7: E6 D9    //            INC  D9       Increment memory by one
EBC9: A6 CE    //            LDX  CE       Load index X with memory
EBCB: A4 C8    //            LDY  C8       Load index Y with memory
EBCD: 0A       //            ASL           Shift accumulator left one bit
EBCE: 85 CE    //            STA  CE       Store accumulator in memory
EBD0: C8       //            INY           Increment index Y by one
EBD1: B9 00 02 //            LDA  0200,Y   Load accumulator with memory
EBD4: C9 74    //            CMP #74       Compare memory and accumulator
EBD6: F0 D2    //            BEQ  D2       Branch on result zero
EBD8: 49 B0    //            EOR #B0       'Exclusive-Or' memory with accumulator
EBDA: C9 0A    //            CMP #0A       Compare memory and accumulator
EBDC: B0 F0    //            BCS  F0       Branch on carry set
EBDE: C8       //            INY           Increment index Y by one
EBDF: C8       //            INY           Increment index Y by one
EBE0: 84 C8    //            STY  C8       Store index Y in memory
EBE2: B9 00 02 //            LDA  0200,Y   Load accumulator with memory
EBE5: 48       //            PHA           Push accumulator on stack
EBE6: B9 FF 01 //            LDA  01FF,Y   Load accumulator with memory
EBE9: A0 00    //            LDY #00       Load index Y with memory
EBEB: 20 08 E7 //            JSR  E708     Jump to new location saving return address
EBEE: 68       //            PLA           Pull accumulator from stack**
EBEF: 95 A0    //            STA  A0,X     Store accumulator in memory
EBF1: A5 CE    //            LDA  CE       Load accumulator with memory
EBF3: C9 C7    //            CMP #C7       Compare memory and accumulator
EBF5: D0 03    //            BNE  03       Branch on result not zero
EBF7: 20 6F E7 //            JSR  E76F     Jump to new location saving return address
EBFA: 4C 01 E8 //            JMP  E801     Jump to new location

EBFD: FF FF FF

EC00: 50 20    //            BVC  20       Branch on overflow clear
EC02: 13
EC03: EC D0 15 //            CPX  15D0     Compare memory and index X
EC06: 20 0B EC //            JSR  EC0B     Jump to new location saving return address
EC09: D0 10    //            BNE  10       Branch on result not zero
EC0B: 20 82 E7 //            JSR  E782     Jump to new location saving return address
EC0E: 20 6F E7 //            JSR  E76F     Jump to new location saving return address
EC11: 50 03    //            BVC  03       Branch on overflow clear
EC13: 20 82 E7 //            JSR  E782     Jump to new location saving return address
EC16: 20 59 E7 //            JSR  E759     Jump to new location saving return address
EC19: 56 50    //            LSR  50,X     Shift right one bit
EC1B: 4C 36 E7 //            JMP  E736     Jump to new location

EC1E: FF FF
EC20: C1 FF 7F D1 CC C7 CF CE    //  A..QLGON
EC28: C5 9A 98 8B 96 95 93 BF    //  E......?
EC30: B2 32 2D 2B BC B0 AC BE    //  22-+<0,>
EC38: 35 8E 61 FF FF FF DD FB    //  5.a...].
EC40: 20 C9 EF 15 4F 10 05 20    //   Io.O.. 
EC48: C9 EF 35 4F 95 50 10 CB    //  Io5O.P.K
EC50: 4C C9 EF 40 60 8D 60 8B    //  LIo@`.`.
EC58: 00 7E 8C 33 00 00 60 03    //  ...3..`.
EC60: BF 12 00 40 89 C9 47 9D    //  ?..@.IG.
EC68: 17 68 9D 0A 00 40 60 8D    //  .h...@`.
EC70: 60 8B 00 7E 8C 3C 00 00    //  `....<..
EC78: 60 03 BF 1B 4B 67 B4 A1    //  `.?.Kg4!
EC80: 07 8C 07                   //  ...

// converting the bytes to readable ascii:
// ascii = (byte and 0x3F) + 0xA0

EC83: AE  // => N
EC84: A9  // => I
EC85: AC  // => L
EC86: A8  // => H	HLIN
EC87: 67
EC88: 8C
EC89: 07C8A: B4  // => T
EC8B: AF  // => O
EC8C: AC  // => L
EC8D: B0  // => P	PLOT
EC8E: 67
EC8F: 9D
EC90: B2  // => R
EC91: AF  // => O
EC92: AC  // => L
EC93: AF  // => O
EC94: A3  // => C	COLOR
EC95: 67
EC96: 8C
EC97: 07
EC98: A5  // => E
EC99: AB  // => K
EC9A: AF  // => O
EC9B: B0  // => P	POKE
EC9C: F4  // => T
EC9D: AE  // => N
EC9E: A9  // => I
EC9F: B2  // => R
ECA0: B0  // => P	PRINT
ECA1: 7F
ECA2: 0E
ECA3: 27  // => G
ECA4: B4  // => T
ECA5: AE  // => N
ECA6: A9  // => I
ECA7: B2  // => R
ECA8: B0  // => P	PRINTG or PRINT (?)
ECA9: 7F
ECAA: 0E
ECAB: 28  // => H
ECAC: B4  // => T
ECAD: AE  // => N
ECAE: A9  // => I
ECAF: B2  // => R
ECB0: B0  // => P	PRINTH or PRINT (?)
ECB1: 64
ECB2: 07
ECB3: A6  // => F
ECB4: A9  // => I	IF
ECB5: 67
ECB6: AF  // => O
ECB7: B4  // => T
ECB8: AF  // => O
ECB9: A7  // => G	GOTO
ECBA: 78
ECBB: B4  // => T
ECBC: A5  // => E
ECBD: AC  // => L	LET
ECBE: 78
ECBF: 7F
ECC0: 02
ECC1: AD  // => M
ECC2: A5  // => E
ECC3: B2  // => R	REM
ECC4: 67
ECC5: A2  // => B
ECC6: B5  // => U
ECC7: B3  // => S
ECC8: AF  // => O
ECC9: A7  // => G	GOSUB
ECCA: EE  // => N
ECCB: B2  // => R
ECCC: B5  // => U
ECCD: B4  // => T
ECCE: A5  // => E
ECCF: B2  // => R	RETURN
ECD0: 7E
ECD1: 8C
ECD2: 39
ECD3: B4  // => T
ECD4: B8  // => X
ECD5: A5  // => E
ECD6: AE  // => N	NEXT
ECD7: 67
ECD8: B0  // => P
ECD9: A5  // => E
ECDA: B4  // => T
ECDB: B3  // => S	STEP
ECDC: 27
ECDD: AF  // => O
ECDE: B4  // => T	TO
ECDF: 07
ECE0: 9D
ECE1: 19
ECE2: B2  // => R
ECE3: AF  // => O
ECE4: A6  // => F	FOR
ECE5: 7F
ECE6: 05
ECE7: 37
ECE8: B4  // => T
ECE9: B5  // => U
ECEA: B0  // => P
ECEB: AE  // => N
ECEC: A9  // => I	INPUT
ECED: 7F
ECEE: 05
ECEF: 28  // => H
ECF0: B4  // => T
ECF1: B5  // => U
ECF2: B0  // => P
ECF3: AE  // => N
ECF4: A9  // => I	INPUTH
ECF5: 7F
ECF6: 05
ECF7: 2A  // => J
ECF8: B4  // => T
ECF9: B5  // => U
ECFA: B0  // => P
ECFB: AE  // => N
ECFC: A9  // => I	INPUTJ
ECFD: E4  // => D
ECFE: AE  // => N
ECFF: A5  // => E	END
ED00: 00
ED01: FF
ED02: FF
ED03: 47
ED04: A2  // => B
ED05: A1  // => A
ED06: B4  // => T	TAB
ED07: 7F
ED08: 0D
ED09: 30
ED0A: AD  // => M
ED0B: A9  // => I
ED0C: A4  // => D	DIM
ED0D: 7F
ED0E: 0D
ED0F: 23  // => C
ED10: AD  // => M
ED11: A9  // => I
ED12: A4  // => D	DIMC
ED13: 67
ED14: AC  // => L
ED15: AC  // => L
ED16: A1  // => A
ED17: A3  // => C	CALL

ED18: 00 40 80 C0 C1 80 00 47    //  .@.@A..G
ED20: 8C 68 8C DB 67 9B 68 9B    //  .h.[g.h.
ED28: 50 8C 63 8C 7F 01 51 07    //  P.c...Q.
ED30: 88 29 84 80 C4 80 57 71    //  .)..D.Wq
ED38: 07 88 14                   //  ...

ED3B: ED  // => M
ED3C: A5  // => E
ED3D: AD  // => M
ED3E: AF  // => O
ED3F: AC  // => L	LOMEM
ED40: ED  // => M
ED41: A5  // => E
ED42: AD  // => M
ED43: A9  // => I
ED44: A8  // => H	HIMEM
ED45: F2  // => R
ED46: AF  // => O
ED47: AC  // => L
ED48: AF  // => O
ED49: A3  // => C	COLOR
ED4A: 71
ED4B: 08
ED4C: 88
ED4D: AE  // => N
ED4E: A5  // => E
ED4F: AC  // => L	LEN
ED50: 68
ED51: 83
ED52: 08
ED53: 68
ED54: 9D
ED55: 08
ED56: 71
ED57: 07
ED58: 88
ED59: 60
ED5A: 76
ED5B: B4  // => T
ED5C: AF  // => O
ED5D: AE  // => N	NOT
ED5E: 76
ED5F: 8D
ED60: 76
ED61: 8B
ED62: 51
ED63: 07
ED64: 88
ED65: 19
ED66: B8
ED67: A4  // => D
ED68: AE  // => N
ED69: B2  // => R	RND
ED6A: F2 
ED6B: B3
ED6C: B5
ED6D: F3  // => S
ED6E: A2  // => B
ED6F: A1  // => A	ABS
ED70: EE  // => N
ED71: A7  // => G
ED72: B3  // => S	SNG
ED73: E4  // => D
ED74: AE  // => N
ED75: B2  // => R	RND
ED76: EB  // => K
ED77: A5  // => E
ED78: A5  // => E
ED79: B0  // => P	PEEK

ED7A: 51 07 88 39 81 C1
ED80: 4F 7F 0F 2F 00 51 06 88
ED88: 29 C2 0C 82 57 8C 6A 8C
ED90: 42

ED91: AE  // => N
ED92: A5  // => E
ED93: A8  // => H
ED94: B4  // => T	THEN
ED95: 60
ED96: AE  // => N
ED97: A5  // => E
ED98: A8  // => H
ED99: B4  // => T	THEN

ED9A: 4F 7E 1E 35 8C 27
EDA0: 51 07 88 09 8B FE

EDA6: E4  // => D
EDA7: AF  // => O
EDA8: AD  // => M	MOD
EDA9: F2  // => R
EDAA: AF  // => O	OR
EDAB: E4  // => D
EDAC: AE  // => N
EDAD: A1  // => A	AND

EDAE: DC  // => <
EDAF: DE  // => >
EDB0: 9C  // => <
EDB1: DD  // => =
EDB2: 9C  // => <
EDB3: DE  // => >
EDB4: DD  // => =
EDB5: 9E  // => >
EDB6: C3  // => #
EDB7: DD  // => =
EDB8: CF  // => /
EDB9: CA  // => *
EDBA: CD  // => -
EDBB: CB  // => +
EDBC: 00  // =>  
EDBD: 47  // => '
EDBE: 9D  // => =	math symbols

EDBF: AD  // => M
EDC0: A5  // => E
EDC1: AD  // => M
EDC2: AF  // => O
EDC3: AC  // => L	LOMEM
EDC4: 76
EDC5: 9D
EDC6: AD  // => M
EDC7: A5  // => E
EDC8: AD  // => M
EDC9: A9  // => I
EDCA: A8  // => H	HIMEM
EDCB: E6  // => F
EDCC: A6  // => F
EDCD: AF  // => O	OFF
EDCE: 60
EDCF: 8C
EDD0: 20
EDD1: AF  // => O
EDD2: B4  // => T
EDD3: B5  // => U
EDD4: A1  // => A	AUTO
EDD5: F2  // => R
EDD6: AC  // => L
EDD7: A3  // => C	CLR
EDD8: F2  // => R
EDD9: A3  // => C
EDDA: B3  // => S	SCR (?)
EDDB: 60
EDDC: 8C
EDDD: 20
EDDE: AC  // => L
EDDF: A5  // => E
EDE0: A4  // => D	DEL
EDE1: EE  // => N
EDE2: B5  // => U
EDE3: B2  // => R	RUN
EDE4: 60
EDE5: AE  // => N
EDE6: B5  // => U
EDE7: B2  // => R	RUN
EDE8: F4  // => T
EDE9: B3  // => S
EDEA: A9  // => I
EDEB: AC  // => L	LIST
EDEC: 60
EDED: 8C
EDEE: 20
EDEF: B4  // => T
EDF0: B3  // => S
EDF1: A9  // => I
EDF2: AC  // => L	LIST

EDF3: 7A 7E 9A 22 20 00 60
EDFA: 03 BF 60 03 BF 1F

EE00: 20 B1 E7 //            JSR  E7B1     Jump to new location saving return address
EE03: E8       //            INX           Increment index X by one
EE04: E8       //            INX           Increment index X by one
EE05: B5 4F    //            LDA  4F,X     Load accumulator with memory
EE07: 85 DA    //            STA  DA       Store accumulator in memory
EE09: B5 77    //            LDA  77,X     Load accumulator with memory
EE0B: 85 DB    //            STA  DB       Store accumulator in memory
EE0D: B4 4E    //            LDY  4E,X     Load index Y with memory
EE0F: 98       //            TYA           Transfer index Y to accumulator
EE10: D5 76    //            CMP  76,X     Compare memory and accumulator
EE12: B0 09    //            BCS  09       Branch on carry set
EE14: B1 DA    //            LDA (DA),Y    Load accumulator with memory
EE16: 20 C9 E3 //            JSR  CharOut  Jump to new location saving return address
EE19: C8       //            INY           Increment index Y by one
EE1A: 4C 0F EE //            JMP  EE0F     Jump to new location
EE1D: A9 FF    //            LDA #FF       Load accumulator with memory
EE1F: 85 D5    //            STA  D5       Store accumulator in memory
EE21: 60       //            RTS           Return from subroutine

EE22: E8       //            INX           Increment index X by one
EE23: A9 00    //            LDA #00       Load accumulator with memory
EE25: 95 78    //            STA  78,X     Store accumulator in memory
EE27: 95 A0    //            STA  A0,X     Store accumulator in memory
EE29: B5 77    //            LDA  77,X     Load accumulator with memory
EE2B: 38       //            SEC           Set carry flag
EE2C: F5 4F    //            SBC  4F,X     Subtrac memory from accumulator with borrow
EE2E: 95 50    //            STA  50,X     Store accumulator in memory
EE30: 4C 23 E8 //            JMP  E823     Jump to new location

EE33: FF       //            ''
EE34: 20 15 E7 //            JSR  E715     Jump to new location saving return address
EE37: A5 CF    //            LDA  CF       Load accumulator with memory
EE39: D0 28    //            BNE  28       Branch on result not zero
EE3B: A5 CE    //            LDA  CE       Load accumulator with memory
EE3D: 60       //            RTS           Return from subroutine

EE3E: 20 34 EE //            JSR  EE34     Jump to new location saving return address
EE41: A4 C8    //            LDY  C8       Load index Y with memory
EE43: C9 30    //            CMP #30       Compare memory and accumulator
EE45: B0 21    //            BCS  21       Branch on carry set
EE47: C0 28    //            CPY #28       Compare memory and index Y
EE49: B0 1D    //            BCS  1D       Branch on carry set
EE4B: 60       //            RTS           Return from subroutine

EE4C: EA       //            NOP           No operation
EE4D: EA       //            NOP           No operation
EE4E: 20 34 EE //            JSR  EE34     Jump to new location saving return address
EE51: 60       //            RTS           Return from subroutine

EE52: EA       //            NOP           No operation
EE53: 8A       //            TXA           Transfer index X to accumulator
EE54: A2 01    //            LDX #01       Load index X with memory
EE56: B4 CE    //            LDY  CE,X     Load index Y with memory
EE58: 94 4C    //            STY  4C,X     Store index Y in memory
EE5A: B4 48    //            LDY  48,X     Load index Y with memory
EE5C: 94 CA    //            STY  CA,X     Store index Y in memory
EE5E: CA       //            DEX           Decrement index X by one
EE5F: F0 F5    //            BEQ  F5       Branch on result zero
EE61: AA       //            TAX           Transfer accumulator to index X
EE62: 60       //            RTS           Return from subroutine

EE63: A0 77    //            LDY #77       Load index Y with memory
EE65: 4C E0 E3 //            JMP  E3E0     Jump to new location

EE68: A0 7B    //            LDY #7B       Load index Y with memory
EE6A: D0 F9    //            BNE  F9       Branch on result not zero
EE6C: 20 54 E2 //            JSR  E254     Jump to new location saving return address
EE6F: A5 DA    //            LDA  DA       Load accumulator with memory
EE71: D0 07    //            BNE  07       Branch on result not zero
EE73: A5 DB    //            LDA  DB       Load accumulator with memory
EE75: D0 03    //            BNE  03       Branch on result not zero
EE77: 4C 7E E7 //            JMP  E77E     Jump to new location
EE7A: 06 CE    //            ASL  CE       Shift left one Bit (memory or accumulator)
EE7C: 26 CF    //            ROL  CF       Rotate one bit left
EE7E: 26 E6    //            ROL  E6       Rotate one bit left
EE80: 26 E7    //            ROL  E7       Rotate one bit left
EE82: A5 E6    //            LDA  E6       Load accumulator with memory
EE84: C5 DA    //            CMP  DA       Compare memory and accumulator
EE86: A5 E7    //            LDA  E7       Load accumulator with memory
EE88: E5 DB    //            SBC  DB       Subtrac memory from accumulator with borrow
EE8A: 90 0A    //            BCC  0A       Branch on carry clear
EE8C: 85 E7    //            STA  E7       Store accumulator in memory
EE8E: A5 E6    //            LDA  E6       Load accumulator with memory
EE90: E5 DA    //            SBC  DA       Subtrac memory from accumulator with borrow
EE92: 85 E6    //            STA  E6       Store accumulator in memory
EE94: E6 CE    //            INC  CE       Increment memory by one
EE96: 88       //            DEY           Dekrement index Y by one
EE97: D0 E1    //            BNE  E1       Branch on result not zero
EE99: 60       //            RTS           Return from subroutine

EE9A: FF FF FF FF FF FF

EEA0: 20 15 E7 //            JSR  E715     Jump to new location saving return address
EEA3: 6C CE 00 //            JMP (00CE)    Jump to new location
EEA6: A5 4C    //            LDA  4C       Load accumulator with memory
EEA8: D0 02    //            BNE  02       Branch on result not zero
EEAA: C6 4D    //            DEC  4D       Decrement memory by one
EEAC: C6 4C    //            DEC  4C       Decrement memory by one
EEAE: A5 48    //            LDA  48       Load accumulator with memory
EEB0: D0 02    //            BNE  02       Branch on result not zero
EEB2: C6 49    //            DEC  49       Decrement memory by one
EEB4: C6 48    //            DEC  48       Decrement memory by one
EEB6: A0 00    //            LDY #00       Load index Y with memory
EEB8: B1 4C    //            LDA (4C),Y    Load accumulator with memory
EEBA: 91 48    //            STA (48),Y    Store accumulator in memory
EEBC: A5 CA    //            LDA  CA       Load accumulator with memory
EEBE: C5 4C    //            CMP  4C       Compare memory and accumulator
EEC0: A5 CB    //            LDA  CB       Load accumulator with memory
EEC2: E5 4D    //            SBC  4D       Subtrac memory from accumulator with borrow
EEC4: 90 E0    //            BCC  E0       Branch on carry clear
EEC6: 4C 53 EE //            JMP  EE53     Jump to new location
EEC9: C9 28    //            CMP #28       Compare memory and accumulator
EECB: B0 9B    //            BCS  9B       Branch on carry set
EECD: A8       //            TAY           Transfer accumulator to index Y
EECE: A5 C8    //            LDA  C8       Load accumulator with memory
EED0: 60       //            RTS           Return from subroutine

EED1: EA EA    //            NOP           No operation

EED3: 98       // PrintErr:  TYA           save y in x (via accu)
EED4: AA       //            TAX           
EED5: A0 6E    //            LDY #6E       Print "*** "
EED7: 20 C4 E3 //            JSR  ErrorOutp
EEDA: 8A       //            TXA           copy x to y (via accu)
EEDB: A8       //            TAY           
EEDC: 20 C4 E3 //            JSR  ErrorOutp
EEDF: A0 72    //            LDY #72       Print " ERR"
EEE1: 4C C4 E3 //            JMP  ErrorOutp	(and use RTS from ErrorOutp-Subroutine to go back)

EEE4: 20 15 E7 //            JSR  E715     Jump to new location saving return address
EEE7: 06 CE    //            ASL  CE       Shift left one Bit (memory or accumulator)
EEE9: 26 CF    //            ROL  CF       Rotate one bit left
EEEB: 30 FA    //            BMI  FA       Branch on result minus
EEED: B0 DC    //            BCS  DC       Branch on carry set
EEEF: D0 04    //            BNE  04       Branch on result not zero
EEF1: C5 CE    //            CMP  CE       Compare memory and accumulator
EEF3: B0 D6    //            BCS  D6       Branch on carry set
EEF5: 60       //            RTS           Return from subroutine

EEF6: 20 15 E7 //            JSR  E715     Jump to new location saving return address
EEF9: B1 CE    //            LDA (CE),Y    Load accumulator with memory
EEFB: 94 9F    //            STY  9F,X     Store index Y in memory
EEFD: 4C 08 E7 //            JMP  E708     Jump to new location
EF00: 20 34 EE //            JSR  EE34     Jump to new location saving return address
EF03: A5 CE    //            LDA  CE       Load accumulator with memory
EF05: 48       //            PHA           Push accumulator on stack
EF06: 20 15 E7 //            JSR  E715     Jump to new location saving return address
EF09: 68       //            PLA           Pull accumulator from stack**
EF0A: 91 CE    //            STA (CE),Y    Store accumulator in memory
EF0C: 60       //            RTS           Return from subroutine

EF0D: FF FF FFEF10: 20 6C EE //            JSR  EE6C     Jump to new location saving return address
EF13: A5 CE    //            LDA  CE       Load accumulator with memory
EF15: 85 E6    //            STA  E6       Store accumulator in memory
EF17: A5 CF    //            LDA  CF       Load accumulator with memory
EF19: 85 E7    //            STA  E7       Store accumulator in memory
EF1B: 4C 44 E2 //            JMP  E244     Jump to new location

EF1E: 20 E4 EE //            JSR  EEE4     Jump to new location saving return address
EF21: 4C 34 E1 //            JMP  E134     Jump to new location

EF24: 20 E4 EE //            JSR  EEE4     Jump to new location saving return address
EF27: B4 78    //            LDY  78,X     Load index Y with memory
EF29: B5 50    //            LDA  50,X     Load accumulator with memory
EF2B: 69 FE    //            ADC #FE       Add memory to accumulator with carry
EF2D: B0 01    //            BCS  01       Branch on carry set
EF2F: 88       //            DEY           Dekrement index Y by one
EF30: 85 DA    //            STA  DA       Store accumulator in memory
EF32: 84 DB    //            STY  DB       Store index Y in memory
EF34: 18       //            CLC           Clear carry flag
EF35: 65 CE    //            ADC  CE       Add memory to accumulator with carry
EF37: 95 50    //            STA  50,X     Store accumulator in memory
EF39: 98       //            TYA           Transfer index Y to accumulator
EF3A: 65 CF    //            ADC  CF       Add memory to accumulator with carry
EF3C: 95 78    //            STA  78,X     Store accumulator in memory
EF3E: A0 00    //            LDY #00       Load index Y with memory
EF40: B5 50    //            LDA  50,X     Load accumulator with memory
EF42: D1 DA    //            CMP (DA),Y    Compare memory and accumulator
EF44: C8       //            INY           Increment index Y by one
EF45: B5 78    //            LDA  78,X     Load accumulator with memory
EF47: F1 DA    //            SBC (DA),Y    Subtrac memory from accumulator with borrow
EF49: B0 80    //            BCS  80       Branch on carry set
EF4B: 4C 23 E8 //            JMP  E823     Jump to new location

EF4E: 20 15 E7 //            JSR  E715     Jump to new location saving return address
EF51: A5 4E    //            LDA  4E       Load accumulator with memory
EF53: 20 08 E7 //            JSR  E708     Jump to new location saving return address
EF56: A5 4F    //            LDA  4F       Load accumulator with memory
EF58: D0 04    //            BNE  04       Branch on result not zero
EF5A: C5 4E    //            CMP  4E       Compare memory and accumulator
EF5C: 69 00    //            ADC #00       Add memory to accumulator with carry
EF5E: 29 7F    //            AND #7F       'AND' memory with accumulator
EF60: 85 4F    //            STA  4F       Store accumulator in memory
EF62: 95 A0    //            STA  A0,X     Store accumulator in memory
EF64: A0 11    //            LDY #11       Load index Y with memory
EF66: A5 4F    //            LDA  4F       Load accumulator with memory
EF68: 0A       //            ASL           Shift accumulator left one bit
EF69: 18       //            CLC           Clear carry flag
EF6A: 69 40    //            ADC #40       Add memory to accumulator with carry
EF6C: 0A       //            ASL           Shift accumulator left one bit
EF6D: 26 4E    //            ROL  4E       Rotate one bit left
EF6F: 26 4F    //            ROL  4F       Rotate one bit left
EF71: 88       //            DEY           Dekrement index Y by one
EF72: D0 F2    //            BNE  F2       Branch on result not zero
EF74: A5 CE    //            LDA  CE       Load accumulator with memory
EF76: 20 08 E7 //            JSR  E708     Jump to new location saving return address
EF79: A5 CF    //            LDA  CF       Load accumulator with memory
EF7B: 95 A0    //            STA  A0,X     Store accumulator in memory
EF7D: 4C 7A E2 //            JMP  E27A     Jump to new location

EF80: 20 15 E7 //            JSR  E715     Jump to new location saving return address
EF83: A4 CE    //            LDY  CE       Load index Y with memory
EF85: C4 4C    //            CPY  4C       Compare memory and index Y
EF87: A5 CF    //            LDA  CF       Load accumulator with memory
EF89: E5 4D    //            SBC  4D       Subtrac memory from accumulator with borrow
EF8B: 90 1F    //            BCC  1F       Branch on carry clear
EF8D: 84 48    //            STY  48       Store index Y in memory
EF8F: A5 CF    //            LDA  CF       Load accumulator with memory
EF91: 85 49    //            STA  49       Store accumulator in memory
EF93: 4C B6 EE //            JMP  EEB6     Jump to new location

EF96: 20 15 E7 //            JSR  E715     Jump to new location saving return address
EF99: A4 CE    //            LDY  CE       Load index Y with memory
EF9B: C4 CA    //            CPY  CA       Compare memory and index Y
EF9D: A5 CF    //            LDA  CF       Load accumulator with memory
EF9F: E5 CB    //            SBC  CB       Subtrac memory from accumulator with borrow
EFA1: B0 09    //            BCS  09       Branch on carry set
EFA3: 84 4A    //            STY  4A       Store index Y in memory
EFA5: A5 CF    //            LDA  CF       Load accumulator with memory
EFA7: 85 4B    //            STA  4B       Store accumulator in memory
EFA9: 4C B7 E5 //            JMP  E5B7     Jump to new location
EFAC: 4C CB EE //            JMP  EECB     Jump to new location

EFAF: EA EA EA EA //         NOP           No operation

EFB3: 20 C9 EF //            JSR  EFC9     Jump to new location saving return address
EFB6: 20 71 E1 //            JSR  E171     Jump to new location saving return address
EFB9: 4C BF EF //            JMP  EFBF     Jump to new location
EFBC: 20 03 EE //            JSR  EE03     Jump to new location saving return address
EFBF: A9 FF    //            LDA #FF       Load accumulator with memory
EFC1: 85 C8    //            STA  C8       Store accumulator in memory
EFC3: A9 74    //            LDA #74       Load accumulator with memory
EFC5: 8D 00 02 //            STA  0200     Store accumulator in memory
EFC8: 60       //            RTS           Return from subroutine

EFC9: 20 36 E7 //            JSR  E736     Jump to new location saving return address
EFCC: E8       //            INX           Increment index X by one
EFCD: 20 36 E7 //            JSR  E736     Jump to new location saving return address
EFD0: B5 50    //            LDA  50,X     Load accumulator with memory
EFD2: 60       //            RTS           Return from subroutine

// Init 4a/4b-pointer and 4c/4d-pointer
EFD3: A9 00    //            LDA #00       Load 0x0800 into 4a/4b-pointer
EFD5: 85 4A    //            STA  4A       Load 0x1000 into 4c/4d-pointer
EFD7: 85 4C    //            STA  4C
EFD9: A9 08    //            LDA #08
EFDB: 85 4B    //            STA  4B
EFDD: A9 10    //            LDA #10
EFDF: 85 4D    //            STA  4D
EFE1: 4C AD E5 //            JMP  E5AD     Jump to new location

EFE4: D5 78    //            CMP  78,X     Compare memory and accumulator
EFE6: D0 01    //            BNE  01       Branch on result not zero
EFE8: 18       //            CLC           Clear carry flag
EFE9: 4C 02 E1 //            JMP  E102     Jump to new location

EFEC: 20 B7 E5 //            JSR  E5B7     Jump to new location saving return address
EFEF: 4C 36 E8 //            JMP  E836     Jump to new location

EFF2: 20 B7 E5 //            JSR  E5B7     Jump to new location saving return address
EFF5: 4C 5B E8 //            JMP  E85B     Jump to new location

EFF8: E0 80    //            CPX #80       Compare memory and index X
EFFA: D0 01    //            BNE  01       Branch on result not zero
EFFC: 88       //            DEY           Dekrement index Y by one
EFFD: 4C 0C E0 //            JMP  E00C     Jump to new location
