; CS617 Chapter 08 r010 - full limon 0.9 integration CANDIDATE
; Alex Barragan and ChatGPT (Sol) - source-only, no Rev 0.45 build yet.
; Baseline: exact tested limon-09/limonv9ROM.s (SHA256 below in README).
; PROVENANCE: all Rxxxx, Mxxxx, Lxxxx, commands and firmware objects come
; from the frozen donor; only entry, ORG, MENU, BRSTR and E write gate adapted.
; WARNING: many C-ROM-derived absolute Rxxxx calls need runtime mapping test.
; ======================================================================
; PB-2000C standalone CLEAR MON -- LIMON v9
;
; Functional source baseline.
; Comments describe the current program and hardware-facing behavior.
; Piotr Piatek original functional comments are retained.
;
; Symbol convention:
;   Rxxxx = external callable/executable target
;   Mxxxx = external storage/data location
;   Lxxxx = location emitted inside this image
; ======================================================================

; External callable/executable dependencies.
R002B:  EQU     &H002B
R0049:  EQU     &H0049
R00E3:  EQU     &H00E3
R0197:  EQU     &H0197
R01C9:  EQU     &H01C9
R01AA:  EQU     &H01AA
R01BC:  EQU     &H01BC
R01CE:  EQU     &H01CE
R01D3:  EQU     &H01D3
R01E1:  EQU     &H01E1
R01EC:  EQU     &H01EC
R021D:  EQU     &H021D
R026C:  EQU     &H026C
R0270:  EQU     &H0270
R0279:  EQU     &H0279
R027B:  EQU     &H027B
R028A:  EQU     &H028A
R029D:  EQU     &H029D
R02A3:  EQU     &H02A3
R02D4:  EQU     &H02D4
R0304:  EQU     &H0304
R0306:  EQU     &H0306
R030C:  EQU     &H030C
R0312:  EQU     &H0312
R0319:  EQU     &H0319
R031C:  EQU     &H031C
R031F:  EQU     &H031F
R0327:  EQU     &H0327
R032D:  EQU     &H032D
R035A:  EQU     &H035A
R035E:  EQU     &H035E
R0368:  EQU     &H0368
R037D:  EQU     &H037D
R0388:  EQU     &H0388
R03A3:  EQU     &H03A3
R03E4:  EQU     &H03E4
R03F3:  EQU     &H03F3
R03FF:  EQU     &H03FF
R0411:  EQU     &H0411
R0426:  EQU     &H0426
R0435:  EQU     &H0435
R043D:  EQU     &H043D
R044F:  EQU     &H044F
R0460:  EQU     &H0460
R04EA:  EQU     &H04EA
R04EF:  EQU     &H04EF
R055A:  EQU     &H055A
R0571:  EQU     &H0571
R0578:  EQU     &H0578
R058B:  EQU     &H058B
R0634:  EQU     &H0634
R0661:  EQU     &H0661
R0665:  EQU     &H0665
R06CF:  EQU     &H06CF
R09E0:  EQU     &H09E0
R0B23:  EQU     &H0B23
R1CDA:  EQU     &H1CDA
R23B2:  EQU     &H23B2
R23B9:  EQU     &H23B9
R2AEE:  EQU     &H2AEE
R2AEF:  EQU     &H2AEF
R2AF0:  EQU     &H2AF0
R2B84:  EQU     &H2B84
R2C7C:  EQU     &H2C7C
R3312:  EQU     &H3312
R3ECF:  EQU     &H3ECF
R3EFB:  EQU     &H3EFB
R3EFF:  EQU     &H3EFF
R3F07:  EQU     &H3F07
R4DDA:  EQU     &H4DDA
R54E8:  EQU     &H54E8
R571D:  EQU     &H571D
R6E90:  EQU     &H6E90
RF552:  EQU     &HF552

; External storage/data dependencies.
M0000:  EQU     &H0000
M0080:  EQU     &H0080
M0100:  EQU     &H0100
M08A7:  EQU     &H08A7
M08CA:  EQU     &H08CA
M08CB:  EQU     &H08CB
M08CC:  EQU     &H08CC
M08CD:  EQU     &H08CD
M08CE:  EQU     &H08CE
M08CF:  EQU     &H08CF
M08D0:  EQU     &H08D0
M08D1:  EQU     &H08D1
M08D3:  EQU     &H08D3
M08D5:  EQU     &H08D5
M08D7:  EQU     &H08D7
M08D9:  EQU     &H08D9
M09E2:  EQU     &H09E2
M09E4:  EQU     &H09E4
M09E6:  EQU     &H09E6
M09EF:  EQU     &H09EF
M09F2:  EQU     &H09F2
M0A02:  EQU     &H0A02
M0A03:  EQU     &H0A03
M0A06:  EQU     &H0A06
M0A66:  EQU     &H0A66
M0A80:  EQU     &H0A80
M0A8A:  EQU     &H0A8A
M0A8C:  EQU     &H0A8C
M0A98:  EQU     &H0A98
M0A9A:  EQU     &H0A9A
M0AA0:  EQU     &H0AA0
M0AA2:  EQU     &H0AA2
M0AAA:  EQU     &H0AAA
M0AB0:  EQU     &H0AB0
M0AB6:  EQU     &H0AB6
M0AB8:  EQU     &H0AB8
M0ABC:  EQU     &H0ABC
M0ABD:  EQU     &H0ABD
M0C01:  EQU     &H0C01
M0ABE:  EQU     &H0ABE
M0AC0:  EQU     &H0AC0
M0AC9:  EQU     &H0AC9
M0BD1:  EQU     &H0BD1
M0BE1:  EQU     &H0BE1
M0C03:  EQU     &H0C03
M0C04:  EQU     &H0C04
M0C12:  EQU     &H0C12
M0CE2:  EQU     &H0CE2
M0CE6:  EQU     &H0CE6
M0CE7:  EQU     &H0CE7
M0CE9:  EQU     &H0CE9
M0CEB:  EQU     &H0CEB
M0CED:  EQU     &H0CED	; Dump bank context
M0CEE:  EQU     &H0CEE	; Edit bank context
M0CEF:  EQU     &H0CEF	; Raw UA probe context
M0CF0:  EQU     &H0CF0	; Raw UA probe address
M0CF2:  EQU     &H0CF2	; Raw UA probe end address
M0D0B:  EQU     &H0D0B
M1099:  EQU     &H1099
M1298:  EQU     &H1298
M129A:  EQU     &H129A
M129B:  EQU     &H129B
M1300:  EQU     &H1300
M1315:  EQU     &H1315
M1317:  EQU     &H1317
M1319:  EQU     &H1319
M1400:  EQU     &H1400
M1419:  EQU     &H1419
M141B:  EQU     &H141B
M141D:  EQU     &H141D
M1558:  EQU     &H1558
M1559:  EQU     &H1559
M155B:  EQU     &H155B
M155C:  EQU     &H155C
M155D:  EQU     &H155D
M155F:  EQU     &H155F
M1561:  EQU     &H1561
M1569:  EQU     &H1569
M156A:  EQU     &H156A
M156B:  EQU     &H156B
M156D:  EQU     &H156D
M159D:  EQU     &H159D
M159F:  EQU     &H159F
M16C9:  EQU     &H16C9
M1A00:  EQU     &H1A00
M8000:  EQU     &H8000

; Language-ROM header.
        DB      &H43,&H4D
        DB      &HFF,&HFF,&HFF,&HFF
        DB      &H01,&H04,&H10,&H10
        DB      &HFF,&HFF,&HFF,&HFF
        DB      &HFF,&HFF,&HFF,&HFF
        DB      &HFF,&HFF,&HFF,&HFF
        DB      &HFF,&HFF,&HFF,&HFF
        DB      &HFF
        DB      &H03
        DB      &HC0
        DB      &HFF,&HFF,&HFF

; CS617 r016: keep the original contrast/firmware table at ROM2:0D40h.
; It is now emitted by crttab.s, with L0D6A bound to native 0D6Ah.
; C-ROM-derived vector/code body remains at ROM2:8040h (unchanged r015
; addresses). 8000h..803Fh is deliberately empty: no duplicate table.
; These donor vectors are not the live Chapter 08 card vectors.
        ORG     &H8040

; C vector table / ROM identity.
        JP      C_RESET               ; reset/power-on
        JP      R2AEE                ; TRP
        JP      R01AA                ; ON interrupt
        JP      R01BC                ; one-minute timer
        JP      R2AEF                ; external interrupt 2
        JP      R2AEF                ; pulse/key interrupt
        JP      R6E90                ; external interrupt 1
        JP      R00E3
        RTN
        DB      &HFF,&HFF
        RTN
        DB      &HFF,&HFF
        JP      R1CDA                ; check user stack
        JP      R3312                ; power-off
        JP      L2E73                ; key decode
        JP      L4D6E
        JP      C_RESET              ; BRK handler - current standalone path
        JP      R3F07                ; BS Error
        JP      R3ECF                ; SN Error
        JP      R3EFF                ; MA Error
        JP      R3EFB                ; OV Error
L0DB9:
        DB      &HF4,&H10             ; CH08 provisional ID, donor D4 12 replaced

; ASCII font table: 96 glyphs, 6 bytes per glyph.
; One 6-byte DB per glyph.
L0DBB:
ASCII_FONT:
        DB      &H00,&H00,&H00,&H00,&H00,&H00      ; code $20 ' '
        DB      &H00,&H00,&HF2,&H00,&H00,&H00      ; code $21 '!'
        DB      &H00,&HE0,&H00,&HE0,&H00,&H00      ; code $22 '"'
        DB      &H28,&HFE,&H28,&HFE,&H28,&H00      ; code $23 '#'
        DB      &H24,&H54,&HFE,&H54,&H48,&H00      ; code $24 '$'
        DB      &HC4,&HC8,&H10,&H26,&H46,&H00      ; code $25 '%'
        DB      &H6C,&H92,&H6A,&H04,&H1A,&H00      ; code $26 '&'
        DB      &H00,&HA0,&HC0,&H00,&H00,&H00      ; code $27
        DB      &H00,&H38,&H44,&H82,&H00,&H00      ; code $28 '('
        DB      &H00,&H82,&H44,&H38,&H00,&H00      ; code $29 ')'
        DB      &H28,&H10,&H7C,&H10,&H28,&H00      ; code $2A '*'
        DB      &H10,&H10,&H7C,&H10,&H10,&H00      ; code $2B '+'
        DB      &H00,&H05,&H06,&H00,&H00,&H00      ; code $2C ','
        DB      &H10,&H10,&H10,&H10,&H10,&H00      ; code $2D '-'
        DB      &H00,&H06,&H06,&H00,&H00,&H00      ; code $2E '.'
        DB      &H04,&H08,&H10,&H20,&H40,&H00      ; code $2F '/'
        DB      &H7C,&H8A,&H92,&HA2,&H7C,&H00      ; code $30 '0'
        DB      &H00,&H42,&HFE,&H02,&H00,&H00      ; code $31 '1'
        DB      &H42,&H86,&H8A,&H92,&H62,&H00      ; code $32 '2'
        DB      &H84,&H82,&HA2,&HD2,&H8C,&H00      ; code $33 '3'
        DB      &H18,&H28,&H48,&HFE,&H08,&H00      ; code $34 '4'
        DB      &HE4,&HA2,&HA2,&HA2,&H9C,&H00      ; code $35 '5'
        DB      &H3C,&H52,&H92,&H92,&H0C,&H00      ; code $36 '6'
        DB      &H80,&H8E,&H90,&HA0,&HC0,&H00      ; code $37 '7'
        DB      &H6C,&H92,&H92,&H92,&H6C,&H00      ; code $38 '8'
        DB      &H60,&H92,&H92,&H94,&H78,&H00      ; code $39 '9'
        DB      &H00,&H6C,&H6C,&H00,&H00,&H00      ; code $3A ':'
        DB      &H00,&H6A,&H6C,&H00,&H00,&H00      ; code $3B ';'
        DB      &H10,&H28,&H44,&H82,&H00,&H00      ; code $3C '<'
        DB      &H28,&H28,&H28,&H28,&H28,&H00      ; code $3D '='
        DB      &H00,&H82,&H44,&H28,&H10,&H00      ; code $3E '>'
        DB      &H40,&H80,&H8A,&H90,&H60,&H00      ; code $3F '?'
        DB      &H4C,&H92,&H9E,&H82,&H7C,&H00      ; code $40 '@'
        DB      &H7E,&H90,&H90,&H90,&H7E,&H00      ; code $41 'A'
        DB      &HFE,&H92,&H92,&H92,&H6C,&H00      ; code $42 'B'
        DB      &H7C,&H82,&H82,&H82,&H44,&H00      ; code $43 'C'
        DB      &HFE,&H82,&H82,&H44,&H38,&H00      ; code $44 'D'
        DB      &HFE,&H92,&H92,&H92,&H82,&H00      ; code $45 'E'
        DB      &HFE,&H90,&H90,&H90,&H80,&H00      ; code $46 'F'
        DB      &H7C,&H82,&H92,&H92,&H5E,&H00      ; code $47 'G'
        DB      &HFE,&H10,&H10,&H10,&HFE,&H00      ; code $48 'H'
        DB      &H00,&H82,&HFE,&H82,&H00,&H00      ; code $49 'I'
        DB      &H04,&H02,&H82,&HFC,&H80,&H00      ; code $4A 'J'
        DB      &HFE,&H10,&H28,&H44,&H82,&H00      ; code $4B 'K'
        DB      &HFE,&H02,&H02,&H02,&H02,&H00      ; code $4C 'L'
        DB      &HFE,&H40,&H30,&H40,&HFE,&H00      ; code $4D 'M'
        DB      &HFE,&H20,&H10,&H08,&HFE,&H00      ; code $4E 'N'
        DB      &H7C,&H82,&H82,&H82,&H7C,&H00      ; code $4F 'O'
        DB      &HFE,&H90,&H90,&H90,&H60,&H00      ; code $50 'P'
        DB      &H7C,&H82,&H8A,&H84,&H7A,&H00      ; code $51 'Q'
        DB      &HFE,&H90,&H98,&H94,&H62,&H00      ; code $52 'R'
        DB      &H64,&H92,&H92,&H92,&H4C,&H00      ; code $53 'S'
        DB      &H80,&H80,&HFE,&H80,&H80,&H00      ; code $54 'T'
        DB      &HFC,&H02,&H02,&H02,&HFC,&H00      ; code $55 'U'
        DB      &HF8,&H04,&H02,&H04,&HF8,&H00      ; code $56 'V'
        DB      &HFC,&H02,&H1C,&H02,&HFC,&H00      ; code $57 'W'
        DB      &HC6,&H28,&H10,&H28,&HC6,&H00      ; code $58 'X'
        DB      &HE0,&H10,&H0E,&H10,&HE0,&H00      ; code $59 'Y'
        DB      &H86,&H8A,&H92,&HA2,&HC2,&H00      ; code $5A 'Z'
        DB      &H00,&HFE,&H82,&H82,&H00,&H00      ; code $5B '['
        DB      &HA8,&H68,&H3E,&H68,&HA8,&H00      ; code $5C
        DB      &H00,&H82,&H82,&HFE,&H00,&H00      ; code $5D ']'
        DB      &H20,&H40,&H80,&H40,&H20,&H00      ; code $5E '^'
        DB      &H02,&H02,&H02,&H02,&H02,&H00      ; code $5F '_'
        DB      &H00,&HC0,&HA0,&H00,&H00,&H00      ; code $60 '`'
        DB      &H04,&H2A,&H2A,&H2A,&H1C,&H02      ; code $61 'a'
        DB      &HFE,&H12,&H22,&H22,&H1C,&H00      ; code $62 'b'
        DB      &H1C,&H22,&H22,&H22,&H04,&H00      ; code $63 'c'
        DB      &H1C,&H22,&H22,&H12,&HFE,&H00      ; code $64 'd'
        DB      &H1C,&H2A,&H2A,&H2A,&H18,&H00      ; code $65 'e'
        DB      &H00,&H20,&H7E,&HA0,&H80,&H00      ; code $66 'f'
        DB      &H18,&H25,&H25,&H25,&H3E,&H00      ; code $67 'g'
        DB      &HFE,&H10,&H20,&H20,&H1E,&H00      ; code $68 'h'
        DB      &H00,&H22,&HBE,&H02,&H00,&H00      ; code $69 'i'
        DB      &H02,&H01,&H21,&HBE,&H00,&H00      ; code $6A 'j'
        DB      &H00,&HFE,&H08,&H14,&H22,&H00      ; code $6B 'k'
        DB      &H00,&H82,&HFE,&H02,&H00,&H00      ; code $6C 'l'
        DB      &H3E,&H20,&H1E,&H20,&H1E,&H00      ; code $6D 'm'
        DB      &H3E,&H10,&H20,&H20,&H1E,&H00      ; code $6E 'n'
        DB      &H1C,&H22,&H22,&H22,&H1C,&H00      ; code $6F 'o'
        DB      &H3F,&H24,&H24,&H24,&H18,&H00      ; code $70 'p'
        DB      &H18,&H24,&H24,&H24,&H3F,&H00      ; code $71 'q'
        DB      &H3E,&H10,&H20,&H20,&H10,&H00      ; code $72 'r'
        DB      &H12,&H2A,&H2A,&H2A,&H24,&H00      ; code $73 's'
        DB      &H20,&H7C,&H22,&H02,&H04,&H00      ; code $74 't'
        DB      &H3C,&H02,&H02,&H04,&H3E,&H00      ; code $75 'u'
        DB      &H30,&H0C,&H02,&H0C,&H30,&H00      ; code $76 'v'
        DB      &H3C,&H02,&H0C,&H02,&H3C,&H00      ; code $77 'w'
        DB      &H22,&H24,&H1C,&H12,&H22,&H00      ; code $78 'x'
        DB      &H21,&H11,&H0A,&H0C,&H30,&H00      ; code $79 'y'
        DB      &H22,&H26,&H2A,&H32,&H22,&H00      ; code $7A 'z'
        DB      &H10,&H6C,&H82,&H00,&H00,&H00      ; code $7B '{'
        DB      &H00,&H00,&HEE,&H00,&H00,&H00      ; code $7C '|'
        DB      &H00,&H00,&H82,&H6C,&H10,&H00      ; code $7D '}'
        DB      &H40,&H80,&H40,&H20,&H40,&H00      ; code $7E '~'
        DB      &H00,&H00,&H00,&H00,&H00,&H00      ; code $7F


L15A1:
        DB      &H54,&H54,&H54,&H54,&H54,&H00,&H22,&H22,&HFA,&H22,&H22,&H00
        DB      &H0A,&H4A,&H2A,&H1A,&H0A,&H00,&H0A,&H1A,&H2A,&H4A,&H0A,&H00
        DB      &H00,&H00,&H7F,&H80,&H40,&H00,&H04,&H02,&HFC,&H00,&H00,&H00
        DB      &H10,&H10,&H54,&H10,&H10,&H00,&H24,&H48,&H24,&H12,&H24,&H00
        DB      &HE0,&HA0,&HE0,&H00,&H00,&H00,&H00,&H00,&H18,&H18,&H00,&H00
        DB      &H00,&H00,&H10,&H10,&H00,&H00,&H08,&H04,&HFE,&H80,&H80,&H00
        DB      &H78,&H20,&H40,&H38,&H00,&H00,&HB8,&HA8,&HE8,&H00,&H00,&H00
        DB      &H00,&H38,&H38,&H38,&H00,&H00,&H00,&H00,&H00,&H00,&H00,&H00

L1601:

        db	&HFF, &HFF,	'Z',  'z',	&HFF, &HFF,	'A',  'a'
        db	'Q',  'q',	'W',  'w',	&H09, &H09,	&H27, &H27
        db	&HFF, &HFF,	&HFF, &HFF
        db	'X',  'x',	'C',  'c',	'S',  's',	'D',  'd'
        db	'E',  'e',	'R',  'r',	'(',  '(',	')',  ')'
        db	&HFF, &HFF,	&HFC, &HFC
        db	'V',  'v',	'B',  'b',	'F',  'f',	'G',  'g'
        db	'T',  't',	'Y',  'y',	'[',  '[',	']',  ']'
        db	&HFF, &HFF,	&HFD, &HFD
        db	'N',  'n',	'M',  'm',	'H',  'h',	'J',  'j'
        db	'U',  'u',	'I',  'i',	'|',  '|',	&H90, &H90
        db	&HFF, &HFF,	&HFE, &HFE
        db	',',  ',',	' ',  ' ',	'K',  'k',	'L',  'l'
        db	'O',  'o',	'P',  'p',	&H94, &H94,	&H93, &H93
        db	&HFF, &HFF,	&HFF, &HFF
        db	&H92, &H92,	&HFF, &HFF,	';',  ';',	':',  ':'
        db	'=',  '=',	&HFF, &HFF,	&H9B, &H9B,	&HFF, &HFF
        db	&HFF, &HFF,	&H95, &H95
        db	'0',  '0',	&HFF, &HFF,	'1',  '1',	'2',  '2'
        db	'4',  '4',	'5',  '5',	&HFF, &HFF,	&HFF, &HFF
        db	&H9A, &H9A,	&HFF, &HFF
        db	'.',  '.',	&H0D, &H0D,	'3',  '3',	'+',  '+'
        db	'6',  '6',	'-',  '-',	'7',  '7',	'9',  '9'
        db	'*',  '*',	'8',  '8'
        db	&HFF, &HFF,	&HFF, &HFF,	&H08, &H08,	'/',  '/'
        db	&H1C, &H1C,	&H9D, &H9D,	&H11, &H11,	&H9C, &H9C
        db	&HFF, &HFF,	&HFF, &HFF
        db	&HFF, &HFF,	&HFF, &HFF,	&HFF, &HFF,	&H0C, &H0C
        db	&H1D, &H1D,	&H1F, &H1F,	&H12, &H12,	&H1E, &H1E
        db	&HFF, &HFF,	&HFF, &HFF


; Sparse keyword-address table.
; C slot is at base + 4; M slot is at base + 24.
L_KEY_TABLE:
        DS      &H0004                  ; opaque table bytes +0..+3
L17BB:
        DW      L1801                   ; C slot, table base +4
        DS      &H0012                  ; opaque table bytes +6..+23
L17CF:
        DW      L1863                   ; M slot, table base +24

L1801:
        DB      'CLEA','R'+&H80,&H6A
        DB      &H00


L1863:
        DB      &H00,&H00,&H00,&H00,&HFF

L20CF:

        ldw	$15,M0CE6	; string address = WORK1
        rtn


L20D4:
        sbc     $16,$sx
        rtn     z

L2136:

C_PARSE:
        ld	$23,$sx
        sbw	$14,$14
        pre	ix,M0000	; INTOP buffer
L213F:
        ldi	$0,(iz+$sx)
        sbc	$0,&H20
        jr	nc,L2158
        pre	ix,M0000	; INTOP buffer
        ldd	$0,(ix+$sx)
        ld	$15,$sx
        sbc	$0,&H03
        rtn	nz


L2152:
        std     $14,(ix+$sx)
        ld      $15,$14
        rtn
L2158:

        sbc	$15,&H40
        jr	z,L2165
        sbc	$0,&H22		; quotation mark?
        jr	nz,L2176


L2162:
        xr      $15,&H80
L2165:

        sbc	$0,&H3D		; '='
        jr	nz,L2171


L216A:
        anc     $15,&HC0
        jr      nz,L2171
        ld      $23,$sy
L2171:

        cal	L224B		; store the byte $0 in the output buffer
        jr	L213F
L2176:
        anc	$15,&H80
        jr	nz,L2165
        sbc	$0,&H3A		; ':'
        jr	nz,L2185


L2180:
        ld      $0,$sy

L2182:

        ld	$15,$sx,jr L2165
L2185:
        sbc	$0,&H27		; apostrophe, starts a comment
        jr	nz,L2191


L218A:
        ld      $0,&H02
        ld      $15,&H40,jr L2165
L2191:

        sbc	$0,&H26		; '&', starts a hex numeral
        jr	nz,L2199


L2196:
        ld      $15,$sy,jr L2165
L2199:

        cal	R01EC		; TCAPS, lower to upper case conversion
        sbc	$15,$sy
        jr	nz,L21A7


L21A0:
        diu     $15
        sbc     $0,&H48
        jr      z,L2165
L21A7:

        cal	R01E1		; OKAM1, is $0 a letter?
        jr	nc,L21CA	; branch if not
        sbc	$15,&H20
        jr	z,L21CF
        sbc	$15,&H10
        jr	nz,L21BB


L21B6:
        sbc     $0,&H47
        jr      c,L2165
L21BB:

        ldd	$1,(iz-$sy)
        cal	L220E		; parse for a keyword
        jr	nc,L21CF	; branch when not any keyword found
        ld	$15,$sx,jr L21DC
L21C5:
        cal	L2252		; store the word $16,$17 in the output buffer
        jr	L220B
L21CA:
        cal	R01CE
        jr	nc,L21D5
L21CF:
        ld	$0,(iz-$sy)
        ld	$15,&H20,jr L2165
L21D5:
        cal	R002B		; OKNM1, is $0 a digit?
        jr	nc,L2182


L21DA:
        jr      L2165

L21DC:

        ldw	$0,&H9B05	; keyword HYP
        sbcw	$16,$sz
        jr	nz,L21C5


L21E4:
        DB      &H77,&H52

L220B:

        jp	L213F

L220E:
        gre	ix,$2
        sb	$0,&H41		; 'A'
        biu	$0
        gst	ua,$1
        phs	$1
        an	$1,&HCF
        pst	ua,$1
        pre	ix,L_KEY_TABLE
        ldw	$0,(ix+$sz)
        pre	ix,$0		; pointer to the table of keywords
        ld	$16,&H04	; initial keyword prefix value
L2229:
        cal	R0665
        jr	c,L2237
        ad	$16,$sy
        sbc	$16,&H08
        jr	nz,L2229
        ldi	$0,(iz+$sx)	; updated next parsed character
L2237:
        pre	ix,$2
        pps	$1
        pst	ua,$1
        rtn

L223E:
        ldd     $0,(iz+$sx)
L2240:
        sbc     $0,&H20
        rtn     nz
        cal     L224B
        ldd     $0,(iz+$sy)
        jr      L2240

L224B:

        ad	$14,$sy		; counter of stored bytes
        jr	c,L2257	; BV Error, buffer overflow
        sti	$0,(ix+$sx)
        rtn
L2252:
        ad	$14,&H02	; counter of stored bytes
        jr	nc,L225A


L2257:
        DB      &H37,&HDB

L225A:

        stiw	$16,(ix+$sx)
        rtn


L225D:
        ld      $16,&H03


L22C2:

        pre	ix,M08D5	; ELVAD, pointer to the contrast data
        ldw	$3,L0D6A
        stw	$3,(ix+$sx)
        rtn


L22CD:
        cal     R02A3
        anc     $1,&H02
        rtn
L22D4:
        ld      $0,&H20,jr L22E6
L22D8:
        ld      $0,&H08,jr L22E6
L22DC:
        ld      $0,&H04,jr L22E6

L22E0:

        ld	$0,&H02,jr L22E6	; cursor display enable
L22E4:
        ld	$0,$sy
L22E6:
        cal	R02A3		; $1 <- (LCDST)
        or	$1,$sz
L22EB:
        std	$1,(ix+$sx)
        rtn


L22EE:
        ld      $0,&HDF,jr L2301

L22F2:

        ld	$0,&HF7,jr L2301 ; ignore the cursor movement range setting

L22F6:
        ld      $0,&HFB,jr L2301

L22FA:

        ld	$0,&HFD,jr L2301	; cursor display disable
L22FE:
        ld	$0,&HFE
L2301:
        cal	R02A3		; $1 <- (LCDST)
        an	$1,$sz,jr L22EB
L2307:
        cal	R02D4
        cal	L26DA
        jp	R0306

L2310:
        cal	R0319		; $2,$3 <- SCTOP address in the LEDTP buffer
        ldw	$0,M08D3	; DSPMD
        ld	$0,($sz)
        an	$0,$sy
        ld	$1,&H03
        sb	$1,$sz
        ld	$4,$sx		; first row
        pre	ix,$2		; IX = source address
L2324:
        cal	R032D		; copy 192 data bytes to the LCD row $4
        ad	$4,$sy		; next row
        sbc	$1,$4		; last row reached?
        jr	nc,L2324
        jp	R0304		; LCD on


L2331:
        pre     ix,M08A7
        gst     ua,$11
        gre     ix,$12
        ldw     $2,&H0807
        ld      $10,&H20
L2340:
        ld      $16,($12)
        adw     $12,$sy
        cal     L236A
        ldm     $4,(ix+$sx),6
        pst     ua,$0
        pre     ix,$2
        stim    $4,(ix+$sx),6
        gre     ix,$2
        sb      $10,$sy
        jr      nz,L2340
        pst     ua,$11
        pre     ix,&H0807
        ld      $4,&H03
        jp      R032D
L2364:
        cal     L236A
        jp      R0312

L236A:
        gst	ua,$0
        phs	$0
        ld	$0,$16
        ld	$1,$sx
        sb	$0,&H20
        jr	nc,L237A


L2378:
        ld      $0,$sx


L237A:

        sbc	$0,&HD0
        jr	nc,L23AA
L237F:
        gpo	$5
        gpo	$6
        sbc	$5,$6
        jr	nz,L237F
        anc	$5,$sy
        jr	nz,L2396	; branch for Japanese version
        sbc	$0,&H3C
        jr	nz,L_EXP_SKIP_R23B2                                ; EXP: invert short condition
        jp	R23B2                                               ; EXP: long fixed-coordinate transfer
L_EXP_SKIP_R23B2:
        sbc	$0,&H60
        jr	c,L_EXP_SKIP_R23B9                                 ; EXP: inverse of NC
        jp	R23B9                                               ; EXP: long fixed-coordinate transfer
L_EXP_SKIP_R23B9:
L2396:
        ldw	$5,L0DBB
        pst	ua,&H04
        biuw	$0
        adw	$5,$sz
        biuw	$0
        adw	$5,$sz
        pre	ix,$5
        pps	$0
        rtn


L23AA:
        DB      &HD1,&H05,&H06


L23C1:

        pre	ix,M08CB
        ld	$0,(ix-$sy)		; LCDST
        anc	$0,&H08			; bit "cursor movement range setting"
        rtn


L23CB:
        cal	R031C		; $2,$3 <- EDCSR address in the LEDTP buffer
        cal	R0388		; display a character, $2,$3=pointer to bitmap
        pre	ix,M08CB
        rtn


L23D6:
        ldw	$0,M0100	; address
        ldw	$2,&H0701	; number of bytes
        cal	R027B		; CLRME, clear memory block
        pre	ix,M08CB
        std	$31,(ix+$sx)
        st	$31,(ix+$sy)
        st	$31,(ix+&H04)
        jp	L2521
L23EF:
        pre	ix,M08CB
        ld	$0,(ix-$sy)	; LCDST
        anc	$0,&H06
        rtn	z
        ld	$2,$sx
        ld	$3,(ix+&H09)	; TOEDB
L23FE:
        ldw	$0,(ix+$sx)	; $0=EDCSR, $1=SCTOP
        sb	$0,$1
        jr	c,L2410	; branch if EDCSR<SCTOP
        sbc	$0,$3
        jr	c,L2416	; branch if EDCSR<TOEDB
        cal	L241D		; increment SCTOP by 32
        ld	$2,$sy,jr L23FE


L2410:
        cal     L2419
        ld      $2,$sy,jr L23FE

L2416:

        sbc	$2,$sx		; test for 0
        rtn


L2419:
        ld      $1,&HE0,jr L2420

L241D:

        ld	$1,&H20
L2420:
        ad	(ix+$sy),$1	; SCTOP
        rtn
L2423:
        pre	ix,M08CB
        ldd	$0,(ix+$sx)	; EDCSR
        ldd	$10,(ix-$sy)	; LCDST
        pre	ix,M0100	; EDTOP
        std	$16,(ix+$sz)
        cal	R031C		; $2,$3 <- EDCSR address in the LEDTP buffer
        cal	L2364		; creates a dot pattern for the character $16
        anc	$10,&H20
        rtn	z

; Initialise user-defined characters.
; Immediate NEW ALL dependency.

L243B:
        invm    $4,6
        stm     $4,(ix+$sx),6
        rtn

L2442:

N2442:
        GPO     $0
        GPO     $1
        SBC     $1,$SZ
        JR      NZ,N2442
        LDW     $2,M129B
        ANC     $0,$SY
        JR      NZ,N2456
        LDW     $2,L15A1
N2456:
        LDW     $0,M0A06
        LDW     $4,&H0060
        JP      R026C


L2461:
        DB      &H01
        DW      L2753                ; guard: roll up not yet closed
        DB      &H02
        DW      L2753                ; guard: line top not yet closed
        DB      &H05
        DW      L2753                ; guard: line delete not yet closed
        DB      &H06
        DW      L2753                ; guard: line end not yet closed
        DB      &H07
        DW      L2753                ; guard: beep path not yet closed
        DB      &H08
        DW      L26DF                ; backspace: closed
        DB      &H09
        DW      L2753                ; guard: tab not yet closed
        DB      &H0B
        DW      L2753                ; guard: home not yet closed
        DB      &H0C
        DW      L26D5
        DB      &H0D
        DW      L269A                ; CR/LF: closed
        DB      &H10
        DW      L2753                ; guard: roll down not yet closed
        DB      &H11
        DW      L26FD
        DB      &H12
        DW      L2715
        DB      &H18
        DW      L2659
        DB      &H1C
        DW      L263F                ; right: closed
        DB      &H1D
        DW      L2649                ; left: closed
        DB      &H1E
        DW      L2753                ; guard: up not yet closed
        DB      &H1F
        DW      L263A                ; down: closed
        DB      &H00


L2498:
        DW      L2753

L249A:

        cal	L2521
        pre	ix,L2461
        sbc	$16,&H20
        jp	c,R028A	; execute a procedure from the table
        sbc	$16,&H7F
        rtn	z
        cal	L2423		; put character $16 to buffers EDTOP and LEDTP
        cal	L23CB		; display a character from the LEDTP buffer
        ldm	$0,(ix-$sy),8
        sbc	$1,$4
        jr	c,L24DD


L24B9:
        cal     L3230
        sbc     $1,$sy
        jr      nz,L24C5
        anc     $0,&H08
        jr      nz,L24F0
L24C5:
        sbc     $4,$7
        jr      nz,L24DD
        sbc     $3,$6
        jr      nz,L24D4
        anc     $0,&H09
        jr      nz,L24DD
L24D4:
        cal     L27D1
        cal     L24E3
        jp      L26F4
L24DD:
        cal     L24E3
        jp      L2650
L24E3:
        pre     ix,M08CB
        ld      $0,(ix+&H06)
        sbc     (ix+$sx),$0
        rtn     nc
        ad      (ix+$sx),$30
        rtn


L24F0:
        adc     $7,$sy
        jr      c,L2500
        pre     ix,M08CB
        ad      (ix+$sx),$30
        ad      (ix+&H06),$30
L24FD:
        jp      L2650
L2500:
        an      $6,&HE0
        jr      z,L24FD
        cal     L2832
        pre     ix,M08CB
        ldm     $0,(ix+$sx),7
        sb      $0,&H1F
        sb      $1,&H20
        sb      $5,&H20
        sb      $6,&H1F
        stm     $0,(ix+$sx),7
        jp      L26F4

L2521:

        cal	L3230		; $1 <- (MODE)
        sbc	$1,$sy
        jp	nz,R03A3


L2529:
        cal     L23C1                 ; test cursor movement range setting
        jp      z,R03A3               ; ignored when range setting is clear
        pre     ix,M08D0
        ldd     $0,(ix+$sx)
        st      $0,(ix-$sy)
        st      $0,(ix-&H03)
        ld      $0,(ix-&H05)
        pre     ix,M0100
L2541:
        sbc     (ix+$sz),$31
        jr      z,L254B
        ad      $0,$sy
        jr      nc,L2541
        sb      $0,$sy
L254B:
        pre     ix,M08CE
        std     $0,(ix+$sx)
        st      $0,(ix+&H03)
        rtn

L2555:
        pre     ix,M08CB
        ldim    $0,(ix+$sx),7
        sbc     $6,$sz
        jp      z,L2753
        adc     $6,$sy
        jr      nc,L2578
        an      $5,&HE0
        jp      z,L2739
        ld      $0,&H20
        sb      (ix-&H02),$0
        sb      (ix-$sy),$0
        cal     L27D1
        jr      L258D
L2578:
        an      $6,&H1F
        sbc     $6,&H1F
        jr      nz,L2588
        cal     L2840
        cal     L2521
        jr      L258D
L2588:
        ad      (ix-&H04),$30
        ad      (ix-$sy),$30
L258D:
        jp      L2744


L25E7:

        ld      $0,&H20,jr L25ED
L25EB:
        ld      $0,$sy
L25ED:
        pre     ix,M08CB
        ldd     $1,(ix+$sx)        ; EDCSR, cursor position
        ad      $1,$sz
        rtn     c                  ; out of range, command failed
        sbc     (ix+&H06),$1       ; BOARE, cursor movement range bottom
        rtn     c
        jr      L2615

L25FC:
        ld      $0,&H10,jr L2606
L2600:
        ld      $0,&H20,jr L2606
L2604:
        ld      $0,$sy
L2606:
        pre     ix,M08CB
        ldd     $1,(ix+$sx)        ; EDCSR, cursor position ldd $1,(ix+$sx) ; EDCSR, cursor position
        sb      $1,$sz
        rtn     c                  ; out of range, command failed
        ld      $0,(ix+&H05)       ; TOARE, cursor movement range top
        sbc     $1,$sz
        rtn     c
L2615:
        ld      $0,(ix+&H08)       ; DSPMD, display mode
        anc     $0,&H02
        jr      nz,L2629
        phsw    $2
        cal     L23CB             ; display a character from LEDTP buffer
        ppsw    $1
        std     $1,(ix+$sx)
L2626:
        sbc     $30,$sx
        rtn

L2629:
        DB      &H26,&H01,&H2C

L263A:

        cal     L25E7             ; down: increment cursor by 32
        jr      L264C
L263F:
        cal     L25EB             ; right: increment cursor by 1
        jr      L264C

L2644:
        cal     L2600
        jr      L264C

L2649:

        cal     L2604             ; left: decrement cursor by 1
L264C:
        rtn     c
        cal     R044F             ; conditionally set key repeat flag

L2650:

        cal	L23EF		; modify SCTOP when necessary
        jp	z,L2521

; Cursor fall-through helper.
L2656:
        jp      L26F7


; CLS dependency helper.
L2659:

        pre     ix,M08CD
        ld      $0,(ix+&H02)
        ld      $1,(ix+$sy)
        ad      $1,$sy
        sb      $1,$sz
        jr      z,L26DA
        cal     L2857
        pre     ix,M08CB
        ld      $0,(ix+&H04)

L2672:

        std	$0,(ix+$sx)
        jr	L26F4


L2676:
        pre     ix,M08CD
        ld      $0,(ix-&H02)
        ld      $1,(ix+$sy)
        ad      $1,$sy
        sb      $1,$sz
        jr      z,L26DA
        cal     L2857
        jr      L26F4
L268A:
        ldw     $0,M08CF
        ld      $0,($sz),jr L2694
L2691:
        cal     R03E4

L2694:

        pre	ix,M08CB
        jr	L2672
L269A:
        cal	L23C1		; test the bit "cursor movement range setting"
        jp	nz,L2753	; return if respected
        pre	ix,M08CB
        ldd	$0,(ix+$sx)
        an	$0,&HE0
        ad	$0,&H20
        jr	nc,L2694
L26AE:
        cal	R03E4		; $0 <- end of the string in the logical line
        an	$0,&HE0
        ad	$0,&H20
        jr	nc,L2694
        cal	L27D1
        jr	L26AE

L26BE:
        DB      &H77,&HC1

; CLS dependency helper.
L26CB:

        cal     L3230             ; $1 <- (MODE)
        sbc     $1,$sy
        jp      nz,L2753
        jr      L2659

L26D5:

        cal	L23C1		; test the bit "cursor movement range setting"
        jr	nz,L26CB	; jump if respected
L26DA:
        cal	L23D6		; CLEDB, clear screen
        jr	L26F4

L26DF:

        pre	ix,M08CC
        ld	$0,(ix-$sy)
        sbc	(ix+$sy),$0
        jr	z,L2753


L26E9:
        sb      (ix-$sy),$30

L26EB:

        cal     R03FF             ; process logical line: EDCNT, fill gaps
        cal     L27FD
L26F1:
        cal     R044F             ; conditionally set key repeat flag

L26F4:

        cal	L23EF		; modify SCTOP when necessary
L26F7:
        cal	L2310		; DOTDS, copy the RAM to the LCD driver
        jp	L2521

L26FD:

; control code $11: DEL
        cal     R03E4
        sbc     (ix-&H03),$0
        jr      c,L26EB
        cal     R0327
        jr      z,L2753
        ld      $1,$sy
        pre     ix,M08CD
        cal     L2857
        jr      L26F1

; control code $12: INS
L2715:
        cal     L3230
        sbc     $1,$sy
        jr      nz,L2722
        cal     L23C1
        jp      nz,L2555
L2722:
        cal     R03FF
        cal     R03E4
        sbc     (ix-&H03),$0
        jr      nc,L2753
        ldd     $1,(ix+$sx)
        sbc     $0,$1
        jr      c,L2744
        cal     L27A8
        jr      nc,L2744
L2739:
        pre     ix,M08D1
        ldd     $0,(ix+$sx)
        cal     R0327
        jr      nz,L2753
L2744:
        cal     L27F2
        phs     $16
        ld      $16,&H20
        cal     L2423
        pps     $16
        jr      L26F1

L2753:

        sbc	$31,$sy
        rtn


L2756:
        cal     L23C1
        jr      nz,L2753
        ld      $2,(ix+$sy)
        sbc     $2,$sx
        jr      z,L2753
        anc     $0,&H06
        jr      z,L2776
        cal     L2600
        ld      $0,(ix+&H09)
        sb      $0,&H20
        ld      $2,(ix+$sy)
        ad      $2,$sz
        sbc     (ix+$sx),$2
        rtn     nc
L2776:
        cal     L2419
L2779:
        jp      L26F1
L277C:
        cal     L23C1
        jr      nz,L2753
        ld      $2,(ix+$sy)
        ld      $3,(ix+&H09)
        sbc     $3,&H60
        jr      nz,L278E
        ld      $3,&HA0
L278E:
        sbc     $2,$3
        jr      nc,L2753
        anc     $0,&H06
        jr      z,L27A3
        cal     L25E7
        ad      $2,&H20
        sbc     (ix+$sx),$2
        jp      c,L2626
L27A3:
        cal     L241D
        jr      L2779

L27A8:

        pre     ix,M08CA
        ldm     $0,(ix+$sx),8
        sbc     $4,$7
        jr      z,L27C7
        ad      $4,&H20
        ld      $0,$4
        cal     R03F3
        sb      $4,&H20
        sbc     $4,$sz
        cal     c,L2840
        jr      L27EF
L27C7:
        anc     $0,&H08
        jr      nz,L2753
        sbc     $3,$6
        jr      z,L2753

L27D1:

        cal	L2832
        pre	ix,M08CB
        ld	$1,&H20
        sb	(ix+$sx),$1
        jr	nc,L27E1


L27DF:
        ad      (ix+$sx),$1

L27E1:

        sb	(ix+$sy),$1
        jr	nc,L27E7


L27E5:
        ad      (ix+$sy),$1

L27E7:

        sb	(ix+&H04),$1
        jr	nc,L27EF


L27EC:
        ad      (ix+&H04),$1

L27EF:

        jp	L2521


; INS dependency helper.
L27F2:

        pre     ix,M08CB
        ldi     $0,(ix+$sx)
        ld      $2,$sy
        ad      $2,$sz,jr L2808

L27FD:

        pre     ix,M08CB
        ldi     $2,(ix+$sx)
        ld      $0,$sy
        ad      $0,$2
L2808:
        std     $0,(ix+$sy)
        ld      $1,(ix+$sy)
        st      $2,(ix+$sy)
        ld      $0,(ix-&H02)
        sb      $1,$sz

L2813:

        st	$1,(ix+&H05)	; EDCNT
        cal	L286B		; destination address $2,$3 <- EDTOP+BOEDB
        pre	iy,$2
        ld	$0,(ix-$sy)	; character position <- TOEDB
        cal	R0327		; source address $2,$3 <- EDTOP+$0
        cal	L282D		; SHFTM, move memory block
        cal	L287A		; destination address $2,$3 = LEDTP+6*BOEDB
        pre	iy,$2
        ld	$0,(ix-$sy)	; character position <- TOEDB
        cal	R031F		; source address $2,$3 <- LEDTP+6*$0
L282D:
        gre	iy,$0
        jp	R0279		; SHFTM, move memory block
L2832:
        pre	ix,M08CD
        ldw	$0,&H0020
        stw	$0,(ix+$sx)
        ld	$1,&HE0,jr L2813 ; move an area of the buffers EDTOP and LEDTP

; INS dependency helper.
L2840:

        pre     ix,M08CD
        ld      $0,(ix+$sy)
        ad      $0,$sy
        ld      $1,$sz
        ad      $1,&H20
        jr      c,L2854
        stw     $0,(ix+$sx)
        cmp     $1,jr L2813
L2854:
        ld      $1,&H20

; CLS dependency helper.
L2857:

        st      $1,(ix+&H05)       ; EDCNT
        st      $0,(ix+$sy)        ; BOEDB
        cal     L286B
        cal     L2865
        cal     L287A
L2865:
        ldm     $0,$2,4
        jp      R027B             ; CLRME

L286B:

        ld	$0,(ix+$sy)	; BOEDB
        cal	R0327		; $2,$3 <- EDTOP+$0
        pre	ix,M08CE
        ld	$4,(ix+&H04)	; EDCNT
        ld	$5,$sx
        rtn
L287A:
        ldw	$4,M08CE
        ld	$0,($4)		; character position = BOEDB
        cal	R031F		; $2,$3 <- address in the LEDTP buffer
        pre	ix,$4
        ld	$0,(ix+&H04)	; EDCNT
        ld	$1,$sx
        biuw	$0		; *2
        ldw	$4,$sz
        biuw	$0		; *4
        adw	$4,$sz		; *(4+2)
        rtn
L2894:
        sbc	(ix+$sz),$1
        jr	z,L28A5
        jr	c,L28A5


L289A:
        ldi     $1,(ix+$sz)
        gre     ix,$0
        cal     L23C1
        rtn     nz
        st      $31,($sz)
        rtn

L28A5:

        st	$31,(ix+$sz)
        sbc	$3,$sz
        rtn	z		; beginning of the string was reached
        sb	$0,$sy
        sbc	(ix+$sz),$1
        jr	z,L28A5
        rtn			; no more trailing spaces
L28B1:
        cal	R03FF		; process the logical line: EDCNT, fill the gaps
        cal	L2894		; append zero to the string in the logical line
        ldw	$0,M0000	; start address
        ldw	$2,&H0100	; number of bytes
        jp	R027B		; CLRME, clear memory block
L28C2:
        cal	L28B1
        pre	iz,M08CF	; MOEDB, logical line top at the time of INPUT
        ldd	$0,(iz+$sx)
        pre	iz,M0100	; EDTOP buffer
        ldd	$1,(iz+$sz)	; IZ <- EDTOP + (MOEDB)
        rtn
L28D2:
        ldw	$0,&H6001
        jr	L28DC
L28D8:
        ldw	$0,&H8000
L28DC:
        pre	ix,M08D3	; DSPMD, SCROL
        stw	$0,(ix+$sx)
        rtn

; Cold-recovery object.

L28E3:
        ld      $0,$10
        cal     R031F
        phsm    $14,4
        sb      $11,$10
        gst     ua,$12
        gre     iz,$13
        pst     ua,&H54
        pre     iz,M0100
        ldd     $16,(iz+$10)
L28FD:
        ldi     $16,(iz+$sx)
        cal     L236A
        ldm     $4,(ix+$sx),6
        pst     ua,$0
        pre     ix,$2
        stim    $4,(ix+$sx),6
        gre     ix,$2
        sb      $11,$sy
        jr      nc,L28FD
        pre     iz,$13
        pst     ua,$12
        ppsm    $11,4
        rtn

L291A:

        gst	ua,$14
        pst	ua,&H44
        ld	$17,($15)	; length
        adw	$15,$sy
; the string is copied to RAM then displayed
        ld	$4,$17		; number of bytes
        ld	$5,$sx
        ldw	$2,$15		; source pointer
        ldw	$0,M0CE6	; destination pointer = WORK1
        cal	R021D		; block transfer
        pst	ua,$14
        pre	ix,M0CE6	; WORK1
        jr	L293D

; display a string of length $17 pointed to by $15,$16
        pre	ix,$15
L293D:
        sb	$17,$sy
        rtn	c
        ldi	$16,(ix+$sx)
        gre	ix,$14
        cal	L3B50		; display the character $16
        pre	ix,$14,jr L293D

L294A:
        db	&H1B, &H0C, &H0D, "       ROM card changed!", &H0D
L2966:
        db	&H20, &H0D, "Memory initialize OK? (EXE key)"
L2987:
        db	&H1A, &H0C, &H0D, "         Out of memory!", &H0D
L29A2:
        db	&H1B, &H0D, "      Press NEWALL button!"

        ldw	$2,L29DB
        cal	L3280		; BRSTR, set ACJMP
        cal	L28D8		; Normal display, 4-line scroll
        ldw	$15,L294A	; string "ROM card changed!"
        ldw	$18,L2966	; string "Memory initialize OK?"
        ld	$20,$sx
L29D2:
        cal	L291A		; display a string prefixed with a length byte
        ldw	$15,$18
        cal	L291A		; display a string prefixed with a length byte
L29DB:
        pre	ss,M0100
        pre	us,M0080
        cal	L22FA		; cursor display disable
        cal	R0460		; CRTKY
        sbc	$0,&H9A		; key new all?
        jp	z,L2FE8
        sbc	$0,&H0D		; key EXE?
        jr	nz,L29DB
        sbc	$20,$sx
        jr	nz,L29DB
        pre	ix,M0AB6
        ldw	$0,(ix+$sx)
        pre	ix,M0AAA
        ldw	$2,(ix+$sx)
        sbw	$2,$sz
        jr	c,L2A34
        ldw	$0,M1400
        sbcw	$2,$sz
        jr	c,L2A34
        cal	L3B3A		; display code &H0C - clear screen
        pre	ix,M0AB0
        ldm	$17,(ix+$sx),6
        ldw	$19,&H0020
L2A1E:
        sbcw	$17,$21
        jr	nc,L2A3F
        pre	iz,$17
        gre	iz,$6
        ld	$0,(iz+&H05)
        sbc	$0,&H24
        cal	nz,R571D	; KILL, delete file
        adw	$17,$19,jr L2A1E
L2A34:
        ldw	$15,L2987	; string "Out of memory!"
        ldw	$18,L29A2	; string "Press NEWALL button!"
        ld	$20,$sy,jr L29D2
L2A3F:
        pre	ix,M0AAA
        ldw	$0,(ix+$sx)
        ld	$2,&H06
L2A48:
        stdw	$1,(ix-$sy)
        sb	$2,$sy
        jr	nz,L2A48
        sb	$1,&H04
        ld	$2,&H05
L2A54:
        stdw	$1,(ix-$sy)
        sb	$2,$sy
        jr	nz,L2A54
        pre	ix,M0A80
        ldw	$2,M0AB6
        ldw	$2,($2)
        stiw	$2,(ix+$sx)
        stiw	$2,(ix+$sx)
        sbw	$0,$2
        bidw	$1
        bidw	$1
        adw	$2,$sz
        stiw	$2,(ix+$sx)
        stiw	$2,(ix+$sx)
        stiw	$2,(ix+$sx)
        stiw	$2,(ix+$sx)
        adw	$2,$sz
        stiw	$2,(ix+$sx)
        stiw	$2,(ix+$sx)
        stiw	$2,(ix+$sx)
        stiw	$2,(ix+$sx)
        cal	L2442		; initialise the user defined characters
        pst	ua,&H14
        jp	L304D

; reset or power switch on

L2A8D:

C_RESET:
        pre	ss,M0100
        pre	us,M0080
        pst	ua,&H14
        cal	R04EF
        sbc	$16,$sx
        jr	nz,L2AAB
        pre	ix,M08D9
        ld	$0,&H07
        st	$0,(ix+$sy)
        cal	L22C2		; set the initial contrast data pointer ELVAD
L2AAB:
        phs	$16
        cal	L3169
        pps	$16
        pre	ix,M0A66
        ldw	$0,(ix+$sx)
        an	$1,&HF0
        pre	iz,L0DB9
        ldw	$2,(iz+$sx)
        an	$3,&HF0
        sbcw	$2,$sz
        pst	ua,&H54

        jp	L2FE8                                              ; PATCH


        pre	ss,M1298
        pre	us,M1099
        sbc	$16,$sx
        jr	z,L2B00


L2AD8:
        DB      &H77,&H8F


L2AF9:

        pre	ss,M1298
        cal	L3208
L2B00:
        cal	R02A3		; $1 <- (LCDST)
        an	$1,&H20
        or	$1,&H06
        std	$1,(ix+$sx)
        cal	L2B39
L2B0E:
        pst	ua,&H54
        ldw	$2,R2AF0	; jump address
        cal	L3280		; BRSTR, set ACJMP
        cal	L32B2
L2B1B:
        cal	L2C53
        cal	L3298		; test the ANSFG variable
        jr	nz,L2B28
        cal	L2F88


L2B26:
        jr      L2B0E
L2B28:
        std     $31,(ix+$sx)
        cal     L3B47
        jr      L2B0E
L2B2F:
        pre     ss,M1298
        pre     us,M1099
        jr      L2B1B

L2B39:

        cal	L323B
        jr	z,L_EXP_SKIP_R2B84                                  ; EXP: invert short condition
        jp	R2B84
L_EXP_SKIP_R2B84:
        sbc	$1,$sx
        jr	nz,L2B56
        pre	ix,M08D3
        sbc	(ix+$sx),$31
        jr	z,L2B56
        pre	ix,M0AC9
        ldm	$0,(ix+$sx),8
        orcm	$0,$sz,8
        jr	nz,L2B68
L2B56:
        cal	L28D8		; Normal display, 4-line scroll
        pre	ix,M08CB
        ld	$1,(ix+$sy)	; SCTOP
        sbc	$1,&HA0
        cal	nc,L2419	; decrement SCTOP by 32
        jp	L2310		; DOTDS, copy the RAM to the LCD driver


L2B68:
        DB      &H77


L2C53:

CALC_IN:
        cal	L2E0C		; wait for a key, handle the function keys
        cal	L3230		; $1 <- (MODE)
        anc	$1,&H40
        jp	nz,R54E8	; jump if MENU mode
        anc	$1,&H04
        jp	nz,R4DDA	; jump if MEMO mode
        sbc	$0,&HF0
        jr	c,L_EXP_SKIP_R2C7C                                   ; EXP: inverse of NC
        jp	R2C7C
L_EXP_SKIP_R2C7C:
        sbc	$0,$sy
        jr	c,L2C77
        sbc	$0,&H0D
        rtn	z
        cal	L2CC9		; display the character $0 optionally preceded
        jr	L2C53


L2C77:
        DB      &H77,&HFE


L2CC9:

        ld	$16,$sz		; key code
        cal	L3298		; test the ANSFG variable
        jr	z,L2CF8


L2CD0:
        DB      &H41,&H10

L2CF8:

        cal	L32A8
        jp	L3B42		; display the character $16


L2CFE:
        DB      &H77

L2E0C:

KEY_WAIT:
        cal	R035A
        cal     LM_CRTKY          ; CH08: raw-ready + SYSCAL for CRTKY; cold BRK
        sbc	$0,&H90		; function key?
        jr	uz,L2E1F	; branch if so
L2E17:
        phs	$0
        cal	R035E
        pps	$0
        rtn

L2E1F:

        sbc	$0,&H9A
        jp	z,L2FE8	; jump if key code = &H9A, new all
        sbc	$0,&H9C
        jr	nc,L2E2E
        ad	$0,&H60,jr L2E17
L2E2E:
        phs	$0
        pre	us,M1099
        cal	L3139
        cal	L312C
        pps	$0
        sb	$0,&H9C
        jp	z,CH08_COLD      ; CS617: MENU must COLD initialize
        sb	$0,$sy
        jp	KEY_WAIT	; ignore CAL and MEMO in standalone monitor


L2E47:

        cal	L325B		; clear the variables &H0D0B to &H0D0D
        cal	L28D2		; PF display, 3-line scroll
        jp	L2AF9

L2E50:
        pre     ix,M08CB
        ldd     $0,(ix+$sx)
        st      $0,(ix+&H04)
        cal     L32B2
        cal     L2C53
        jp      L28C2

L2E62:

; Keyboard decode object.
        pre	ix,M09EF
        ld	$0,&H10
        ldw	$1,M09F2
        stm	$0,(ix+$sx),3
        jp	R0435		; clear the keyboard buffer

; expects coordinates of a pressed key in $0 and $1
; $0 contains the bit number of the KI port (1=KI1, 2=KI2, ...)
; $1 contains the KO state (1=KO1, 2=KO2, ...)
L2E73:
        ld	$4,(ix-$sy)	; KANA1
        anc	$4,&H02
        phs	$1
        cal	nz,L394A	; keyboard beep
        pps	$1
        ld	$2,(ix-&H02)	; KEYMD
        sbc	$1,&H02
        jr	nz,L2E91
        sbc	$0,&H05
        jr	z,L2ED3	; branch if KANA
        sbc	$0,&H03
        jr	z,L2ECC	; branch if CAPS
L2E91:
        sbc	$0,&H02
        jr	z,L2EAD	; branch if [S]
        sbc	$1,$sy
        jr	nz,L2EDA	; branch if other than BRK
        cal	R0435		; clear the keyboard buffer
        sbc	$0,$sy
        jr	nz,L2EA9
        ld	$0,&H03
L2EA4:
        ld	$7,$sx
        jp	R0634
L2EA9:
        ld	$0,&H13,jr L2EA4

; [S] key pressed
L2EAD:
        xr	$2,&H80		; flip the S mode
L2EB0:
        st	$2,(ix-&H02)	; KEYMD
        ldw	$3,M09E2
        ldw	$5,($3)
        stw	$30,($3)
        sbc	$5,&H1F
        jr	z,L2EC6
        sbc	$6,&H1F
        rtn	nz
L2EC6:
        ld	$0,&HDD
        jp	R0411		; put the character $0 to the keyboard buffer

; CAPS key pressed
L2ECC:
        an	$2,&H40
        xr	$2,&H40,jr L2EB0	; flip the CAPS mode

; KANA key pressed
L2ED3:
        an	$2,&H20
        xr	$2,&H20,jr L2EB0	; flip the English/Japanese bit

; other keys
L2EDA:
        cal	L2F15
        ld	$7,$sx
        anc	$2,&H20
        jp	z,R058B
        cal	R01E1		; OKAM1, is $0 a letter?
        jp	nc,R0578	; branch if not
        ld	$1,$sx
        ldw	$3,M0BD1
        cal	R0661
        ldw	$3,M09E2
        ldw	$5,($3)
        sbc	$0,&H06
        jp	nz,R0571
        ld	$0,&HDD
        sbc	$5,&H1F
        jr	z,L2F0E
        sbc	$6,&H1F
        jr	nz,L2F12
L2F0E:
        ld	$1,$sz
        ld	$7,$sy
L2F12:
        jp	R0634

L2F15:
        sbc	$0,$sy
        jr	z,L2F42
        sb	$0,&H03
        sb	$1,&H02
        biu	$1
        ad	$0,$1
        biu	$1
        biu	$1
        ad	$0,$1
L2F2B:
        anc	$2,&H80
        jr	nz,L2F48
        biu	$0
        anc	$2,&H40
        jr	z,L2F39
        ad	$0,$sy
L2F39:
        ldw	$3,L1601
L2F3D:
        ld	$1,$sx
        jp	R0661
L2F42:
        ad	$1,&H44
        bydw	$1,jr L2F2B
L2F48:
        anc	$2,&H20
        jr	z,L2F6D
        sbc	$0,&H48
        jr	c,L2F6D
        jr	z,L2F74
        sbc	$0,&H4E
        jr	z,L2F78
        jr	nc,L2F6D
        sbc	$0,&H4C
        jr	z,L2F6D
        jr	nc,L2F7C
        sbc	$0,&H4A
        jr	c,L2F80
        jr	z,L2F84
        ld	$0,&HA4
        rtn
L2F6D:
        ldw	$3,M16C9
        biu	$0,jr L2F3D
L2F74:
        ld	$0,&HB0
        rtn
L2F78:
        ld	$0,&HA3
        rtn
L2F7C:
        ld	$0,&HA2
        rtn
L2F80:
        ld	$0,&HA5
        rtn
L2F84:
        ld	$0,&HA1
        rtn

L2F88:

C_EXEC:
        cal	L28C2
        cal	L2136		; parser
        pre	iz,M0000
        sbc	(iz+$sx),$31
        rtn	z
        cal	L3223
        cal	L26AE
        cal	R0049		; NEXTC, get next character other than space
        sbc	$0,&H04
        jr	z,L2FCA


L2FA3:
        sbc     $23,$sy

L2FCA:

        ldi	$16,(iz+$sy)
        pre	ix,L2FD9
        cal	R028A		; execute a procedure from the table


L2FD3:
        DB      &H3B

L2FD9:
        DB      &H6A
        DW      CLEAR_C

; NEW ALL object.

L2FE8:

NEWALL:
        PST     UA,&H14
        CAL     L22C2
        CAL     L2442
        LDW     $0,M0AC0
        LDW     $2,&H0122
        CAL     R027B
        PRE     IX,M08D9
        LD      $0,&H07
        ST      $0,(IX+$SY)

        LDW     $0,M8000
        SLW
        LD      $2,($SZ)
        INV     $2
        ST      $2,($SZ)
        LD      $3,($SZ)
        FST
        SBC     $2,$3
        JR      Z,NA_REXP

; No RAM expansion card.
        LDW     $2,NA_T32

NA_COPY:
        LDW     $0,M0A80
        LDW     $4,&H0036
        CAL     R026C
        CAL     L3178
        LD      $0,&H0A
        PRE     IX,M09E4
        STW     $31,(IX+$SX)
        PRE     IX,M0AB8
        LDW     $0,&H02B0
        LDW     $2,&H0503
        STM     $0,(IX+$SX),4
        PRE     IX,M0A03
        LDW     $0,&H0800
        STM     $31,(IX+$SX),3
L304D:
        PRE     IZ,L0DB9
        LDW     $0,(IZ+$SX)
        PRE     IX,M0A66
        STW     $0,(IX+$SX)
        PRE     SS,M1298
        PRE     US,M1099
        PST     UA,&H54
        CAL     L7200

        JP      MONITOR

NA_REXP:
        LDW     $2,&HAA55
        ST      $2,($SZ)
        LD      $1,&HA0
        ST      $3,($SZ)
        LD      $1,&H80
        LD      $0,($SZ)
        SBC     $2,$SZ
        JR      NZ,NA_RP8

; RP-33.
        LDW     $2,NA_T33
        JR      NA_COPY

NA_RP8:
        LDW     $2,NA_T8
        JR      NA_COPY


L308A:

NA_T32:
        DB      &H00,&H1A,&H00,&H1A,&H80,&H2E
        DB      &H80,&H2E,&H80,&H2E,&H80,&H2E,&H00,&H43
        DB      &H00,&H43,&H00,&H43,&H00,&H43,&H00,&H6C
        DB      &H00,&H6C,&H00,&H6C,&H00,&H6C,&H00,&H6C
        DB      &H00,&H70,&H00,&H70,&H00,&H70,&H00,&H70
        DB      &H00,&H70,&H00,&H70,&H00,&H70,&H00,&H70
        DB      &H00,&H70,&HFF,&H7F,&HFF,&H7F,&HFF,&H7F

L30C0:

NA_T8:
        DB      &H00,&H1A,&H00,&H1A,&H80,&H36,&H80,&H36
        DB      &H80,&H36,&H80,&H36,&H00,&H53,&H00,&H53
        DB      &H00,&H53,&H00,&H53,&H00,&H8C,&H00,&H8C
        DB      &H00,&H8C,&H00,&H8C,&H00,&H8C,&H00,&H90
        DB      &H00,&H90,&H00,&H90,&H00,&H90,&H00,&H90
        DB      &H00,&H90,&H00,&H90,&H00,&H90,&H00,&H90
        DB      &HFF,&H9F,&HFF,&H9F,&HFF,&H9F

L30F6:

NA_T33:
        DB      &H00,&H1A,&H00,&H1A,&H80,&H4A,&H80,&H4A
        DB      &H80,&H4A,&H80,&H4A,&H00,&H7B,&H00,&H7B
        DB      &H00,&H7B,&H00,&H7B,&H00,&HDC,&H00,&HDC
        DB      &H00,&HDC,&H00,&HDC,&H00,&HE0,&H00,&HE0
        DB      &H00,&HE0,&H00,&HE0,&H00,&HE0,&H00,&HE0
        DB      &H00,&HE0,&H00,&HE0,&H00,&HE0,&H00,&HE0
        DB      &HFF,&HFF,&HFF,&HFF,&HFF,&HFF

L312C:

DSP_INIT:
        ldw	$0,M08CA	; LCDST, LCD state
        st	&H06,($sz)
        cal	L28D8		; Normal display, 4-line scroll
        jp	L3B3A		; display code &H0C - clear screen


L3139:
        DB      &H77,&H00,&H00

L3169:

C_INIT:
        ldw	$0,&H4107
        ldw	$2,&H0080
        pre	ix,M09E6
        stm	$0,(ix+$sx),4
L3178:
        ppo	&HC0
        pst	ia,&H40
        pst	pd,&HE8
        pst	pe,&HF8
        pre	ix,M0AB6
        ldw	$0,M1A00
        stw	$0,(ix+$sx)
        pre	ix,M0A98
        ldiw	$0,(ix+$sx)
        stiw	$0,(ix+$sx)
        stw	$0,(ix+$sx)
        ldw	$0,M08CA
        st	&H06,($sz)
        cal	L28D8		; Normal display, 4-line scroll
        pre	ix,M09E4
        ldw	$0,(ix+$sx)
        an	$0,&H60
        an	$1,&H02
        stw	$0,(ix+$sx)
        cal	L2E62
        cal	L32AB		; clear the ANSFG variable
        cal	L325B		; clear the variables &H0D0B to &H0D0D
        ldw	$0,M0ABE
        st	$31,($sz)
        pre	ix,M08D7
        ld	$0,&H5F
        st	$0,(ix+$sy)
        cal	L2307
        cal	L28D2		; PF display, 3-line scroll
        pst	pd,&HC8
        cal	L64D7		; turn on the tape motor relay
        cal	L64BE
        slw
        cal	R055A
        pre	iz,M0C03
        pre	ix,M0ABC
        ldiw	$0,(iz+$sx)
        ld	$1,$sx
        stw	$0,(ix+$sx)
        adc	$0,$sy
        jr	c,L3203
        ldw	$0,&H050D
        stw	$0,(iz+$sx)
        ldw	$0,&H0104
        ld	$7,$sx
        cal	L3B9B
        fst
        ld	$4,&H03
        std	$4,(iz+$sy)
        rtn


L3203:
        pst     pe,&HC0

L3208:

        cal	L3214
        cal	L321A
        cal	L3223
        jp	L6C37		; close all opened files

L3214:
        pre	ix,M0AA2
        jr	L321E
L321A:
        pre	ix,M0AA0
L321E:
        ldw	$0,(ix+$sx)
        stdw	$1,(ix-$sy)
        rtn
L3223:
        pre	us,M1099
        pre	ix,M0A9A
        ldiw	$0,(ix+$sx)
        stw	$0,(ix+$sx)
        rtn
L3230:
        pre	ix,M0D0B	; MODE system variable
        ldd	$1,(ix+$sx)
        rtn


L3237:
        ld      $0,&H80,jr L3255
L323B:
        ld      $0,&H40,jr L3255
L323F:
        ld      $0,&H20,jr L3255
L3243:
        ld      $0,&H10,jr L3255
L3247:
        ld      $0,&H08,jr L3255
L324B:
        ld      $0,&H04,jr L3255
L324F:
        ld      $0,&H02,jr L3255
L3253:
        ld      $0,$sy
L3255:
        cal     L3230
        anc     $1,$sz
        rtn
L325B:
        pre     ix,M0D0B
        sbw     $0,$sz
        stm     $31,(ix+$sx),3
        rtn
L3265:
        ld      $1,&H07,jr L3274
L3269:
        ld      $1,&H06,jr L3274
L326D:
        ld      $1,&H05,jr L3274
L3271:
        ld      $1,&H04
L3274:
        cal     R0049
        sbc     $1,$sz
        rtn     nz
        sbc     (iz+$sy),$2
        rtn     nz
        ldiw    $1,(iz+$sx)
        rtn
L3280:
        pre     ix,M0CE2
        stw     $2,(ix+$sx)
        rtn


L3287:
        ld      $0,&H04,jr L3291
L328B:
        ld      $0,&H02,jr L3291
L328F:
        ld      $0,$sx
L3291:
        pre     ix,M0ABD
        std     $0,(ix+$sx)
        rtn
L3298:

        pre	ix,M0A02	; ANSFG, post calculating flag
        ldd	$1,(ix+$sx)
        sbc	$1,$sx
        rtn


L32A1:
        cal     L3298
        rtn     z
        cal     L3B47
L32A8:

        cal	L22E0		; cursor display enable
L32AB:
        ldw	$0,M0A02	; ANSFG, post calculating flag
        st	$31,($sz)	; clear the "after calculation" flag
        rtn
L32B2:
        cal	L22FA		; cursor display disable
        cal	L3298		; test the ANSFG variable
        rtn	nz
        jp	L22E0		; cursor display enable

L32BC:
        cal	R04EA		; test the power switch
        ld	$3,&H03		; counter
L32C2:
        ld	$0,&H41		; data for the IA register
        cal	R043D		; select KO column $0, read KI to $1,$2
        sbc	$1,$sx		; BRK key?
        rtn	z		; return if not

L32CB:
        sb      $3,$sy
        jr      nz,L32C2
        jp      C_RESET

L394A:
        ld      $3,$sy
        jp      L3951


L394D:
        ldw     $3,&H0010
L3951:
        ld	$2,$sx
        ld	$4,$sy,jr L395C

; print control code $07 / low tone beep entry
L3956:
        ldw     $2,&H0200
        ld      $4,$sx
L395C:
        gst	pd,$1
        an	$1,&H3F
        or	$1,&H40
L3964:
        pst	pd,$1
        xr	$1,&HC0
        sbbw	$2,$sy
        jr	c,L397E
        sbc	$4,$sx
        jr	z,L3975
        ldm	$0,$0,6,jr L3964
L3975:
        ad      $4,&H0D
        jr      nc,L3975
        ld      $4,$sx
        jr      L3964
L397E:
        or	$1,&HC0
        pst	pd,$1
        rtn


L3984:
        DB      &H27,&H00,&H77

L3A84:

CLEAR_C:
        cal	R0049		; NEXTC, get next character other than space
        ldm	$0,(iz+$sx),4
        ldw	$4,&H4F4D	; 'MO'
        ldw	$6,&H004E	; 'N'
        xrcm	$4,$sz,4
        jp	z,L6F17                                            ; collapse original JR Z -> fixed JP Z monitor
        jp      L3A97             ; preserve original not-taken fall-through


L3A97:
        ldw     $4,&H6F6D
        ld      $6,&H6E
        xrcm    $4,$sz,4

L3AA1:

        jp	z,L6F17	; monitor


L3AA4:
        ldw     $4,&H5553
        ldw     $6,&H004D
        xrcm    $4,$sz,4
        jr      z,L3AD0
        ldw     $4,&H7573
        ld      $6,&H6D
        xrcm    $4,$sz,4
        jr      z,L3AD0
        cal     R01C9
        pre     ix,M0AAA
        ldw     $1,(ix+$sx)
        ld      $0,&H06
L3AC9:
        stdw    $2,(ix-$sy)
        sb      $0,$sy
        jr      nz,L3AC9
        rtn

L3AD0:
        pre     ix,M0C12
        ldw     $2,&HF3EE
        sbw     $28,$28
        pst     ua,&H04
L3ADE:
        ldi     $0,(ix+$sx)
        ad      $28,$sz
        xr      $29,$sz
        sbw     $2,$sy
        jr      nz,L3ADE
        pst     ua,&H54
        ldw     $15,L3B24
        cal     L291A
        ld      $15,$28
        cal     L3B0E
        cal     L3B47
        ldw     $15,L3B2D
        cal     L291A
        ld      $15,$29
        cal     L3B0E
        cal     L3B47
        jp      L2B2F

L3B0E:
        cal     L3B11
L3B11:
        diuw    $15
        an      $16,&H0F
        ad      $16,&H30
        sbc     $16,&H3A
        jr      c,L3B21
        ad      $16,&H07
L3B21:
        jp      L3B50

L3B24:
        db      &H08,&H52,&H4F,&H4D,&H2D,&H53,&H55,&H4D,&H20
L3B2D:
        db      &H08,&H52,&H4F,&H4D,&H2D,&H58,&H4F,&H52,&H20

L3B36:
        ld      $16,&H18,jr L3B50

L3B3A:

OUT_CTL:
        ld	$16,&H0C,jr L3B50	; clear screen
L3B3E:
        ld	$16,&H20,jr L3B50	; display a space
L3B42:
        cal	L22E4
        jr	L3B53
L3B47:
        ld	$16,&H0D
        cal	L3B50
        ld	$16,&H0A
L3B50:
        cal	L22FE
L3B53:
        pre	ix,M0ABD	; OUTDV, output device
        ldd	$0,(ix+$sx)
        sbc	$0,&H02
        jp	c,L249A	; OUTDV=&H00, LCD


L3B5F:
        jp      L249A

L3B9B:

        bydw	$6		; = LD $5,$6
        st	$0,(iz+$sy)	; printer control port
        st	$1,(iz+$sy)
        sbc	$7,$sy		; printing or port initialisation?
        cal	z,L3BAB	; wait until the printer is ready
        na	$4,$sx		; = LD $4,&HFF
        std	$4,(iz+$sx)	; printer data port
        rtn

L3BAB:
        cal     L32BC
        rtn


L3C40:

        ppum	$0,3
        pre	iz,$1
        pst	ua,$0
        rtn
L3C48:
        gst	ua,$1
        gre	iz,$2
        phum	$3,3
        pst	ua,&H14
        rtn


L3C53:
        DB      &H77,&H93,&H3C

L4D6E:

        ldw	$2,M0D0B	; MODE system variable
        ld	$0,($2)
        sbc	$0,&H03		; C+EDIT mode?
        jp	nz,R0368
        jp      L4D7B              ; preserve not-taken fall-through exactly

L4D7B:
        sbc     $24,$sy
        jp      nz,R0368
        anc     $23,&H06
        jp      nz,R0368
        anc     $1,&H02
        rtn     z
        xr      $1,&H10
        std     $1,(ix+$sx)
        ldd     $10,(ix+$sx)
        cal     R030C
        anc     $10,&H10
        jp      z,R0388
        pre     ix,M09E4
        ldd     $1,(ix+$sx)
        na      $0,$sx
        anc     $1,&H20
        jr      z,L4DAA
        ld      $0,&H0F
L4DAA:
        jp      R037D

L5774:

KYIN:
        cal	L2E0C		; wait for a key, handle the function keys
        sbc	$0,$sy
        jr	nc,L5780


L577B:
        cal     R0426
        na      $0,$sx

L5780:

        sbc	$0,&H0D
        rtn	z
        sbc	$0,&H59
        rtn	z
        sbc	$0,&H79
        rtn


L578C:
        DB      &HA6,&H01,&H96

L64BE:

        cal	L3C48		; save UA and IZ on the user stack, UA <- &H14
        pre	iz,M0C04
        ld	$0,&H80
        std	$0,(iz+$sx)
        jp	L3C40		; restore UA and IZ from the user stack


L64CD:
        pre     iz,M0C01
        ld      $1,&H18
        st      $1,(iz+$sy)
        rtn

L64D7:

        cal	L64E6		; delay 20ms
        cal	L3C48		; save UA and IZ on the user stack, UA <- &H14
        pre	iz,M0C04
        std	$31,(iz+$sx)
        cal	L3C40		; restore UA and IZ from the user stack
L64E6:
        ld	$0,$sx
L64E8:
        cal	L20CF		; dummy call, waste some time
        sb	$0,$sy
        jr	nz,L64E8
        rtn


L64F0:
        ld      $5,&H0A

L6C26:

        ldw	$0,M0A98	; IOBF system variable
        ldw	$8,($sz)	; starting address of the I/O buffer
        ldw	$2,M0A9A	; SSTOP system variable
        ldw	$2,($2)		; ending address of the I/O buffer
        sbcw	$2,$8
        rtn

L6C37:
        cal	L6C26		; address of the first I/O control block
        jp	z,R029D	; INT1 interrupt disable if the buffer empty
        jp      L6C3D


L6C3D:
        DB      &H96

L6F0A:

        db	'B'
        dw	L6FBF
        db	'D'
        dw	L708F
        db	'E'
        dw	L6FED
        db	'Q'
        dw	L707C
        db	&H00
MONITOR:
L6F17:
        pst	ua,&H54
        pre	ss,M1298
        pre	us,M1099
        ldw	$0,M0CE6	; address
        ldw	$2,&H0018	; number of bytes
        cal	R027B		; CLRME, clear memory block
        pre	ix,M0CE6	; memory bank setting
        ld	$0,&H31
        std	$0,(ix+$sx)
        ldw     $2,$30          ; CS617: ACJMP=0000, native COLD fallback
        cal	L3280		; BRSTR, set ACJMP
        cal     L312C               ; CH08: skip donor splash; clear then show >
L6F40:
        cal	L715C		; display '>'
        ld	$0,&H0A
        cal	L22E6
        ld	$10,(ix+$sy)
        an	$10,&HE0
        ad	$10,$sy
        sti	$10,(ix+&H06)
        or	$10,&H1F
        st	$10,(ix+$sx)
L6F58:
        cal	L5774		; KYIN
        sbc	$0,&H0D		; EXE?
        jr	nz,L6F9C
        cal	L22F2		; ignore the cursor movement range setting
        cal	L28C2
        pre	ix,M0000
        ld	$0,&H0F
L6F6D:
        ldi	$1,(iz+$sx)
        sti	$1,(ix+$sx)
        sb	$0,$sy
        jr	nc,L6F6D
        cal	L3B47		; OUTCR, display CR-LF
        pre	iz,M0000
        adc	(iz+$sx),$31
        jr	z,L6FA8
        cal	L71A2		; convert a string to upper case
        ldi	$0,(iz+$sx)
        pre     ix,LIMON_CMD_TABLE
        pst	ua,&H04
L6F8C:
        ldim	$1,(ix+$sx),3
        adc	$1,$sx
        jr	z,L6FA8
        sbc	$1,$sz
        jr	nz,L6F8C
        pst	ua,&H54
        jp	$2
L6F9C:
        sbc	$0,&HF0
        jr	nc,L6F58
        ld	$16,$sz
        cal	L3B42		; display the character $16
        jr	L6F58
L6FA8:
        pst	ua,&H54
        cal	L7160		; display '?'
L6FAE:
        pre	ss,M1298
        pre	us,M1099
        cal	L22F2		; ignore the cursor movement range setting
        cal	L3B47		; OUTCR, display CR-LF
L6FBC:
        jp	L6F40
L6FBF:
        adc	(iz+$sx),$31
        jr	nz,L6FA8
        pre	iz,M0CE6	; memory bank setting
        ldd	$16,(iz+$sx)
        cal	L3B50		; display the character $16
        cal	L7164		; display '-'
L6FCF:
        cal	L5774		; KYIN
        sbc	$0,&H0D		; EXE?
        jr	z,L6FE8
        ld	$16,$sz
        sbc	$0,&H30		; '0'
        jr	c,L6FCF
        sbc	$0,&H34		; '4'
        jr	nc,L6FCF
        cal	L3B50		; display the character $16
        std	$16,(iz+$sx)	; store the new value
L6FE8:
        cal	L3B47		; OUTCR, display CR-LF
        jr	L6FBC
L6FED:
        adc	(iz+$sx),$31
        jr	z,L6FFF
        cal	L717F		; convert a hex number to binary
        pre	ix,M0CEB	; Edit address
        stiw	$14,(ix+$sx)
        adc	$0,$sx
        jp	nz,L6FA8
L6FFF:
        ldw	$17,&H0103
        cal	LEV5DSP	; display Edit bank:address followed by a space
L7006:
        cal	L710A
        cal	L7164		; display '-'
L700C:
        cal	L5774		; KYIN
        sbc	$0,&H0D		; EXE?
        jr	z,L7056	; exit the Edit mode - display CR-LF and return
        sbc	$0,&H08		; backspace?
        jr	z,L705C	; discard changes, back to the previous address
        sbc	$0,&H20		; space?
        jr	z,L7067	; discard changes, move to the next address
        ld	$16,$sz
        cal	R01D3		; CHEX1, hex character to binary conversion
        jr	nc,L700C	; ignore invalid entries
        adc	$18,$sx		; first or second hexadecimal digit?
        jr	nz,L7071	; branch if the first one
        or	$19,$sz		; lower nibble of the byte
        cal	L3B50		; display the character $16
        pre	ix,M0CE6	; memory bank setting
        ldm	$0,(ix+$sx),7
        ; CS617 effective-write whitelist, before any UA bank transition.
        ; $0 = ASCII bank; $5/$6 = live E cursor from M0CEB/0CEC.
        ; Allow only two dedicated bytes in RAM bank 1, so nothing can
        ; overwrite launcher, other app state, executable RAM or stack.
        sbc     $0,&H31
        jp      nz,LM_WRITE_DENIED
        sbc     $6,&H2E        ; high byte must equal 2Eh
        jp      nz,LM_WRITE_DENIED
        sbc     $5,&H02        ; low byte must be 00h or 01h
        jp      nc,LM_WRITE_DENIED
        pre	iz,$5
        cal	L71BA		; select the memory bank for the IZ register
        st	$19,(iz+$sx)	; store the byte
        pst	ua,&H54
L703F:
        pre	ix,M0CEB	; Edit address
        adw	(ix+$sx),$30	; increment it
        ld	$18,$sy		; flag of the first hexadecimal digit
        adc	$17,$sx		; test the counter of the characters
        jr	z,L7051	; branch if the end of the line reached
        cal	L3B3E		; display a space
        sb	$17,$sy,jr L7006 ; decrement the counter of the characters
L7051:
        cal	L3B47		; OUTCR, display CR-LF
        jr	L6FFF
L7056:
        cal	L3B47		; OUTCR, display CR-LF
        jp	L6F40
L705C:
        pre	ix,M0CEB	; Edit address
        sbw	(ix+$sx),$30	; decrement the address
        cal	L3B47		; OUTCR, display CR-LF
        jr	L6FFF
L7067:
        cal	L3B3E		; display a space
        adc	$18,$sx
        cal	nz,L3B3E	; display a space
        jr	L703F
L7071:
        sb	$18,$sy		; flag of the next digit
        diu	$0
        ld	$19,$sz		; upper nibble of the byte
        cal	L3B50		; display the character $16
        jp	L700C        ; r010a: out-of-range JR after write-guard insertion
L707C:
        jp      CH08_COLD   ; Chapter 08 Q exits via genuine cold initialization
        jp	L6F40         ; unreachable inherited slot, retained for stable geometry                                              ; return to monitor prompt
L7082:
        ldi	$0,(iz+$sx)
        adc	(iz+$sx),$31
        jp	z,L6FA8
        pre	ix,M0CE9
        jr	L70AD
L708F:
        adc	(iz+$sx),$31
        jr	z,L70C0
        ldd	$0,(iz+$sx)
        sbc	$0,&H2C		; comma?
        jr	z,L7082
        cal	L717F		; convert a hex number to binary
        pre	ix,M0CE7	; starting Dump address
        stiw	$14,(ix+$sx)
        adc	$0,$sx
        jr	z,L70C0	; branch if only first Dump address specified
        sbc	$0,&H2C		; comma?
        jp	nz,L6FA8
L70AD:
        cal	L717F		; convert a hex number to binary
        stw	$14,(ix+$sx)	; ending Dump address
        adc	$0,$sx
        jp	nz,L6FA8
        cal	L70D9
L70BA:
        cal	L3B47		; OUTCR, display CR-LF
        jp	L6F40
L70C0:
        cal	L70C5
        jr	L70BA
L70C5:
        ld	$17,&H08
L70C8:
        cal	LDV5DSP	; display Dump bank:address followed by a space
L70CB:
        cal	L7117
        cal	L32BC		; test the OFF switch and BRK key
        sb	$17,$sy
        rtn	z
        cal	L3B3E		; display a space
        jr	L70CB
L70D9:
        pre	ix,M0CE7	; Dump address
        ldm	$21,(ix+$sx),4
        sbw	$23,$21
        jp	c,L6FA8
        ldw	$25,&H0008
        adw	$23,$sy
        jr	c,L70F9
L70EE:
        sbcw	$23,$25
        jr	z,L70C5
        jr	nc,L70FF
        ld	$17,$23,jr L70C8
L70F9:
        ldw	$23,&HFFF8
        jr	L7102
L70FF:
        sbw	$23,$25
L7102:
        cal	L70C5
        cal	L3B47		; OUTCR, display CR-LF
        jr	L70EE
L710A:
        pre	ix,M0CE6	; memory bank setting
        ldm	$0,(ix+$sx),7
        pre	iz,$5
        sbc	$6,&H0C,jr L7125
L7117:
        pre	ix,M0CE6	; memory bank setting
        ldm	$0,(ix+$sx),3
        adw	(ix+$sy),$30
        pre	iz,$1
        sbc	$2,&H0C		; address >= &H0C00 ?
L7125:
        jr	nc,L7133
        sbc	$0,&H30		; bank 0 ?
        jr	nz,L7133
        na	$15,$sx		; $15 = &HFF
        cal	L7142		; display the first digit
        jr	L7139		; display the second digit
L7133:
        cal	L71BA		; select the memory bank for the IZ register
        cal	L713B		; fetch a byte, display the first digit
L7139:
        jr	L7142		; display the second digit
L713B:
        slw
        ldd	$15,(iz+$sx)
        fst
        pst	ua,&H54
L7142:
        diuw	$15
        cal	L7194		; convert the $16 digit to hex ASCII
L7147:
        jp	L3B50		; display the character $16
L714A:
        pre	ix,M0CEB	; Edit address
        jr	L7154
L7150:
        pre	ix,M0CE7	; Dump address
L7154:
        ldw	$14,(ix+$sx)
        cal	L7168		; display a hex word $14,$15
        jp	L3B3E		; display a space
L715C:
        ld	$16,&H3E,jr L7147	; display '>'
L7160:
        ld	$16,&H3F,jr L7147	; display '?'
L7164:
        ld	$16,&H2D,jr L7147	; display '-'
L7168:
        phsm	$17,4
        ld	$17,$sx
L716D:
        dium	$14,3
        cal	L7194		; convert the $16 digit to hex ASCII
        cal	L3B50		; display the character $16
        ad	$17,&H40	; counter of digits
        jr	nc,L716D	; branch if less than 4 digits processed
        ppsm	$14,4
        rtn
L717F:
        sbbm	$13,$13,3
L7182:
        ldi	$0,(iz+$sx)
        cal	R01D3		; CHEX1, hex character to binary conversion
        rtn	nc
        diuw	$14
        or	$14,$sz
        ad	$13,&H40	; counter of digits
        jr	nc,L7182	; up to 4 digits can be processed
        ldi	$0,(iz+$sx)
        rtn
L7194:
        an	$16,&H0F
        ad	$16,&H30
        sbc	$16,&H3A
        rtn	c
        ad	$16,&H07
        rtn
L71A2:
        phsw	$1
        gre	iz,$0
        phsw	$1
L71A8:
        ldd	$0,(iz+$sx)
        cal	R01EC		; TCAPS, lower to upper case conversion
        sti	$0,(iz+$sx)
        adc	(iz+$sx),$31
        jr	nz,L71A8
        ppsw	$0
        pre	iz,$0
        ppsw	$0
        rtn
L71BA:
        cal	L71C0
        pst	ua,$0
        rtn
L71C0:
        diu	$0
        biu	$0
        biu	$0
        or	$0,&H14
        rtn

; Immediate NEW ALL dependency.


L71CA:
        cal     R09E0
        jp      R06CF

L7200:
N7200:
        PRE     IX,M0BE1
        ST      $31,(IX+$SX)
        PRE     IX,M129A
        ST      $31,(IX+$SX)
        RTN



; v8: removed isolated inherited C compiler initialization island L7210..LA8C2.
; v7 first removed the sole live call into L7643 and passed runtime testing;
; static cross-reference analysis then found no remaining named inbound references.


; LIMON standalone extension block.


LIMON_CMD_TABLE:
        DB      'B'
        DW      LBV5
        DB      'D'
        DW      LDV5
        DB      'E'
        DW      LEV5
        DB      'Q'
        DW      L707C
        DB      'U'
        DW      LUV5
        DB      &H00


; LIMON startup splash.
; Four 32-character rows are stored as one zero-terminated buffer.
; DS is not used inside the visible buffer because zero terminates PRINTZ.

LIMON_SPLASH:
        cal     L312C                ; initialize and clear monitor display
        pst     ua,&H14               ; firmware text state
        ld      $6,0                  ; start of 32 x 4 firmware text surface
        pre     iz,LSPL_TXT
        cal     LSPL_PRINTZ
        pst     ua,&H54               ; restore monitor UA state
        cal     L22FA                ; cursor display off while splash is held

LSPL_WAIT:
        cal     L5774                ; KYIN
        sbc     $0,&H0D
        jr      nz,LSPL_WAIT
        cal     L312C                ; initialize and clear monitor display
        rtn

; Firmware normal/small-character text output path.
LSPL_PRINTZ:
        ldi     $7,(iz+$sx)
        ld      $0,$7
        diu     $7
        did     $0
        or      $7,$sz
        rtn     z
        cal     R0197
        jr      LSPL_PRINTZ

; One contiguous zero-terminated 32 x 4 splash buffer.
LSPL_TXT:
        db      "                   Xandrian Labs"
        db      "                       limon 0.9"
        db      "                       Press EXE"
        db      "                                "
        db      0

; Explicit validation errors added in v6; messages refined in v9.
; These report only the newly validated conditions; inherited syntax errors keep
; the monitor's original handling.
LERR_UA:
        ld      $16,&H42              ; B
        cal     L3B50
        ld      $16,&H41              ; A
        cal     L3B50
        ld      $16,&H44              ; D
        cal     L3B50
        cal     L3B3E                 ; space
        ld      $16,&H55              ; U
        cal     L3B50
        ld      $16,&H41              ; A
        cal     L3B50
        cal     L3B3E                 ; space
        ld      $16,&H28              ; (
        cal     L3B50
        ld      $16,&H65              ; e
        cal     L3B50
        ld      $16,&H78              ; x
        cal     L3B50
        cal     L3B3E                 ; space
        ld      $16,&H31              ; 1
        cal     L3B50
        ld      $16,&H34              ; 4
        cal     L3B50
        ld      $16,&H2C              ; ,
        cal     L3B50
        ld      $16,&H35              ; 5
        cal     L3B50
        ld      $16,&H34              ; 4
        cal     L3B50
        ld      $16,&H2C              ; ,
        cal     L3B50
        ld      $16,&H35              ; 5
        cal     L3B50
        ld      $16,&H35              ; 5
        cal     L3B50
        ld      $16,&H29              ; )
        cal     L3B50
        jr      LERR_DONE

LERR_BANK:
        ld      $16,&H42              ; B
        cal     L3B50
        ld      $16,&H41              ; A
        cal     L3B50
        ld      $16,&H44              ; D
        cal     L3B50
        cal     L3B3E                 ; space
        ld      $16,&H42              ; B
        cal     L3B50
        ld      $16,&H41              ; A
        cal     L3B50
        ld      $16,&H4E              ; N
        cal     L3B50
        ld      $16,&H4B              ; K
        cal     L3B50
        cal     L3B3E                 ; space
        ld      $16,&H28              ; (
        cal     L3B50
        ld      $16,&H30              ; 0
        cal     L3B50
        ld      $16,&H2D              ; -
        cal     L3B50
        ld      $16,&H33              ; 3
        cal     L3B50
        ld      $16,&H29              ; )
        cal     L3B50
LERR_DONE:
        cal     L3B47                 ; CR/LF
        jp      L6F40

; D and E keep independent bank contexts.  The bank is an ASCII digit 0..3.
; M0CE6 remains the active bank byte used by the original monitor access code.

LDV5:
        pre     ix,M0CED
        ld      $16,(ix+$sx)
        adc     $16,$sx
        jr      nz,LDV5CTX
        ld      $16,&H31
        st      $16,(ix+$sx)
LDV5CTX:
        pre     ix,M0CE6
        st      $16,(ix+$sx)
        gre     iz,$20
        ldi     $0,(iz+$sx)
        ld      $16,$0
        ldi     $1,(iz+$sx)
        sbc     $1,&H3A               ; x: is explicitly a bank prefix
        jr      nz,LDV5NOP
        ld      $0,$16
        sbc     $0,&H30
        jp      c,LERR_BANK
        sbc     $0,&H34
        jp      nc,LERR_BANK
        pre     ix,M0CED
        st      $16,(ix+$sx)
        pre     ix,M0CE6
        st      $16,(ix+$sx)
        jp      L708F
LDV5NOP:
        pre     iz,$20
        jp      L708F

LEV5:
        pre     ix,M0CEE
        ld      $16,(ix+$sx)
        adc     $16,$sx
        jr      nz,LEV5CTX
        ld      $16,&H31
        st      $16,(ix+$sx)
LEV5CTX:
        pre     ix,M0CE6
        st      $16,(ix+$sx)
        gre     iz,$20
        ldi     $0,(iz+$sx)
        ld      $16,$0
        ldi     $1,(iz+$sx)
        sbc     $1,&H3A               ; x: is explicitly a bank prefix
        jr      nz,LEV5NOP
        ld      $0,$16
        sbc     $0,&H30
        jp      c,LERR_BANK
        sbc     $0,&H34
        jp      nc,LERR_BANK
        pre     ix,M0CEE
        st      $16,(ix+$sx)
        pre     ix,M0CE6
        st      $16,(ix+$sx)
        jp      L6FED
LEV5NOP:
        pre     iz,$20
        jp      L6FED

; Temporary compatibility command.  B sets both D and E bank contexts.
LBV5:
        adc     (iz+$sx),$31
        jp      nz,L6FA8
        pre     iz,M0CE6
        ldd     $16,(iz+$sx)
        cal     L3B50
        cal     L7164
LBV5_KEY:
        cal     L5774
        sbc     $0,&H0D
        jr      z,LBV5END
        ld      $16,$0
        sbc     $0,&H30
        jp      c,LBV5_BAD
        sbc     $0,&H34
        jp      nc,LBV5_BAD
        cal     L3B50
        pre     ix,M0CE6
        st      $16,(ix+$sx)
        pre     ix,M0CED
        st      $16,(ix+$sx)
        pre     ix,M0CEE
        st      $16,(ix+$sx)
LBV5END:
        cal     L3B47
        jp      L6F40
LBV5_BAD:
        cal     L3B47                 ; finish the displayed current-bank prompt
        jp      LERR_BANK

LDV5DSP:
        pre     ix,M0CED
        ld      $16,(ix+$sx)
        cal     L3B50
        ld      $16,&H3A
        cal     L3B50
        jp      L7150

LEV5DSP:
        pre     ix,M0CEE
        ld      $16,(ix+$sx)
        cal     L3B50
        ld      $16,&H3A
        cal     L3B50
        jp      L714A

; Raw-UA read-only memory probe.
; Syntax: Uua:address or Uua:address,end
; UA is restored to &H54 immediately after each IZ byte read.
LUV5:
        adc     (iz+$sx),$31
        jp      z,L6FA8
        cal     L717F
        sbc     $13,&H80
        jp      nz,L6FA8
        adc     $15,$sx
        jp      nz,L6FA8
        sbc     $0,&H3A
        jp      nz,L6FA8
        ld      $1,$14
        an      $1,&H0F
        sbc     $1,&H04
        jr      z,LU5_UA_OK
        sbc     $1,&H05
        jp      nz,LERR_UA
LU5_UA_OK:
        pre     ix,M0CEF
        st      $14,(ix+$sx)
        adc     (iz+$sx),$31
        jp      z,L6FA8
        cal     L717F
        pre     ix,M0CF0
        stiw    $14,(ix+$sx)
        adc     $0,$sx
        jr      z,LU5ONE
        sbc     $0,&H2C
        jp      nz,L6FA8
        cal     L717F
        stw     $14,(ix+$sx)
        adc     $0,$sx
        jp      nz,L6FA8
        cal     LU5RNG
        cal     L3B47
        jp      L6F40
LU5ONE:
        cal     LU5LINE
        cal     L3B47
        jp      L6F40

LU5LINE:
        ld      $17,&H08
        cal     LU5DSP
LU5LOOP:
        cal     LU5GET
        cal     L32BC
        sb      $17,$sy
        rtn     z
        cal     L3B3E
        jr      LU5LOOP

LU5RNG:
        pre     ix,M0CF0
        ldm     $21,(ix+$sx),4
        sbw     $23,$21
        jp      c,L6FA8
        ldw     $25,&H0008
        adw     $23,$sy
        jr      c,LU5LAST
LU5RLP:
        sbcw    $23,$25
        jr      z,LU5LINE
        jr      nc,LU5FULL
        ld      $17,$23
        jr      LU5PART
LU5LAST:
        ldw     $23,&HFFF8
        jr      LU5CALL
LU5FULL:
        sbw     $23,$25
LU5CALL:
        cal     LU5LINE
        cal     L3B47
        jr      LU5RLP
LU5PART:
        cal     LU5DSP
LU5PLP:
        cal     LU5GET
        cal     L32BC
        sb      $17,$sy
        rtn     z
        cal     L3B3E
        jr      LU5PLP

; Read one byte through IZ using the exact raw UA probe value.
LU5GET:
        pre     ix,M0CEF
        ld      $0,(ix+$sx)
        pre     ix,M0CF0
        ldw     $1,(ix+$sx)
        adw     (ix+$sx),$30
        pre     iz,$1

        ; A low nibble of 5 selects PC bank 1.  Per the HD61700 manual the
        ; PC-bank change is delayed until a following jump/call/return.
        ; Mask interrupts and perform the IZ load inline, restoring UA before
        ; any control transfer.  This preserves U's raw-Z probe while keeping
        ; LIMON execution in bank 0.
        gst     ie,$2
        pst     ie,0
        pst     ua,$0
        slw
        ldd     $15,(iz+$sx)
        fst
        pst     ua,&H54
        pst     ie,$2
        cal     L7142
        cal     L7142
        rtn

; Display raw UA and probe address as uu:aaaa followed by a space.
LU5DSP:
        pre     ix,M0CEF
        ld      $16,(ix+$sx)
        ld      $19,$16
        did     $16
        cal     L7194
        cal     L3B50
        ld      $16,$19
        cal     L7194
        cal     L3B50
        ld      $16,&H3A
        cal     L3B50
        pre     ix,M0CF0
        ldw     $14,(ix+$sx)
        cal     L7168
        jp      L3B3E


; CS617-only entry adapter: do not jump through donor C_RESET vector.
LIMON_ENTRY:
        PRE     SS,&H1298
        PRE     US,&H1099
        PST     UA,&H14
        JP      MONITOR

; Guard failure route for E; only RAM1:2E00..2E01 is writable in
; integration. Read-only B/D/Q/U command functions remain donor-complete.
LM_WRITE_DENIED:
        PST     UA,&H54
        LD      $16,&H57
        CAL     L3B50
        LD      $16,&H52
        CAL     L3B50
        LD      $16,&H49
        CAL     L3B50
        LD      $16,&H54
        CAL     L3B50
        LD      $16,&H45
        CAL     L3B50
        CAL     L3B3E
        LD      $16,&H50
        CAL     L3B50
        LD      $16,&H52
        CAL     L3B50
        LD      $16,&H4F
        CAL     L3B50
        LD      $16,&H54
        CAL     L3B50
        LD      $16,&H45
        CAL     L3B50
        LD      $16,&H43
        CAL     L3B50
        LD      $16,&H54
        CAL     L3B50
        LD      $16,&H45
        CAL     L3B50
        LD      $16,&H44
        CAL     L3B50
        CAL     L3B47
        JP      L6F40

; ======================================================================
; CH08 r010f: integrated limon keyboard boundary, NOT donor original.
; Prior limon direct CAL R0460 entered BOOT-ROM CRTKY without the
; launcher/Keystone raw-key readiness gate or a C-ROM selector bridge.
; Keep donor R035A/R035E keyboard pre/post behavior unchanged.
; This local scanner (unlike launcher CH08_RAWREADY) routes BRK COLD.
; CRITICAL: no OFFCHK/BRSTR in idle scan.
; ======================================================================
LM_CRTKY:
LM_SCAN_AGAIN:
        JP      LM_NORMAL_KEY       ; r015: CRTKY owns idle wait/blink
LM_SCAN_COLUMN:
        PST     IA,$0
        GRE     KY,$1
        GRE     KY,$1
        DID     $2
        ANCW    $1,$1
        JR      NZ,LM_SCAN_FOUND
        SB      $0,$30
        JR      LNZ,LM_SCAN_COLUMN
        JR      LM_SCAN_AGAIN
LM_SCAN_FOUND:
        SBC     $0,&H41
        JR      NZ,LM_NORMAL_KEY
LM_BRK_RELEASE:
        LD      $0,&H41
        PST     IA,$0
        GRE     KY,$1
        GRE     KY,$1
        DID     $2
        ANCW    $1,$1
        JR      NZ,LM_BRK_RELEASE
        JP      CH08_COLD       ; LIMON BRK is not launcher WARM
LM_NORMAL_KEY:
        LDW     $28,CRTKY
        CAL     SYSCAL          ; temporary ROM1 selection; restores ROM2
        PST     UA,&H54        ; restore limon monitor's UA context
        RTN