view disk.s @ 1:704b2c9dc19e default tip

Remove extraneous unused and incorrect definition
author William Astle <lost@l-w.ca>
date Wed, 02 Jan 2019 10:11:19 -0700
parents 605ff82c4618
children
line wrap: on
line source

                *pragma nolist
                include defs.s
; Various references to Color Basic and Extended Color Basic which are listed here to allow this ROM to be built independently.
XBWMST          equ 0x80c0
L813C           equ 0x813c
L8168           equ 0x8168
XVEC3           equ 0x8273
XVEC8           equ 0x8286
XVEC18          equ 0x829c
L8311           equ 0x8311
L8316           equ 0x8316
L836C           equ 0x836c
L8748           equ 0x8748
L880E           equ 0x880e
XVEC15          equ 0x8846
XVEC17          equ 0x88f0
L8955           equ 0x8955
L8C1B           equ 0x8c1b
XVEC4           equ 0x8cf1
XVEC9           equ 0x8e90
L95AC           equ 0x95ac
L962E           equ 0x962e
L9650           equ 0x9650
L96CB           equ 0x96cb
L96EC           equ 0x96ec
L975F           equ 0x975f
L9FB5           equ 0x9fb5
LA0E2           equ 0xa0e2
BAWMST          equ 0xa0e8
LA171           equ 0xa171
LA176           equ 0xa176
PUTCHR          equ 0xa282
LA35F           equ 0xa35f
LA37C           equ 0xa37c
LA3ED           equ 0xa3ed
LA3FB           equ 0xa3fb
LA406           equ 0xa406
LA426           equ 0xa426
LA429           equ 0xa429
LA42D           equ 0xa42d
LA549           equ 0xa549
LA59A           equ 0xa59a
LA5A2           equ 0xa5a2
LA5A5           equ 0xa5a5
LA5AE           equ 0xa5ae
LA5C7           equ 0xa5c7
LA5DA           equ 0xa5da
LA5E4           equ 0xa5e4
LA603           equ 0xa603
LA616           equ 0xa616
LA61C           equ 0xa61c
LA61F           equ 0xa61f
LA928           equ 0xa928
LA951           equ 0xa951
LA7D1           equ 0xa7d1
LA7E9           equ 0xa7e9
LA974           equ 0xa974
LAC37           equ 0xac37
LAC44           equ 0xac44
LAC46           equ 0xac46
LAC60           equ 0xac60
LAC73           equ 0xac73
LAC7C           equ 0xac7c
LACEF           equ 0xacef
LAD19           equ 0xad19
LAD21           equ 0xad21
LAD33           equ 0xad33
LAD9E           equ 0xad9e
LADC6           equ 0xadc6
LADD4           equ 0xadd4
LADEB           equ 0xadeb
LAE15           equ 0xae15
LAF9A           equ 0xaf9a
LAFA4           equ 0xafa4
LAFB1           equ 0xafb1
LB00C           equ 0xb00c
LB01E           equ 0xb01e
LB069           equ 0xb069
LB143           equ 0xb143
LB146           equ 0xb146
LB148           equ 0xb148
LB156           equ 0xb156
LB244           equ 0xb244
LB262           equ 0xb262
LB166           equ 0xb166
SYNCOMMA        equ 0xb26d
LB26F           equ 0xb26f
LB277           equ 0xb277
LB2CE           equ 0xb2ce
LB357           equ 0xb357
LB3E6           equ 0xb3e6
LB44A           equ 0xb44a
LB4F3           equ 0xb4f3
GIVABF          equ 0xb4f4
LB50F           equ 0xb50f
LB516           equ 0xb516
LB654           equ 0xb654
LB657           equ 0xb657
LB659           equ 0xb659
LB69B           equ 0xb69b
LB6A4           equ 0xb6a4
EVALEXPB        equ 0xb70b
LB70E           equ 0xb70e
LB738           equ 0xb738
LB73D           equ 0xb73d
LIST            equ 0xb764
LB958           equ 0xb958
LB95C           equ 0xb95c
STRINOUT        equ 0xb99c
LB99F           equ 0xb99f
LB9A2           equ 0xb9a2
LB9AC           equ 0xb9ac
LB9AF           equ 0xb9af
LB9C5           equ 0xb9c5
LBB91           equ 0xbb91
LBC14           equ 0xbc14
LBC33           equ 0xbc33
LBC35           equ 0xbc35
LBC5F           equ 0xbc5f
INT             equ 0xbcee
LBDCC           equ 0xbdcc
LBDD9           equ 0xbdd9
                pragma noexpandcond
                *pragma list
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; DISK EXTENDED COLOR BASIC
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                ifeq DISKVER
DHITOK          equ 0xe0                        ; highest command token
CYEAR           equ '1                          ; ones digit of copyright year
MINORVER        equ '0
                else
DHITOK          equ 0xe1                        ; highest command token
CYEAR           equ '2                          ; ones digit for copyright year
MINORVER        equ '1
                endc
                org DOSBAS
                fcc 'DK'                        ; magic number Extended Basic uses to identify the presence of a Disk ROM
LC002           bra LC00C                       ; entry point - jump around vector table
DCNVEC          fdb DSKCON                      ; DSKCON indirect entry point
DSKVAR          fdb DCOPC                       ; address of DSKCON parameter block
                ifeq DISKVER-1
DSINIT          fdb DOSINI                      ; vector to an initialization routine, the utility of which is unclear
DOSVEC          fdb DOSCOM                      ; pointer to the actual location of the DOS command
                endc
LC00C           ldx #DBUF0                      ; point to start of Disk Basic memory
LC00F           clr ,x+                         ; clear a byte
                cmpx #DFLBUF                    ; at end of statically allocated Disk Basic memory?
                bne LC00F                       ; brif not
                ldx #LC109                      ; point to initializer for the command interpretation table
                ldu #COMVEC+20                  ; point to command interpretation table location for Disk Basic
                ldb #10                         ; ten bytes in each table entry
                jsr LA59A                       ; initialize interpretation table
                ldd #LB277                      ; syntax error address
                std 3,u                         ; set command handler for "user" table to error
                std 8,u                         ; set function handler for "user" table to error
                clr ,u                          ; mark user table with 0 command keywords
                clr 5,u                         ; mark user table with 0 function keywords
                ldd #DXCVEC                     ; intercept Extended Basic's command handler
                std COMVEC+13
                ldd #DXIVEC                     ; intercept Extended Basic's function handler
                std COMVEC+18
                ldu #RVEC0                      ; point to first RAM vector
LC03B           lda #0x7e                       ; op code of JMP extended
                sta RVEC22                      ; set first byte of GET/PUT vector to JMP
                sta ,u+                         ; set this vector to be a JMP instruction
                ldd ,x++                        ; get vector destination
                std ,u++                        ; set the vector destination
                cmpx #LC139                     ; done the whole list?
                bne LC03B                       ; brif not
                ldx #DVEC22                     ; install handler for GET/PUT vector
                stx RVEC22+1
                ifeq DISKVER-1
                ldx #DVEC20                     ; install replacement interpretation loop handler
                stx RVEC20+1
                endc
                ldx #DUSRVC                     ; relocate USR vector table
                stx USRADR
                ldu #LB44A                      ; default USR address is illegal function call
                ldb #10                         ; there are 10 vectors
LC061           stu ,x++                        ; set a vector
                decb                            ; done all?
                bne LC061                       ; brif not
                ldx #DNMISV                     ; install NMI handler
                stx NMIVEC+1
                lda #0x7e                       ; make it a JMP
                sta NMIVEC
                ldx #DIRQSV                     ; install IRQ handler (ECB and CB already made it a JMP)
                stx IRQVEC+1
                lda #19                         ; initialze the number of changes needed to trigger a FAT write
                sta WFATVL
                clr FATBL0                      ; mark all four FAT images as having no open files
                clr FATBL1
                clr FATBL2
                clr FATBL3
                ldx #DFLBUF                     ; point to the start of the disk "heap"
                stx RNBFAD                      ; set start of random file buffers as the end of the allocated space
                leax 0x100,x                    ; allocate 256 bytes for random file buffers by default
                stx FCBADR                      ; save start of FCBs (and end of random file buffers)
                leax 1,x                        ; leave an empty byte before FCBs (why?)
                stx FCBV1                       ; set address of FCB 1
                clr <<FCBTYP,x                  ; mark it closed
                leax FCBLEN,x                   ; set address of FCB 2 (2 user FCBs allocated at startup)
                stx FCBV1+2
                clr <<FCBTYP,x                  ; mark it closed
                leax FCBLEN,x                   ; set address of FCB 3 (system FCB)
                stx FCBV1+4
                clr <<FCBTYP,x                  ; mark it closed
                lda #2                          ; set 2 active FCBs
                sta FCBACT
                leax FCBLEN,x                   ; point to end of active FCBs
                tfr x,d                         ; put it in D so we can do stuff with it
                tstb                            ; is it a partial memory page?
                ifeq DISKVER
                beq LC0C2                       ; brif not
                else
                beq LC0BD                       ; brif not
                endc
                inca                            ; round up
                ifeq DISKVER-1
LC0BD           bita #1                         ; is it even (multiple of 512)?
                beq LC0C2                       ; brif so
                inca                            ; round up to even 512 byte boundary
                endc
LC0C2           tfr a,b                         ; save start of graphics memory
                addb #24                        ; reserve 4 graphics pages
                stb TXTTAB                      ; set start of program there
                jsr L96EC                       ; do graphics initialization (A is the start of grahpics memory)
                lda BEGGRP                      ; get start of current grahpics page
                adda #6                         ; make one page used
                sta ENDGRP
                ifeq DISKVER-1
                jsr [DSINIT]                    ; do the pointless initialization routine
                endc
                bsr LC0F0                       ; initialize FDC stuff and interrupt any action underway
                andcc #0xaf                     ; enable interrupts
                ldx #LC139-1                    ; point to sign on message
                jsr STRINOUT                    ; show sign on
                ldx #DKWMST                     ; install warm start handler
                stx RSTVEC
                jmp LA0E2                       ; jump into mainline Color Basic
DKWMST          nop                             ; flag warm start routine as valid
                bsr LC0F0                       ; initialize FDC variables and interrupt any action underway
                jsr LD2D2                       ; close files and do some other stuff
                jmp XBWMST                      ; transfer control to ECB's warm start
LC0F0           clr NMIFLG                      ; reset the NMI handler vector
                clr RDYTMR                      ; disable the drive timeout counter
                clr DRGRAM                      ; turn off all drive selects and motors (RAM copy)
                clr DSKREG                      ; turn off all drive selects and motors (real hardware)
                lda #0xd0                       ; send "force interrupt" to controller
                sta FDCREG
                exg a,a                         ; wait for status to stabilize
                exg a,a
                lda FDCREG                      ; clear the status indicator (no error handling - nothing useful to do anyway)
                rts
                ifeq DISKVER
LC109           fcb 19                          ; number of keywords (commands)
                else
LC109           fcb 20                          ; number of keywords (commands)
                endc
                fdb LC192                       ; keyword table (commands)
                fdb LC238                       ; handler (commands)
                fcb 6                           ; number of keywords (functions)
                fdb LC219                       ; keyboard table (functions)
                fdb LC24E                       ; handler (functions)
LC113           fdb DVEC0,DVEC1,DVEC2           ; RAM hook handler addresses
                fdb DVEC3,DVEC4,DVEC5
                fdb DVEC6,DVEC7,DVEC8
                fdb XVEC9,DVEC10,DVEC11
                fdb DVEC12,DVEC13,DVEC14
                fdb DVEC15,DVEC12,DVEC17
                fdb DVEC18
; Sign on message
LC139           fcc 'DISK EXTENDED COLOR BASIC 1.'
                fcb MINORVER
                fcb 0x0d
                fcc 'COPYRIGHT (C) 198'
                fcb CYEAR
                fcc ' BY TANDY'
                fcb 0x0d
                fcc 'UNDER LICENSE FROM MICROSOFT'
                fcb 0x0d,0x0d,0x00
; Keyword list (commands)
LC192           fcs 'DIR'                       ; 0xce
                fcs 'DRIVE'                     ; 0xcf
                fcs 'FIELD'                     ; 0xd0
                fcs 'FILES'                     ; 0xd1
                fcs 'KILL'                      ; 0xd2
                fcs 'LOAD'                      ; 0xd3
                fcs 'LSET'                      ; 0xd4
                fcs 'MERGE'                     ; 0xd5
                fcs 'RENAME'                    ; 0xd6
                fcs 'RSET'                      ; 0xd7
                fcs 'SAVE'                      ; 0xd8
                fcs 'WRITE'                     ; 0xd9
                fcs 'VERIFY'                    ; 0xda
                fcs 'UNLOAD'                    ; 0xdb
                fcs 'DSKINI'                    ; 0xdc
                fcs 'BACKUP'                    ; 0xdd
                fcs 'COPY'                      ; 0xde
                fcs 'DSKI$'                     ; 0xdf
                fcs 'DSKO$'                     ; 0xe0
                ifeq DISKVER-1
                fcs 'DOS'                       ; 0xe1
                endc
; Jump table (commands)
LC1F1           fdb DIR                         ; 0xce DIR
                fdb DRIVE                       ; 0xcf DRIVE
                fdb FIELD                       ; 0xd0 FIELD
                fdb FILES                       ; 0xd1 FILES
                fdb KILL                        ; 0xd2 KILL
                fdb LOAD                        ; 0xd3 LOAD
                fdb LSET                        ; 0xd4 LSET
                fdb MERGE                       ; 0xd5 MERGE
                fdb RENAME                      ; 0xd6 RENAME
                fdb RSET                        ; 0xd7 RSET
                fdb SAVE                        ; 0xd8 SAVE
                fdb WRITE                       ; 0xd9 WRITE
                fdb VERIFY                      ; 0xda VERIFY
                fdb UNLOAD                      ; 0xdb UNLOAD
                fdb DSKINI                      ; 0xdc DSKINI
                fdb BACKUP                      ; 0xdd BACKUP
                fdb COPY                        ; 0xde COPY
                fdb DSKI                        ; 0xdf DSKI$
                fdb DSKO                        ; 0xe0 DSKO$
                ifeq DISKVER-1
                fdb DOS                         ; 0xe1 DOS
                endc
; Keyword list (functions)
LC219           fcs 'CVN'                       ; 0xa2
                fcs 'FREE'                      ; 0xa3
                fcs 'LOC'                       ; 0xa4
                fcs 'LOF'                       ; 0xa5
                fcs 'MKN$'                      ; 0xa6
                fcs 'AS'                        ; 0xa7 (here to avoid conflict with ASC)
; Jump table (functions)
LC22C           fdb CVN                         ; 0xa2 CVN
                fdb FREE                        ; 0xa3 FREE
                fdb LOC                         ; 0xa4 LOC
                fdb LOF                         ; 0xa5 LOF
                fdb MKN                         ; 0xa6 MKN$
                fdb LB277                       ; 0xa7 AS (not actually a function)
; Command handler
LC238           cmpa #DHITOK                    ; is it a Disk Basic valid command?
                bhi LC244                       ; brif not
                ldx #LC1F1                      ; point to jump table
                suba #0xce                      ; normalize Disk Basic tokens to 0
                jmp LADD4                       ; return to mainline to execute command
; The next two instructions are completely pointless. If we get here, the comparison has already
; been done and the branch condition is the exact opposite of what brought us here.
LC244           cmpa #DHITOK                    ; is it a Disk Basic token?
                lbls LB277                      ; brif not
                jmp [COMVEC+33]                 ; transfer control to user command handler
; Function handler
LC24E           cmpb #(0xa7-0x80)*2             ; is it a Disk Basic function token?
                bls LC256                       ; brif so
                jmp [COMVEC+38]                 ; transfer control to user handler if not
LC256           subb #(0xa2-0x80)*2             ; normalize Disk Basic tokens to 0
                pshs b                          ; save jump table offset
                jsr LB262                       ; evaluate parenthetical expression
                puls b                          ; get back jump table offset
                ldx #LC22C                      ; point to jump table
                jmp LB2CE                       ; rejoin mainline code to transfer control
; Error handler
DVEC17          puls y                          ; get back original caller
                jsr LAD33                       ; reset some stuff like CONT
                jsr LD2D2                       ; clean up some Disk Basic stuff
                pshs y,b                        ; put return address back and save error code
                jsr DVEC7                       ; close all files
                puls b                          ; get back error code
                cmpb #2*27                      ; is it a Disk Basic error code?
                lblo XVEC17                     ; brif not - pass it to Extended Basic
                leas 2,s                        ; dump the return address
                jsr LA7E9                       ; stop tape
                jsr LA974                       ; stop sound
                clr DEVNUM                      ; reset output to screen
                jsr LB95C                       ; do a newline
                jsr LB9AF                       ; do a ?
                ldx #LC290-2*27                 ; point to error message table
                jmp LAC60                       ; rejoin mainline error handler
; Error strings (note that NE error is provided by Extended Basic)
LC290           fcc 'BR'                        ; 27 Bad record
                fcc 'DF'                        ; 28 Disk full
                fcc 'OB'                        ; 29 Out of buffer space
                fcc 'WP'                        ; 30 Write protected
                fcc 'FN'                        ; 31 Bad file name
                fcc 'FS'                        ; 32 Bad file structure
                fcc 'AE'                        ; 33 File already exists
                fcc 'FO'                        ; 34 Field overflow
                fcc 'SE'                        ; 35 Set to non-fielded string
                fcc 'VF'                        ; 36 Verify error
                fcc 'ER'                        ; 37 Input or write past end of record
BASEXT          fcc 'BAS'                       ; default Basic program file extension
DEFEXT          fcc '   '                       ; default blank extension (three spaces)
DATEXT          fcc 'DAT'                       ; default extension for data files
BINEXT          fcc 'BIN'                       ; default extension for binary files
; "CLS" vector handler. Extended Basic also chose to use this vector as a way to hook into
; the GET/PUT commands, the RENUM token check, and the Extended Basic "functions as commands"
; interpretation scheme. Only the GET/PUT hook is used. Checking the caller address is hacky
; but unavoidable here.
DVEC22          pshs x,cc                       ; save scratch register and flags
                ldx 3,s                         ; get caller address
                cmpx #L975F                     ; is it coming from GET/PUT?
                bne LC2BF                       ; brif not
                cmpa #'#                        ; is it GET # or PUT # (disk file operations)?
                beq LC2C1                       ; brif so - don't return to mainline
LC2BF           puls cc,x,pc                    ; restore scratch register, flags, and return to mainline
; GET/PUT handler for random file access
LC2C1           leas 5,s                        ; remove saved state from above and don't return to mainline
                jsr LC82E                       ; evaluate device number and get FCB pointer
                stx FCBTMP                      ; save the FCB pointer
                clr FCBGET,x                    ; reset the get data pointer
                clr FCBGET+1,x
                clr FCBPUT,x                    ; reset the put data pointer
                clr FCBPUT+1,x
                clr FCBPOS,x                    ; reset print position
                lda FCBDRV,x                    ; get drive number for the file
                sta DCDRV                       ; set it as the DSKCON drive number
                jsr GETCCH                      ; end of statement?
                beq LC2EA                       ; brif so - use current record
                jsr SYNCOMMA                    ; insist on a comma
                ifeq DISKVER
                jsr LB3E6                       ; evaluate expression to D
                else
                jsr LB73D                       ; get unsigned 16 bit number to X
                tfr x,d                         ; stash it in D so we can use X as a pointer
                endc
LC2E6           ldx FCBTMP                      ; get back FCB pointer
                std FCBREC,x                    ; set the current record number
                ifeq DISKVER
LC2EA           jsr LC685                       ; bump record number
                else
LC2EA           ldd FCBREC,x                    ; get desired record number
                beq LC30B                       ; brif 0 - records start at 1
                jsr LC685                       ; bump record number
                endc
                ldd FCBRLN,x                    ; get record length
                ldx FCBBUF,x                    ; point to FCB data buffer
                pshs x,b,a                      ; save them
                leax -2,u                       ; point to record number (but zero based)
                jsr L9FB5                       ; do unsigned multiply of record length and record number
                pshs u,y                        ; save product (this is the file offset to the record)
                lda ,s+                         ; is MSB 0?
                bne LC30B                       ; brif not - record number too big
                puls x                          ; middle two bytes are sector number in file - retrieve it
                puls b                          ; LSB is offset into the sector - retrieve it
LC306           cmpx #(35-1)*18                 ; is it more than the maximum number of sectors a file can have?
                blo LC310                       ; brif so
LC30B           ldb #2*27                       ; code for bad record
                jmp LAC46                       ; raise error
LC310           ldu FCBTMP                      ; get pointer to FCB
                cmpx FCBSOF,u                   ; is it the same sector we're already handling?
                lbeq LC3CF                      ; brif so
                pshs x,b                        ; save sector number and sector offset
                lda FCBFLG,u                    ; were we doing get or put?
                beq LC324                       ; brif we were doing get
                clr FCBFLG,u                    ; flag doing get
                ldb #3                          ; write operation code for DSKCON
                bsr LC357                       ; write the sector data
LC324           ldd 1,s                         ; get sector number
                jsr LC784                       ; convert to a granule offset
                pshs b                          ; save granule offset
                jsr LC779                       ; calculate starting sector of granule number
                negb                            ; make negative
                addb 3,s                        ; add LS byte of sector number
                incb                            ; add one - sectors in FCB start at 1
                stb FCBSEC,u                    ; set sector
                ldb FCBFGR,u                    ; get first granule in file
                jsr LC755                       ; fetch FAT pointer
                leau FATCON,x                   ; point to actual granule table
                lda ,s                          ; get number of granules offset to the record
                inca                            ; bump it (compensate for deca below)
LC33E           leax ,u                         ; point X to entry for this granule
                abx
                deca                            ; are we at the correct one?
                beq LC37B                       ; bif not
                stb ,s                          ; save granule offset on stack
                ldb ,x                          ; get next granule in file
                cmpb #0xc0                      ; is it "end of file" flag?
                blo LC33E                       ; brif not
                ldb ,s                          ; get offset to previous granule
                tst VD8                         ; get or put?
                bne LC366                       ; brif put
LC352           ldb #2*23                       ; code for input past end of file
                jmp LAC46                       ; raise error
LC357           leax FCBCON,u                   ; point to data buffer for FCB
LC35A           stb DCOPC                       ; set operation code for DSKCON
                stx DCBPT                       ; set buffer pointer for DSKCON
                leax ,u                         ; point to FCB
                jsr LC763                       ; convert FCB track and sector to DSKCON parameters
                jmp LD6F2                       ; read or write the sector
LC366           pshs x,a                        ; save granule counter and pointer to last used granule
                jsr LC7BF                       ; find a free granule
                tfr a,b                         ; save allocated granule
                puls a,u                        ; get last granule pointer and counter off stack
                stb ,u                          ; add it to the file's granule chain
                deca                            ; do we have enough of them?
                bne LC366                       ; brif not - allocate another
                pshs x,b                        ; save alocated granule and pointer
                jsr LC71E                       ; write the FAT out
                puls b,x                        ; get back allocated granule and pointer
LC37B           leas 1,s                        ; remove granule number
                ldu FCBTMP                      ; point to FCB
                stb FCBCGR,u                    ; save current granule
                lda #0xff                       ; set to illegal sector offset to force sector data to be read
                sta FCBSOF,u
                lda ,x                          ; get next granule pointer
                cmpa #0xc0                      ; last granule?
                blo LC3B2                       ; brif not
                anda #0x3f                      ; get only the number of sectors used
                cmpa FCBSEC,u                   ; compare calculated sector to current sector
                bhs LC3B2                       ; brif sector is <= last one in file
                lda VD8                         ; GET or PUT?
                beq LC352                       ; brif GET - do IE error
                lda FCBSEC,u                    ; get sector number from FCB
                ora #0xc0                       ; add "last granule" flag bits
                sta ,x                          ; update FAT
                jsr LC5A9                       ; write FAT if needed
                ldx FCBRLN,u                    ; get record length
                cmpx #SECLEN                    ; exactly one sector?
                bne LC3AD                       ; brif not
                cmpx FCBLST,u                   ; is number of bytes in last sector a full sector?
                beq LC3B2                       ; brif so
                lda #0x81                       ; set "presaved" flag and force number of bytes to be 256
                skip1                           ; skip next byte ("BRN")
LC3AD           clra                            ; set number of bytes in last sector to 0
                clrb                            ; clear LS byte of D
                std FCBLST,u                    ; set number of bytes used in last sector
LC3B2           ldb #2                          ; DSKCON read operation
                ldx FCBRLN,u                    ; get record length
                cmpx #SECLEN                    ; exactly one sector?
                bne LC3C8                       ; brif not exactly
                leas 7,s                        ; clean up stack
                ldx FCBBUF,u                    ; point to start of random file buffer
                lda VD8                         ; is it GET or PUT?
                beq LC3C5                       ; brif GET
                ldb #3                          ; DSKCON write opreation
LC3C5           jmp LC35A                       ; go read or write a sector
LC3C8           jsr LC357                       ; read a sector into data buffer
                puls b,x                        ; get back byte offset to record
                stx FCBSOF,u                    ; save sector offset
LC3CF           pshs b                          ; save sector byte offset
                jsr LC755                       ; point to FAT
                leax FATCON,x                   ; point to FAT data
                ldb FCBCGR,u                    ; get current granulenumber
                abx                             ; point to granule data
                lda ,x                          ; get this granule's next pointer
                cmpa #0xc0                      ; end of file flag?
                blo LC40A                       ; brif not
                anda #0x3f                      ; convert to number of sectors in final granule
                cmpa FCBSEC,u                   ; are we asking for the last sector?
                bne LC40A                       ; brif not
                ldd FCBLST,u                    ; get number of bytes in last sector
                anda #0x7f                      ; lose pre-saved flag
                pshs d                          ; save number of bytes in last sector
                clra                            ; zero extend byte offset
                ldb 2,s                         ; get byte offset
                addd 3,s                        ; add in record length
                cmpd ,s++                       ; is it more than last sector?
                bls LC40A                       ; brif the whole record fits
                tst VD8                         ; is it GET?
                lbeq LC352                      ; brif so - IE error if file doesn't have a whole record available
                ifeq DISKVER
                anda #1                         ; keep only bit 0 of byte count
                ora #0x80                       ; set pre-saved flag bit
                else
                cmpd #SECLEN                    ; is it a whole sector we need?
                bls LC405                       ; brif not
                ldd #SECLEN                     ; force one sector length
LC405           ora #0x80                       ; set pre-saved flag bit
                endc
                std FCBLST,u                    ; save number of bytes in last sector
LC40A           puls b                          ; get byte offset
                leax FCBCON,u                   ; point to data buffer
                abx                             ; offset into data buffer
                ldu 2,s                         ; point to position in random file buffer
                pshs b                          ; save byte offset
                lda #-1                         ; convert D into a negative 2 byte number representing unused bytes in sector
                addd 1,s
                bhs LC421                       ; brif there are enough bytes to finish record
                std 1,s                         ; save new temporary record length counter
                puls b                          ; restore byte counter
                negb                            ; negate it (B is number of bytes available to a record in this sector)
                bra LC429                       ; move the data
LC421           ldb 2,s                         ; get remaining record length
                clr 1,s                         ; clear the temporary record length counter
                clr 2,s
                leas 1,s                        ; we no longer need byte offset
LC429           lda VD8                         ; GET?
                beq LC42F                       ; brif so
                exg x,u                         ; swap pointers so we write to data buffer
LC42F           jsr LA59A                       ; copy data
                stu 2,s                         ; save new record pointer
                ldu FCBTMP                      ; get pointer to FCB
                lda VD8                         ; GET?
                beq LC43E                       ; brif so
                sta FCBFLG,u                    ; flag as PUT
                stx 2,s                         ; save buffer pointer
LC43E           ldx FCBSOF,u                    ; get sector offset count
                leax 1,x                        ; bump it
                clrb                            ; byte offset in this new sector is 0
                ldu ,s                          ; get length of record needed
                lbne LC306                      ; brif not already completed ar ecord
                puls a,b,x,pc                   ; clean up stack and return
; OPEN handler
DVEC0           leas 2,s                        ; don't return mainline
                jsr LB156                       ; evaluate mode expression
                jsr LB6A4                       ; get first character in the mode string
                pshs b                          ; save it
                jsr LA5A2                       ; parse device number
                tstb                            ; disk file?
                lble LA603                      ; return mainline if not disk file
                puls a                          ; get mode
                pshs a,b                        ; save mode and file number
                clr DEVNUM                      ; reset device to screen
                jsr SYNCOMMA                    ; insist on a comma
                ldx #DATEXT                     ; point to "DAT" extension as default for data file
                jsr LC938                       ; parse file name
                ldd #0x01ff                     ; file type is "data" (1) and ASCII
                std DFLTYP                      ; save file type
                ldx #SECLEN                     ; default record length - one whole sector
                jsr GETCCH                      ; is there a record length specifier?
                beq LC481                       ; brif not
                jsr SYNCOMMA                    ; insist on comma
                jsr LB3E6                       ; evaluate record length
                ldx FPA0+2                      ; get evaluated length
LC481           stx DFFLEN
                lbeq LB44A                      ; record length of 0 makes no sense of error if so
                jsr LA5C7                       ; raise error if more stuff
                puls a,b                        ; get mode and fil enumber
LC48D           pshs a                          ; save mode
                jsr LC749                       ; point to FCB for this file
                lbne LA61C                      ; brif the file is already open
                stx FCBTMP                      ; save FCB pointer
                jsr LC79D                       ; make sure FAT is valid
                jsr LC68C                       ; search for requested file
                puls b                          ; get mode
                lda #INPFIL                     ; input file flag
                pshs a                          ; save it
                cmpb #'I                        ; input mode?
                bne LC4C7                       ; brif not
                jsr LC6E5                       ; see if match was found
                jsr LC807                       ; check if it's already open
                ldx V974                        ; point to directory data
                ldd DIRTYP,x                    ; get file type and ASCII flag
                std DFLTYP                      ; save it
                bsr LC52D                       ; initialize FCB
                jsr LC627                       ; go read first sector from file
LC4BB           jsr LC755                       ; point to FAT
                inc <<FAT0,x                    ; bump number of open files on this disk
                ldx FCBTMP                      ; get back FCB pointer
                puls a                          ; get file type
                sta <<FCBTYP,x                  ; save file type
                rts
LC4C7           asl ,s                          ; set type to output
                cmpb #'O                        ; output requested?
                bne LC4E8                       ; brif not
                tst V973                        ; did file exist?
                beq LC4E1                       ; brif not
                jsr LC6FC                       ; kill the old file
                lda V973                        ; get directory sector number of old file
                sta V977                        ; save as first free directory entry
                ldx V974                        ; get directory image of old file
                stx V978                        ; asve it as first free entry
                ifeq DISKVER
LC4E1           bsr LC567                       ; set up new directory entry on disk
                else
LC4E1           jsr LC567                       ; set up new directory entry on disk
                endc
                bsr LC538                       ; initialize the file buffer
                bra LC4BB                       ; finish setting up FCB
LC4E8           cmpb #'R                        ; random file?
                beq LC4F2                       ; brif so
                cmpb #'D                        ; direct file?
                lbne LA616                      ; brif not - bad file mode
LC4F2           asl ,s                          ; set file type to random
                ldd RNBFAD                      ; get address of random file buffer area
                pshs d                          ; save it
                addd DFFLEN                     ; add in record length
                bcs LC504                       ; brif we overflowed memory
                cmpd FCBADR                     ; is it more than FCB data area?
                bls LC509                       ; brif not
LC504           ldb #2*29                       ; code for out of buffer space
                jmp LAC46                       ; raise error
LC509           pshs d                          ; save new end of buffer area
                tst V973                        ; did the file exist?
                bne LC514                       ; brif so
                bsr LC567                       ; set up directory
                ifeq DISKVER
LC514           bsr LC52D                       ; inistialize FCB
                else
                bra LC519                       ; initialize FCB
LC514           lda #0xff                       ; set file type match = 0xff (all types)
                jsr LC807                       ; see if any open file matches and AO error if so
LC519           bsr LC52D                       ; initialize FCB
                endc
                com FCBSOF,x                    ; set FCBSOF to 0xff (illegal offset) to force new sector to be read
                inc FCBREC+1,x                  ; set record number to 1
                puls a,b,u                      ; D = end of buffer, U = start of buffer
                std RNBFAD                      ; save start of free buffer space
                stu FCBBUF,x                    ; save buffer pointer in FCB
                ldu DFFLEN                      ; get record length
                stu FCBRLN,x                    ; save in FCB
                bra LC4BB                       ; finish setting things up
LC52D           bsr LC538                       ; initialize FCB
                ldu V974                        ; get directory image
                ldu DIRLST,u                    ; get number of bytes in last sector
                stu FCBLST,x                    ; save it
                rts
LC538           ldx FCBTMP                      ; get FCB pointer
                ldb #FCBCON                     ; number of control bytes
LC53C           clr ,x+                         ; clear a control byte
                decb                            ; done all?
                bne LC53C                       ; brif not
                ldx FCBTMP                      ; get back FCB pointer
                lda DCDRV                       ; set drive number
                sta FCBDRV,x
                lda V976                        ; get first granule
                sta FCBFGR,x                    ; save it in FCB
                sta FCBCGR,x                    ; also set as current granule
                ldb V973                        ; get directory sector offset
                subb #3                         ; directory sectors start at 3
                aslb                            ; 8 directory entries per sector
                aslb
                aslb
                pshs b                          ; save sector offset
                ldd V974                        ; get directory pointer
                subd #DBUF0                     ; calculate offset in sector buffer
                lda #8                          ; 8 directory entries per sector
                mul                             ; now A contains 0 to 7
                adda ,s+                        ; add to directory sector offset
                sta FCBDIR,x                    ; save directory entry number in FCB
                rts
LC567           ldb #28*2                       ; code for disk full
                lda V977                        ; get sector number of first empty entry
                lbeq LAC46                      ; brif none found
                sta V973                        ; save sector number of first entry
                sta DSEC                        ; set DSKCON sector parameter
                ldb #2                          ; DSKCON read operation
                stb DCOPC
                jsr LD6F2                       ; read sector
                ldx V978                        ; get address of RAM image of unused directory
                stx V974                        ; save as current entry
                leau ,x                         ; point to directory image
                ldb #DIRLEN                     ; set counter to clear the entry
LC586           clr ,x+                         ; clear a byte
                decb                            ; done all?
                bne LC586                       ; brif not
                ldx #DNAMBF                     ; point to file name
                ldb #11                         ; 8.3 total number of characters
                jsr LA59A                       ; copy file name into directory
                ldd DFLTYP                      ; get file type and ASCII flag
                std <<0,u                       ; save in directory
                ldb #33                         ; first granule to check
                jsr LC7BF                       ; find first gree granule
                sta V976                        ; save granule found
                sta 2,u                         ; save as first granule in file
                ldb #3                          ; DSKCON write operation
                stb DCOPC
                jsr LD6F2                       ; write out directory entry
LC5A9           pshs u,x,b,a                    ; save registers
                jsr LC755                       ; point to FAT
                inc FAT1,x                      ; mark FAT as changed
                lda FAT1,x                      ; have enough things changed?
                cmpa WFATVL
                blo LC5BA                       ; brif not
                jsr LC71E                       ; write FAT out
LC5BA           puls a,b,x,u,pc                 ; restore registers and return
; Generic input handler
DVEC4           lda DEVNUM                      ; get device number
                lble XVEC4                      ; brif not disk file
                leas 2,s                        ; don't return mainline if disk
LC5C4           pshs x,b                        ; save registers
                clr CINBFL                      ; clear EOF flag
                ldx #FCBV1-2                    ; point to input file buffer table (-2 here to avoid decrementing device)
                ldb DEVNUM                      ; get device number
                aslb                            ; two bytes per pointer
                ldx b,x                         ; get pointer to FCB
                ldb FCBTYP,x                    ; get type of file
                cmpb #RANFIL                    ; random file?
                bne LC5EC                       ; brif not
                ldd FCBGET,x                    ; get record counter
                cmpd FCBRLN,x                   ; compare to size of record
                bhs LC5FE                       ; brif pointer is after end of record - handle empty buffer
                addd #1                         ; move pointer forward
                std FCBGET,x                    ; save new read pointer
                ldx FCBBUF,x                    ; point to data buffer
                leax d,x                        ; offset to buffer location
                lda -1,x                        ; get the character (before the increment)
                puls b,x,pc                     ; return the character from the record
LC5EC           ldb FCBCFL,x                    ; has a character been "ungot"?
                beq LC5F9                       ; brif not
                lda FCBCDT,x                    ; get ungot character
                clr FCBCFL,x                    ; clear ungot flag
                puls b,x,pc                     ; restore registers and return
LC5F9           ldb FCBDFL,x                    ; is there any data left to read?
                beq LC602                       ; brif so
LC5FE           com CINBFL                      ; flag EOF
                puls b,x,pc                     ; restore registers and return
LC602           ldb FCBCPT,x                    ; get character pointer
                inc FCBCPT,x                    ; bump saved pointer
                dec FCBLFT,x                    ; anything left?
                beq LC611                       ; brif buffer is empty
                abx                             ; add offset into buffer
                lda FCBCON,x                    ; get actual character (offset over the FCB control structure)
                puls b,x,pc                     ; restore registers and return
LC611           pshs u,y                        ; save register
                clra                            ; zero extend offset
                leau d,x                        ; now U has buffer offset
                lda FCBCON,u                    ; get character to return (offset over FCB control structure)
                pshs a                          ; save return value
                clr FCBCPT,x                    ; reset character pointer
                lda FCBDRV,x                    ; set DSKCON to the correct drive
                sta DCDRV
                bsr LC627                       ; read a sector
                puls a,y,u                      ; restore registers and get back return value
                puls b,x,pc                     ; restore registers and return
LC627           lda FCBSEC,x                    ; get current sector number
LC629           inca                            ; bump sector counter
                pshs a                          ; save sector counter for later
                cmpa #9                         ; end of granule?
                bls LC631                       ; brif not
                clra                            ; reset granule sector offset
LC631           sta FCBSEC,x                    ; save sector offset
                ldb FCBCGR,x                    ; get granule number
                leau ,x                         ; save FCB pointer
                jsr LC755                       ; point to correct FAT image
                abx                             ; now X points to granule data
                ldb FATCON,x                    ; get next granule pointer (offset past control data structure)
                leax ,u                         ; reset FCB pointer
                cmpb #0xc0                      ; is the current granule the last one?
                bhs LC64D                       ; brif so
                puls a                          ; get sector number
                suba #10                        ; did it overflow the granule?
                bne LC65E                       ; brif not
                stb FCBCGR,x                    ; save new granule number
                bra LC629                       ; set variables for new granule
LC64D           andb #0x3f                      ; get number of sectors in the granule
                cmpb #9                         ; is it more than a granule has?
                bls LC658                       ; brif not
LC653           ldb #2*32                       ; code for bad file structure
                jmp LAC46                       ; raise error
LC658           subb ,s+                        ; subtract current sector number and also clean stack
                bcs LC67D                       ; brif past last sector
                tfr b,a
LC65E           pshs a                          ; save sector number difference
                bsr LC685                       ; bump record number
                lda #2                          ; set up for read
                sta DCOPC
                jsr LC763                       ; set DSKCON variables for correct track and sector
                leau FCBCON,x                   ; point past control structure to actual buffer
                stu DCBPT                       ; set read destination
                jsr LD6F2                       ; go ahead and read the sector
                clr FCBLFT,x                    ; set buffer left to full sector
                ldb ,s+                         ; get sector number back
                bne LC684                       ; brif not last sector
                ldd FCBLST,x                    ; get bytes in last sector
                bne LC681                       ; brif bytes in last sector is nonzero
LC67D           clrb                            ; set remaining bytes to 256
                com FCBDFL,x                    ; flag buffer empty
LC681           stb FCBLFT,x                    ; save number of bytes in buffer
LC684           rts
LC685           ldu FCBREC,x                    ; get current record number
                leau 1,u                        ; bump it
                stu FCBREC,x                    ; save new record number
                rts
; Scan directory for file name; return sector number in V973, granule in V976,
; and pointer to directory data in V974. If disk is full, pointer in V978,
; and first unused sector in V977 (and V973 is 0)
LC68C           clr V973                        ; clear sector number (for not found)
                clr V977                        ; clear temp sector number
                ldd #0x1102                     ; set up to read track 17
                sta DCTRK
                stb DCOPC
                ldb #3                          ; start with sector 3
LC69B           stb DSEC                        ; set DSKCON sector
                ldu #DBUF0                      ; read to global buffer
                stu DCBPT
                jsr LD6F2                       ; read directory sector
LC6A5           stu V974                        ; set pointer to directory entry data
                leay ,u                         ; save start of directory entry
                lda ,u                          ; NUL (for a deleted entry)?
                bne LC6D6                       ; brif not
                bsr LC6D9                       ; set unused pointers
LC6B0           ldx #DNAMBF                     ; point to desired file name
LC6B3           lda ,x+                         ; does a character match?
                cmpa ,u+
                bne LC6C7                       ; brif not
                cmpx #DNAMBF+11                 ; end of file name?
                bne LC6B3                       ; brif not
                stb V973                        ; save sector number for match
                lda FCBFGR,u                    ; set first granule in file
                sta V976
                rts
LC6C7           leau DIRLEN,y                   ; point to next directory entry
                cmpu #DBUF0+SECLEN              ; end of sector?
                bne LC6A5                       ; brif not - search another
                incb                            ; move to next sector
                cmpb #11                        ; 11 sectors in directory - checked all of them?
                bls LC69B                       ; brif more sectors
                rts
LC6D6           coma                            ; is first byte of file name 0xff?
                bne LC6B0                       ; brif not - actually do a search
LC6D9           lda V977                        ; have we already found an unused entry?
                bne DVEC12                      ; brif so
                stb V977                        ; save sector number for unused entry
                stu V978                        ; save pointer to unused entry
DVEC12          rts                             ; NOTE: this is used as a dummy do-nothing RAM hook handler
LC6E5           ldb #2*26                       ; code for NE error
                tst V973                        ; was entry found?
                bne DVEC12                      ; brif so
                jmp LAC46                       ; raise error
; KILL command
KILL            jsr LC935                       ; parse file name
                jsr LA5C7                       ; brif something after file name
                jsr LC79D                       ; load FAT data
                bsr LC68C                       ; look up file
                bsr LC6E5                       ; raise error if not found
LC6FC           lda #0xff                       ; file type to match (all types)
                jsr LC807                       ; find any file that matches type
                ldx V974                        ; get directory entry pointer
                clr ,x                          ; mark it as unused
                ldb #3                          ; set up to write
                stb DCOPC
                jsr LD6F2                       ; write out the updated directory sector
                ldb DIRGRN,x                    ; get starting granule of file
LC70F           bsr LC755                       ; point to correct FAT
                leax FATCON,x                   ; skip control structure
                abx                             ; now X points to next granule
                ldb ,x                          ; get next granule pointer
                lda #0xff                       ; mark granule free
                sta ,x
                cmpb #0xc0                      ; was it last one?
                blo LC70F                       ; brif not
; Write FAT to drive
LC71E           ldu #DBUF0                      ; point to global sector buffer
                stu DCBPT                       ; point DSKCON there
                ldd #0x1103                     ; set up to write track 17
                sta DCTRK
                stb DCOPC
                ldb #2                          ; FAT is in sector 2
                stb DSEC
                bsr LC755                       ; point to proper FAT entry
                clr FAT1,x                      ; mark FAT as having no outstanding changes
                leax FATCON,x                   ; move past control structure
                ldb #GRANMX                     ; get total granule count in a FAT
                jsr LA59A                       ; copy the FAT data to buffer
                ifeq DISKVER
LC739           clr ,x+                         ; clear a byte
                cmpx #DBUF0+SECLEN              ; end of sector?
                else
LC739           clr ,u+                         ; clear out the rest of the sector (to avoid junk going into it)
                cmpu #DBUF0+SECLEN              ; end of sector?
                endc
                ifeq DISKVER-1
                bne LC739                       ; brif not
                endc
                jmp LD6F2                       ; go write the FAT sector out
; Point X to the correct FCB based on DEVNUM (or B if entering at LC749)
LC744           pshs b                          ; save register
                ldb DEVNUM                      ; get device number
                skip2
LC749           pshs b                          ; save register
                lslb                            ; two bytes per pointer
                ldx #FCBV1-2                    ; point to FCB table (-2 to adjust for 1-based file numbers)
                ldx b,x                         ; get pointer
                ldb <<FCBTYP,x                  ; set flags for file type
                puls b,pc                       ; restore register and return
; Point X to FAT image for the selected drive
LC755           pshs b,a                        ; save registers
                lda DCDRV                       ; get drive number
                ldb #FATLEN                     ; get size of FAT mirror
                mul                             ; calculate offset from first FAT image
                ldx #FATBL0                     ; point to first FAT image
                leax d,x                        ; offset to correct one
                puls a,b,pc                     ; restore registers and return
; Set up DSKCON variables to point to the correct sector and track for the current file position
LC763           ldb FCBCGR,x                    ; get granule number
                lsrb                            ; two granules per track
                stb DCTRK                       ; save track
                cmpb #17                        ; is it below the directory?
                blo LC76E                       ; brif so
                inc DCTRK                       ; skip directory track if not
LC76E           aslb                            ; double track number
                negb                            ; subtract from actual granule number: -(TRK*2)+CGR
                addb FCBCGR,x
                bsr LC779                       ; set B=9 for odd granule, B=0 for even
                addb FCBSEC,x                   ; add granule sector offset
                stb DSEC                        ; set DSKCON sector
                rts
LC779           pshs b,a                        ; temp store original
                aslb                            ; times 2
                rola
                aslb                            ; times 4
                rola
                aslb                            ; times 8
                rola
                addd ,s++                       ; times 9
                rts
; Convert sector offset in D to a granule offset (0-67) in B (lose fractional part)
LC784           clr ,-s                         ; make a temporary counter
LC786           inc ,s                          ; bump division counter
                subd #90                        ; does 90 go?
                bpl LC786                       ; brif so
                lda ,s                          ; get quotient (+1)
                stb ,s                          ; save remainder (negative)
                ldb #10                         ; multiply result by 10 (we divided by 90)
                mul
                puls a                          ; get back remainder
LC796           decb                            ; decrement granule count
                adda #9                         ; have we used up the remainder?
                bmi LC796                       ; brif not
                clra                            ; zero extend result
LC79C           rts
; Make sure FAT data is valid
LC79D           bsr LC755                       ; point to correct FAT
                tst <<FAT0,x                    ; any open files?
                bne LC79C                       ; brif so
                clr FAT1,x                      ; reset change count
                leau FATCON,x                   ; point past control structure
                ldx #DBUF0                      ; point DSKCON to sector buffer
                stx DCBPT
                ldd #0x1102                     ; read track 17
                sta DCTRK
                stb DCOPC
                ldb #2                          ; read sector 2 (FAT)
                stb DSEC
                jsr LD6F2                       ; go read FAT
                ldb #GRANMX                     ; get total FAT data size
                jmp LA59A                       ; copy FAT data from sector buffer to FAT image
; Find free granule; enter with B containing the start location; mark granule with 0xc0 in the
; FAT to indicate last granule in file. Return granule number in A
LC7BF           bsr LC755                       ; get pointer to FAT
                leax FATCON,x                   ; move past controls structure
                clra                            ; reset granule counter
                andb #0xfe                      ; start at first granule on track
                clr ,-s                         ; initialize direction counter to down
LC7C8           com b,x                         ; is this granule free
                beq LC7FD                       ; brif so
                com b,x                         ; restore granule data
                inca                            ; bump counter
                cmpa #GRANMX                    ; searched whole FAT?
                bhs LC7F8                       ; brif so - disk full
                incb                            ; bump granule counter
                bitb #1                         ; odd?
                bne LC7C8                       ; brif so
                pshs b,a                        ; save granule counter and current granule
                subb #2                         ; move back one track
                com 2,s                         ; flip direction
                bne LC7EC                       ; brif we're switching to "up"
                subb ,s+                        ; subtract out granule counter (moves other side of start)
                bpl LC7E8                       ; brif below lower bound
                ldb ,s                          ; get original granule number
LC7E6           com 1,s                         ; restore direction flag
LC7E8           leas 1,s                        ; remove saved granule number
                bra LC7C8                       ; see if we found a free granule yet
LC7EC           addb ,s+                        ; move to the top side of starting position
                cmpb #GRANMX                    ; did we overflow upward?
                blo LC7E8                       ; brif not
                ldb ,s                          ; get original granule number
                subb #4                         ; move an extra track in the other direction if overflowed up
                bra LC7E6                       ; go see if we found a free one yet
LC7F8           ldb #2*28                       ; code for disk full
                jmp LAC46                       ; raise error
LC7FD           leas 1,s                        ; clean up direction flag
                tfr b,a                         ; put granule number in A
                abx                             ; point X to granule data
                ldb #0xc0                       ; set granule to "used 0, last of file"
                stb ,x
LC806           rts
; Check active files to see if a file is already open; drive number and granule number
; AO will not be generated if the current status matches *exactly* the requested type in A.
LC807           pshs a                          ; save desired file type
                ldb FCBACT                      ; get number of active FCBs
                incb                            ; include the system FCB in the check
LC80D           jsr LC749                       ; point to FCB
                beq LC829                       ; brif not open at all
                lda DCDRV                       ; get desired drive
                cmpa FCBDRV,x                   ; match?
                bne LC829                       ; brif not
                ldu V974                        ; get directory entry pointer
                lda DIRGRN,u                    ; get first granule in file
                cmpa FCBFGR,x                   ; does it match?
                bne LC829                       ; brif not
                lda <<FCBTYP,x                  ; get file type
                cmpa ,s                         ; does it match the type we want?
                lbne LA61C                      ; brif not - raise AO error
LC829           decb                            ; checked all FCBs?
                bne LC80D                       ; brif not
                puls a,pc                       ; clean stack and return
; Parse device number and make sure it's open in random mode
LC82E           jsr LA5A5                       ; evaluate device number
                clr DEVNUM                      ; reset device number to screen
                tstb                            ; set flags on device number
                lble LB44A                      ; brif not a disk file
                jsr LC749                       ; fetch FCB pointer
                lda <<FCBTYP,x                  ; is file open?
                lbeq LA3FB                      ; brif not
                cmpa #RANFIL                    ; random file?
                beq LC806                       ; brif so
LC845           jmp LA616                       ; raise bad file mode
; Input device number check handler
DVEC5           lda #INPFIL                     ; set to check for input file
                skip2
; Output device number check handler
DVEC6           lda #OUTFIL                     ; set to check for output file
                tst DEVNUM                      ; set flags on device number
                ble LC806                       ; brif not a disk file (return)
                stx ,s                          ; save X and lose return address
                jsr LC744                       ; point to FCB
                ifeq DISKVER
                pshs a                          ; save file type requested
                else
                pshs d                          ; save b and file type requested
                endc
                lda <<FCBTYP,x                  ; get file type
                lbeq LA3FB                      ; brif not open
                cmpa #RANFIL                    ; random file?
                ifeq DISKVER
                beq LC866                       ; brif so - it's good (both input and output)
                else
                beq LC868                       ; brif so - it's good (both input and output)
                endc
                cmpa ,s                         ; is it the right type?
                bne LC845                       ; brif not - bad file mode
                ifeq DISKVER
LC866           puls a,x,pc                     ; restore registers and return
                else
LC866           puls a,b,x,pc                   ; clean up stack, restore registers, and return to caller
; This code is required to work around the dumbosity in the INPUT command which outputs the
; prompt string uncondionally so it would cause the prompt string to end up being output to
; a random file.
LC868           ldx 4,s                         ; are we coming from INPUT?
                cmpx #LB00C
                bne LC866                       ; brif not
                jsr SYNCOMMA                    ; make sure there's a comma after device
                cmpa #'"                        ; is there a prompt string?
                bne LC881                       ; brif not
                jsr LB244                       ; parse prompt string
                jsr LB657                       ; fetch string details (and discard them)
                ldb #';                         ; make sure there's a semicolon after the prompt string
                jsr LB26F
LC881           ldx #LB01E                      ; return after the prompt string check
                stx 4,s
                puls a,b,x,pc                   ; return to mainline flow
                endc
; Device number validity check handler
                ifeq DISKVER
DVEC1           ble LC806                       ; brif not a disk file
                else
DVEC1           ble LC8AF                       ; brif not a disk file
                endc
                cmpb FCBACT                     ; is it in range for open files?
                lbhi LA61F                      ; brif not - device number error
                puls x,pc                       ; purge RAM hook call return and return to original caller
; Set print parameters handler
DVEC2           tst DEVNUM                      ; is it disk file?
                ifeq DISKVER
                ble LC806                       ; brif not
                else
                ble LC8AF                       ; brif not
                endc
                leas 2,s                        ; don't return to mainline code
                pshs x,b,a                      ; save registers
                clr PRTDEV                      ; set print device to "display"
                jsr LC744                       ; point to correct FCB
                ldb FCBPOS,x                    ; get print position
                clra                            ; line width (256)
                ldx #0x1000                     ; tab width of 16, no last tab position
                jmp LA37C                       ; go save print parameters
; LIST break check handler
DVEC11          tst DEVNUM                      ; is it disk file?
                ble LC8AF                       ; brif not
                leas 2,s                        ; purge return - don't do break check if disk file
LC8AF           rts
                ifeq DISKVER-1
; Command interpreation handler
; This code replaces the main command interpretation loop completely. It includes a check
; to see if any keys are down before doing a break check. This is unneeded with Color Basic
; 1.2, but earlier versions of Color Basic benefit from it. This is the only change compared
; to plain ECB.
DVEC20          leas 2,s                        ; don't return to mainline code
LC8B2           andcc #0xaf                     ; enable interrupts
                clr PIA0+2                      ; strobe all keyboard columns
                lda PIA0                        ; get row data
                coma                            ; invert bits so 1 means pressed
                anda #0x7f                      ; lose the comparator input
                beq LC8C2                       ; brif no keys down - don't check for BREAK
                jsr LADEB                       ; do a break check
LC8C2           ldx CHARAD                      ; get input pointer
                stx TINPTR                      ; save it so things can find the start of this statement
                lda ,x+                         ; get current character
                beq LC8D1                       ; brif end of line
                cmpa #':                        ; is it end of statement?
                beq LC8F3                       ; brif so
                jmp LB277                       ; raise syntax error if not end of statement
LC8D1           lda ,x++                        ; get MSB of next line address
                sta ENDFLG                      ; this sets ENDFLG to "END" (unless program code is above 0x7FFF)
                bne LC8DA                       ; brif not end of program
                jmp LAE15                       ; go do "END" If we fell off the end of the program
LC8DA           ldd ,x+                         ; get line number for this line (and leave pointer one before line text)
                std CURLIN                      ; set current line number
                stx CHARAD                      ; set input pointer to start of line text
                lda TRCFLG                      ; are we doing "TRON"?
                beq LC8F3                       ; brif not
                lda #'[                         ; show [
                jsr PUTCHR
                lda CURLIN                      ; restore MSB of line number
                jsr LBDCC                       ; show line number
                lda #']                         ; show ]
                jsr PUTCHR
LC8F3           jsr GETNCH                      ; get starting character of next statement
                tfr cc,b                        ; save flags
                cmpa #0x98                      ; CSAVE?
                bne LC8FE                       ; brif not
                jmp L8316                       ; go handle ECB's CSAVE extensions (CSAVEM)
LC8FE           cmpa #0x97                      ; CLOAD?
                bne LC905                       ; brif not
                jmp L8311                       ; go handle ECB's CLOAD extensions (multi-origin binaries)
LC905           tfr b,cc                        ; restore flags for input byte
                jsr LADC6                       ; go interpret command token
                bra LC8B2                       ; process next statement
                endc
; EOF handler
DVEC14          leas 2,s                        ; dont return to mainline code
                lda DEVNUM                      ; get device number
                pshs a                          ; save it
                jsr LA5AE                       ; evaluate device number
                jsr LA3ED                       ; make sure it's open for input
                tst DEVNUM                      ; set flags on device
                lble LA5DA                      ; brif not disk file - go to mainline code
                jsr LC744                       ; point to correct FCB
                ldb <<FCBTYP,x                  ; get file type
                cmpb #RANFIL                    ; is it random file? (have to check since random is valid for input)
                ifeq DISKVER
                beq LC845                       ; bad file mode if so
                else
                lbeq LA616                      ; bad file mode if so
                endc
                clrb                            ; set flag to not EOF (false)
                lda FCBCFL,x                    ; is there an "ungot" character?
                bne LC932                       ; brif so
                ldb FCBDFL,x                    ; is there anything in the buffer? Will be 0xff if not
LC932           jmp LA5E4                       ; return status
; Parse a disk file name. Enter at LC938 with a pointer to the default extension in X.
; Valid file name patterns are:
; N:FILENAME[.EXT]
; N:FILENAME[/EXT]
; FILENAME[.EXT][:N]
; FILENAME[/EXT][:N]
; where N is a drive number.
LC935           ldx #DEFEXT                     ; point to blank default extension
LC938           clr ,-s                         ; set a flag for whether drive number was seen
                lda DEFDRV                      ; set drive number to default (as set by DRIVE)
                sta DCDRV
                ldu #DNAMBF                     ; point to file name buffer
                ldd #0x2008                     ; space character and 8 characters to set
LC945           sta ,u+                         ; blank a character
                decb                            ; done all?
                bne LC945                       ; brif not
                ldb #3                          ; three characters in extension
                jsr LA59A                       ; set default extension
                jsr L8748                       ; evaluate file name string
                leau ,x                         ; point to start of the string
                cmpb #2                         ; is string less than 2 characters?
                blo LC96A                       ; brif so - can't be N:FILENAME.EXT pattern
                lda 1,u                         ; get second character
                cmpa #':                        ; is it colon?
                bne LC96A                       ; brif not - no leading drive number
                lda ,u                          ; get leading character
                cmpa #'0                        ; is it below ASCII 0?
                blo LC96A                       ; brif so - not a drive number
                cmpa #'3                        ; is it above ASCII 3?
                bhi LC96A                       ; brif so - not a drive number
                bsr LC99D                       ; get drive number
LC96A           ldx #DNAMBF                     ; point to start of file name buffer
                incb                            ; compensate for DECB below
LC96E           decb                            ; end of string?
                bne LC97D                       ; brif so
                leas 1,s                        ; clean up drive number seen flag
LC973           cmpx #DNAMBF                    ; was there a file name?
                bne LC9DF                       ; brif not
LC978           ldb #2*31                       ; bad file name error code
                jmp LAC46                       ; raise error
LC97D           lda ,u+                         ; get character from string
                cmpa #'.                        ; is it extension?
                beq LC9B0                       ; brif so
                cmpa #'/                        ; is it other extension introducer?
                beq LC9B0                       ; brif so
                cmpa #':                        ; drive number introducer?
                beq LC994                       ; brif so
                cmpx #DEXTBF                    ; are we at the end of the file name buffer?
                beq LC978                       ; brif so - name too long
                bsr LC9D0                       ; put character in file name
                bra LC96E                       ; process another
LC994           bsr LC973                       ; bad file name if no name yet
                bsr LC99D                       ; parse drive number
                tstb                            ; is there anything left?
                bne LC978                       ; brif so
LC99B           puls a,pc                       ; clean up strack and return
LC99D           com 2,s                         ; toggle drive number seen flag
                beq LC978                       ; brif we've seen drive number already
                lda ,u++                        ; get drive number and skip trailing : if leading
                subb #2                         ; take two characters from string
                suba #'0                        ; remove ASCII bias
                blo LC978                       ; brif not a digit
                cmpa #3                         ; is it in range?
                bhi LC978                       ; brif not
                sta DCDRV                       ; save drive number
                rts
LC9B0           bsr LC973                       ; error if no file name yet
                ldx #DFLTYP                     ; point to end of extension buffer
                lda #0x20                       ; space (for padding extension)
LC9B7           sta ,-x                         ; insert padding character
                cmpx #DEXTBF                    ; done yet?
                bne LC9B7                       ; brif not
LC9BE           decb                            ; are we at the end of the string?
                beq LC99B                       ; brif so
                lda ,u+                         ; get character
                cmpa #':                        ; drive number?
                beq LC994                       ; brif so
                cmpx #DFLTYP                    ; is extension full?
                beq LC978                       ; brif so - bad fil ename
                bsr LC9D0                       ; put character in buffer
                bra LC9BE                       ; process another character
LC9D0           sta ,x+                         ; put character in buffer
                beq LC978                       ; brif NUL - don't allow it (first character NUL is deleted file)
                cmpa #'.                        ; dot?
                beq LC978                       ; brif not - don't allow extension separator
                cmpa #'/                        ; ditto for slash
                beq LC978
                inca                            ; is if 0xff?
                beq LC978                       ; brif so - first character 0xff means never used entry
LC9DF           rts
; SAVE command
SAVE            cmpa #'M                        ; is it SAVEM?
                lbeq LCF68                      ; brif so
                bsr LCA33                       ; parse file name
                ldx ZERO                        ; set to BASIC program and binary
                stx DFLTYP
                jsr GETCCH                      ; is there something after the file name?
                beq LCA12                       ; brif not
                jsr SYNCOMMA                    ; make sure we have a comma
                ldb #'A                         ; only valid flag is "A" for ASCII
                jsr LB26F
                bne LC9DF                       ; brif more stuff follows - error
                com DASCFL                      ; set to ASCII type
                bsr LCA04                       ; open sequential file for output
                clra                            ; set Z to cause whole program to be listed
                jmp LIST                        ; let LIST do the heavy lifting
LCA04           lda #'O                         ; output file type
                skip2
LCA07           lda #'I                         ; iput file type
                ldb FCBACT                      ; get number of active FCBs
                incb                            ; bump to system FCB
                stb DEVNUM                      ; use the system FCB
                jmp LC48D                       ; open file and initialize FCB
LCA12           bsr LCA04                       ; open file for output
                lda #0xff                       ; send basic file flag
                jsr LCC24
                ldd VARTAB                      ; get end of program address
                subd TXTTAB                     ; now we have length of program
                jsr LCC24                       ; output length MS byte
                tfr b,a                         ; output length LS byte
                jsr LCC24
                ldx TXTTAB                      ; point to start of program text
LCA27           lda ,x+                         ; output byte from program
                jsr LCC24
                cmpx VARTAB                     ; end of program?
                bne LCA27                       ; brif not
                jmp LA42D                       ; close the file
LCA33           ldx #BASEXT                     ; point to BAS extension (for basic programs)
                jmp LC938                       ; parse file name
; MERGE command
MERGE           clra                            ; run flag: 0 = don't run
                ldb #0xff                       ; merge flag: 0xff = merge
                bra LCA50
; RUN handler
DVEC18          cmpa #'"                        ; do we have a file name?
                lbne XVEC18                     ; brif not
                lda #2                          ; RUN flag - run after loading
                bra LCA4F                       ; load file
; LOAD command
LOAD            cmpa #'M                        ; is it LOADM?
                lbeq LCFC1                      ; brif so
                clra                            ; set not to RUN
LCA4F           clrb                            ; set not to MERGE
LCA50           sta DRUNFL                      ; save RUN flag
                stb DMRGFL                      ; save MERGE flag
                bsr LCA33                       ; parse file name
                jsr GETCCH                      ; is there anything after the file name?
                beq LCA6C                       ; brif not
                jsr SYNCOMMA                    ; make sure comma
                ldb #'R                         ; make sure the flag is "R"
                jsr LB26F
                jsr LA5C7                       ; error if anything else
                lda #3                          ; set flags to RUN and not close files
                sta DRUNFL
LCA6C           bsr LCA07                       ; open file for input
                lda DASCFL                      ; is it ASCII?
                beq LCA7E                       ; brif not
                tst DMRGFL                      ; is it merge?
                bne LCA7B                       ; brif so
                jsr LAD19                       ; do a "NEW" - erase existing program
LCA7B           jmp LAC7C                       ; let immediate mode do the heavy lifting now
LCA7E           lda DFLTYP                      ; get type
                ora DMRGFL                      ; mix with merge flag
                lbne LA616                      ; if either of the above was nonzero, raise bad file mode
                jsr LAD19                       ; erase existing program
                com DLODFL                      ; flag that we're loading a program
                jsr LCDBC                       ; get initial character (discard it, should be 0xff)
                jsr LCDBC                       ; get MSB of length
                pshs a                          ; save it
                jsr LCDBC                       ; get LSB of length
                tfr a,b                         ; save length in D
                puls a
                addd TXTTAB                     ; add to start of program text
                jsr LAC37                       ; make sure it fits
                ldx TXTTAB                      ; point to start of program
LCAA4           jsr LC5C4                       ; get a character
                ldb CINBFL                      ; EOF?
                bne LCAAF                       ; brif so
                sta ,x+                         ; save character
                bra LCAA4                       ; process more
LCAAF           clr DLODFL                      ; clear load flag - no errors
                stx VARTAB                      ; set new end of program
                ldb #3                          ; make sure the last three bytes were 0
LCAB6           lda ,-x                         ; do we have a 0?
                bne LCABD                       ; brif not
                decb                            ; done all three?
                bne LCAB6                       ; brif not
LCABD           ldx VARTAB                      ; get end of program
LCABF           stx VARTAB                      ; save new end of program
                clr ,x+                         ; blank a byte
                decb                            ; done enough?
                bpl LCABF                       ; brif not
LCAC6           jsr LA42D                       ; close the file
                jsr LAD21                       ; clear variables, reset stack, etc.
                jsr XVEC18                      ; initalize graphics stuff
                jsr LACEF                       ; recalculate line pointers
                asr DRUNFL                      ; are we supposed to close all files?
                bcs LCADA                       ; brif not
                jsr LA426                       ; close all open files
LCADA           asr DRUNFL                      ; are we supposed to run the program/
                lbcs LAD9E                      ; brif so - launch program
                jmp LAC73                       ; return to immediate mode
; EOF handler for main loop
DVEC13          tst DEVNUM                      ; is it disk file?
                bgt LCAC6                       ; brif so - run it if required
                rts                             ; return to mainline otherwise
; Close all files handler
DVEC7           ldb FCBACT                      ; get number of reserved FCBs
                incb                            ; include system FCB
LCAED           pshs b                          ; save file count
                stb DEVNUM                      ; set device to close
                bsr LCB01                       ; close it
                puls b                          ; get back file count
                decb                            ; move to next one
                bne LCAED                       ; brif not done all disk files
LCAF8           rts
; Close one file handler
DVEC8           tst DEVNUM                      ; is it a disk file?
                lble XVEC8                      ; brif not
                leas 2,s                        ; don't return to mainline
LCB01           jsr LC744                       ; get FCB pointer
                clr DEVNUM                      ; reset device number
LCB06           stx FCBTMP                      ; save FCB pointer
                lda <<FCBTYP,x                  ; get file type
                beq LCAF8                       ; brif file isn't open - we don't have to do anything
                pshs a                          ; save file type
                clr <<FCBTYP,x                  ; mark file closed
                ldb FCBDRV,x                    ; tell DSKCON which drive the file is on
                stb DCDRV
                cmpa #OUTFIL                    ; output file?
                bne LCB31                       ; brif not
                ldb FCBLFT,x                    ; get number of characters in output buffer
                lda #0x80                       ; set pre-saved bit to indicate data already saved
                ifeq DISKVER-1
                ora FCBCPT,x                    ; merge with full sector flag
                endc
                std FCBLST,x                    ; save number of bytes used in last sector
                inc FCBSEC,x                    ; bump sector counter
                ldb FCBCGR,x                    ; get current granule
                jsr LC755                       ; point to FAT
                sta FAT1,x                      ; mark FAT data invalid
                abx                             ; add granule offset to pointer
                inc FATCON,x                    ; add one to sector count for last granule (skip control bytes)
                ifeq DISKVER
LCB2E           bra LCBC3                       ; update FAT and directory, write out any final data
                else
LCB2E           jmp LCBC3                       ; update FAT and directory, write out any final data
                endc
LCB31           cmpa #RANFIL                    ; random file?
                ifeq DISKVER
                bne LCBC3                       ; brif not
                else
                bne LCB2E                       ; brif not - update FAT and directory for input file
                endc
                ldd FCBRLN,x                    ; get record length
                ldx FCBBUF,x                    ; get buffer pointer
                leay d,x                        ; point to end of random file buffer
                pshs y,x,b,a                    ; save pointers and length
                ifeq DISKVER-1
                leay ,s                         ; save stack pointer
                endc
                ldu VARTAB                      ; get start of variables
LCB41           cmpu ARYTAB                     ; end of scalars?
                beq LCB54                       ; brif so
                lda 1,u                         ; get second byte of variable name
                leau 2,u                        ; move past variable name
                bpl LCB4E                       ; brif numeric
                bsr LCB76                       ; adjust string variable if in random file buffer
LCB4E           leau 5,u                        ; move to next variable entry
                bra LCB41                       ; process next variable entry
LCB52           puls u                          ; get address of next array
LCB54           cmpu ARYEND                     ; end of arrays?
                ifeq DISKVER
                beq LCB91                       ; brif so
                else
                beq LCB93                       ; brif so
                endc
                tfr u,d                         ; save array start
                addd 2,u                        ; add length of array
                pshs d                          ; save address of next array
                lda 1,u                         ; is it string?
                bpl LCB52                       ; brif not - do next array
                ldb 4,u                         ; get number of dimensions
                aslb                            ; two bytes per dimension size
                addb #5                         ; 5 bytes constant per array header
                clra                            ; zero extend
                leau d,u                        ; point to start of array data
LCB6B           cmpu ,s                         ; end of this array?
                beq LCB52                       ; brif so
                bsr LCB76                       ; adjust string variable if in random file buffer
                leau 5,u                        ; move to next entry
                bra LCB6B                       ; process next entry
LCB76           ldx 2,u                         ; get pointer to start of string
                cmpx RNBFAD                     ; is it above top of random buffer area?
                bhs LCB8B                       ; brif so
                ifeq DISKVER
                cmpx 4,s                        ; is it below this file's buffer area?
                blo LCB8C                       ; brif so
                cmpx 6,s                        ; is it above this file's buffer?
                else
                cmpx 2,y                        ; is it above start of this file's buffer area?
                blo LCB8B                       ; brif not
                cmpx 4,y                        ; is it below end of this file's buffer area?
                endc
                blo LCB8C                       ; brif so - we have to adjust it
                tfr x,d                         ; save pointer in D
                ifeq DISKVER
                subd 2,s                        ; adjust pointer down by length of buffer area for this file
                else
                subd ,y                         ; adjust pointer down by length of buffer area for this file
                endc
                std 2,u                         ; save new start of string
LCB8B           rts
LCB8C           clr ,u                          ; mark string empty
                clr 2,u                         ; NULL out string address
                clr 3,u
                rts
                ifeq DISKVER
LCB91           puls a,b,x,u                    ; clean up stack
                else
LCB93           ldb FCBACT                      ; get number of active files
                incb                            ; include system FCB
LCB97           pshs b                          ; save files count
                jsr LC749                       ; point to FCB number in B
                lda <<FCBTYP,x                  ; open as random file?
                cmpa #RANFIL
                bne LCBAD                       ; brif not
                ldd FCBBUF,x                    ; get buffer pointer
                cmpd 4,y                        ; is it above this file's buffer?
                blo LCBAD                       ; brif not
                subd ,y                         ; subtract out length for this file's buffer
                std FCBBUF,x                    ; save new buffer area pointer
LCBAD           puls b                          ; get files counter back
                decb                            ; done all?
                bne LCB97                       ; brif not
                puls a,b,x,u                    ; get back pointers and buffer length
                endc
LCBB4           cmpu RNBFAD                     ; at top of buffers?
                beq LCBC0                       ; brif so
                lda ,u+                         ; copy a byte down
                sta ,x+
                bra LCBB4                       ; see if we're done yet
LCBC0           stx RNBFAD                      ; save new start of free buffer area
LCBC3           jsr LC755                       ; point to proper FAT
                dec <<FAT0,x                    ; remove one active file
                tst FAT1,x                      ; new data in FAT image?
                beq LCBCF                       ; brif not
                jsr LC71E                       ; save modified FAT
LCBCF           ldx FCBTMP                      ; get FCB pointer back
                puls a                          ; get file type
                cmpa #OUTFIL                    ; output?
                beq LCBDF                       ; brif so
                cmpa #RANFIL                    ; random?
                bne LCB8B                       ; brif not
                lda FCBFLG,x                    ; doing GET?
                beq LCBE9                       ; brif so
LCBDF           jsr LC763                       ; set up track and sector parameters
                leau FCBCON,x                   ; point to data buffer
                stu DCBPT
                bsr LCC15                       ; write out the sector data
LCBE9           lda FCBLST,x                    ; data pre-saved?
                bpl LCB8B                       ; brif it has already been saved
                ldb FCBDIR,x                    ; get directory number for this file
                andb #7                         ; 8 entries per sector
                lda #DIRLEN                     ; calculate offset into directory sector
                mul
                ldu #DBUF0                      ; point to global buffer
                stu DCBPT                       ; set DSKCON buffer address
                leay d,u                        ; Y points to directory entry now
                ldb FCBDIR,x                    ; get directory entry number
                lsrb                            ; divide by 8 (gives sector number)
                lsrb
                lsrb
                addb #3                         ; first directory sector is 3
                stb DSEC                        ; tell DSKCON
                ldd #0x1102                     ; set up to read track 17
                sta DCTRK
                bsr LCC17                       ; read directory sector
                ldd FCBLST,x                    ; get number of bytes in last sector
                anda #0x7f                      ; remove pre-saved flag
                std DIRLST,y                    ; update directory entry
LCC15           ldb #3                          ; write operation
LCC17           stb DCOPC                       ; tell DSKCON what to do
                jmp LD6F2                       ; go read or write sector
; Generic output handler
DVEC3           tst DEVNUM                      ; disk file?
                lble XVEC3                      ; brif not
                leas 2,s                        ; don't return to mainline
LCC24           pshs x,b,a                      ; save registers
                ldx #FCBV1-2                    ; point to FCB list (-2 for 1-based file numbers)
                ldb DEVNUM                      ; get device number
                aslb                            ; two bytes per pointer
                ldx b,x                         ; get FCB pointer
                ldb ,x                          ; get file type
                cmpb #INPFIL                    ; input?
                beq LCC6A                       ; brif so - bail
                cmpa #0x0d                      ; carriage return?
                bne LCC3A                       ; brif so
                clr FCBPOS,x                    ; reset print position if CR
LCC3A           cmpa #0x20                      ; control code?
                blo LCC40                       ; brif so
                inc FCBPOS,x                    ; bump print position if printing character
LCC40           cmpb #RANFIL                    ; random file?
                bne LCC5E                       ; brif not
                ldd FCBPUT,x                    ; get put pointer
                addd #1                         ; bump it
                cmpd FCBRLN,x                   ; did we overflow the record?
                lbhi LCDCB                      ; brif so - raise error
                std FCBPUT,x                    ; save updated pointer
                ldx FCBBUF,x                    ; get buffer pointer
                leax d,x                        ; add in offset
                puls a                          ; get back output character
                sta -1,x                        ; save in buffer (-1 because we already bumped pointer)
                puls b,x,pc                     ; restore registers and return
LCC5E           inc FCBLFT,x                    ; bump character count
                ldb FCBLFT,x                    ; did we max out a sector?
                beq LCC6C                       ; brif so
                abx                             ; add offset into sector
                sta FCBCON-1,x                  ; save output character in buffer, offset past control structure
LCC6A           puls a,b,x,pc                   ; restore registers and return
LCC6C           pshs u,y                        ; save registers
                sta SECLEN+FCBCON-1,x           ; save last character in buffer
                ifeq DISKVER
                jsr LC685
                endc
                ldb FCBDRV,x                    ; tell DSKCON which drive
                stb DCDRV
                inc FCBSEC,x                    ; bump sector counter (in granule)
                jsr LCBDF                       ; write file buffer to disk
                leay ,x                         ; save FCB pointer
                ldb FCBCGR,x                    ; get granule number
                jsr LC755                       ; get pointer to FAT
                abx                             ; offset into granule data
                leau FATCON,x                   ; now U points to granule data (offset past control structure)
                lda FCBSEC,y                    ; get current sector offset
                cmpa #9                         ; end of granule?
                blo LCC99                       ; brif not
                ifeq DISKVER-1
                dec FCBSEC,y                    ; decrement sector number and bump error flag in case error occurs
                inc FCBCPT,y
                else
                clr FCBSEC,y
                endc
                jsr LC7BF                       ; allocate granule
                ifeq DISKVER-1
                clr FCBSEC,y                    ; clear sector number
                clr FCBCPT,y                    ; clear error flag - disk not full
                endc
                sta FCBCGR,y                    ; save new granule in FCB
                skip2
LCC99           ora #0xc0                       ; mark granule as end of file
                sta ,u                          ; save in granule map
                ifeq DISKVER-1
                leax ,y                         ; get back FCB pointer
                jsr LC685                       ; bump record number
                endc
                jsr LC5A9                       ; update FAT
                puls y,u                        ; restore registers
                puls a,b,x,pc                   ; restore registers and return
; DIR command
DIR             jsr LD24F                       ; parse drive number
                jsr LC79D                       ; fetch FAT for drive
                jsr LB958                       ; do a linefeed
                ldd #0x1102                     ; set up to read track 17
                sta DCTRK
                stb DCOPC
                ldb #3                          ; start at sector 3 for the directory
LCCBB           stb DSEC                        ; set sector to read
                ldx #DBUF0                      ; use the global sector buffer
                stx DCBPT
                jsr LD6F2                       ; read directory sector
LCCC5           puls u                          ; do some stack games due to break check requirements
                jsr LA549
                pshs u
                lda ,x                          ; is this entry used?
                beq LCD08                       ; brif not
                coma                            ; is it the start of never entries?
                beq LCD17                       ; brif so - we're done
                pshs x                          ; save directory data pointer
                ldb #8                          ; print out 8 characters for the filename
                jsr LB9A2                       ; display file name
                bsr LCD1B                       ; put a blank
                ldb #3                          ; show 3 characters in extension
                jsr LB9A2                       ; display extension
                bsr LCD1B                       ; put a blank
                ldb <<0,x                       ; get file type
                cmpb #10                        ; is it one digit?
                bhs LCCEB                       ; brif so
                bsr LCD1B                       ; put another blank
LCCEB           clra                            ; zero extend type
                jsr LBDCC                       ; show file type
                bsr LCD1B                       ; another blank
                ldx ,s                          ; get directory entry back
                lda #'B                         ; set to binary
                adda DIRASC,x                   ; add ASCII flag - will subtract 1 (to A) if ASCII
                bsr LCD18                       ; show character and a blank
                ldb DIRGRN,x                    ; point to first granule in file
                bsr LCD1E                       ; count granules
                tfr a,b                         ; zero extend into D
                clra
                jsr LBDCC                       ; show granule count
                jsr LB958                       ; do a newline
                puls x                          ; get back directory pointer
LCD08           leax DIRLEN,x                   ; move to next entry
                cmpx #DBUF0+SECLEN              ; end of sector?
                blo LCCC5                       ; brif not
                ldb DSEC                        ; get sector number
                incb                            ; move to next one
                cmpb #SECMAX                    ; end of track?
                bls LCCBB                       ; brif not
LCD17           rts
LCD18           jsr PUTCHR                      ; display character
LCD1B           jmp LB9AC                       ; display a space
; Count granule chain starting at granule number in B
LCD1E           jsr LC755                       ; get FAT pointer
                leau FATCON,x                   ; point past control structure
                clra                            ; reset count to 0
LCD24           inca                            ; bump granule count
                cmpa #GRANMX                    ; at maximum size of disk?
                lbhi LC653                      ; do FS error if so
                leax ,u                         ; point to base FAT data
                abx                             ; offset to granule number
                ldb ,x                          ; get next granule pointer
                cmpb #0xc0                      ; end of file marker?
                blo LCD24                       ; brif not
                rts
; INPUT handler; this whole mess is requried because the disk data format varies from that used
; by tape files.
DVEC10          tst DEVNUM                      ; are we reading from a disk file?
                ble LCD97                       ; brif not
                ldx #LB069                      ; change return address to skip ? prompt
                stx ,s
                ldx #LINBUF+1                   ; point to input buffer
                ldb #',                         ; set item separator to ,
                stb CHARAC
                lda VALTYP                      ; get type wanted
                bne LCD4B                       ; brif string
                ldb #0x20                       ; space is the numeric delimiter
LCD4B           bsr LCDBC                       ; fetch input character
                cmpa #0x20                      ; space?
                beq LCD4B                       ; brif so
                cmpa #'"                        ; quote?
                bne LCD5F                       ; brif not
                cmpb #',                        ; delim is ,?
                bne LCD5F                       ; brif not - numeric
                tfr a,b                         ; save quote as search character
                stb CHARAC
                bra LCD81                       ; save quote as first item in buffer
LCD5F           cmpb #'"                        ; string value?
                beq LCD74                       ; brif so
                cmpa #0x0d                      ; end of line?
                bne LCD74                       ; brif not
                cmpx #LINBUF+1                  ; at start of buffer?
                beq LCDB0                       ; brif so - check for LF
                lda -1,x                        ; get back input character
                cmpa #0x0a                      ; was it LF?
                bne LCDB0                       ; brif not
                lda #0x0d                       ; restore CR as input character
LCD74           tsta                            ; NUL?
                beq LCD8E                       ; brif so - ignore it
                cmpa CHARAC                     ; hit a delimiter?
                beq LCD98                       ; brif so
                pshs b                          ; does it match the other delimiter?
                cmpa ,s+
                beq LCD98                       ; brif so
LCD81           sta ,x+                         ; save character in buffer
                cmpx #LINBUF+LBUFMX             ; end of buffer?
                bne LCD8E                       ; brif not
                bsr LCDD0                       ; fetch character
                bne LCD92                       ; brif buffer empty
                bra LCDAC                       ; check for CR/CRLF
LCD8E           bsr LCDD0                       ; get input character
                beq LCD5F                       ; brif we have something
LCD92           clr ,x                          ; put NUL at end of buffer
                ldx #LINBUF                     ; point to input buffer
LCD97           rts
LCD98           cmpa #'"                        ; quote?
                beq LCDA0                       ; brif so
                cmpa #0x20                      ; space?
                bne LCD92                       ; brif not
LCDA0           bsr LCDD0                       ; get character
                bne LCD92                       ; brif end
                cmpa #0x20                      ; space?
                beq LCDA0                       ; brif so - skip it
                cmpa #',                        ; item separator?
                beq LCD92                       ; brif so - done
LCDAC           cmpa #0x0d                      ; carriage return?
                bne LCDB8                       ; brif not
LCDB0           bsr LCDD0                       ; fetch character
                bne LCD92                       ; brif end
                cmpa #0x0a                      ; line feed?
                beq LCD92                       ; brif so - skip it
LCDB8           bsr LCDD6                       ; unget character
                bra LCD92                       ; handle exit
LCDBC           bsr LCDD0                       ; fetch character
                beq LCDD5                       ; brif not end of file
                jsr LC744                       ; point to FCB
                ldb <<FCBTYP,x                  ; get file type
                cmpb #RANFIL                    ; random file?
                lbne LC352                      ; brif not - do input past end of file
LCDCB           ldb #2*37                       ; code for input past end of record
                jmp LAC46                       ; raise error
LCDD0           jsr LA176                       ; read character
                tst CINBFL                      ; set Z if not EOF
LCDD5           rts
LCDD6           pshs x,b                        ; save registers
                jsr LC744                       ; point to FCB
                ldb <<FCBTYP,x                  ; random file?
                cmpb #RANFIL
                bne LCDEC                       ; brif not
                ldd FCBGET,x                    ; get input pointer
                subd #1                         ; move it back (no error check!)
                std FCBGET,x                    ; save new pointer
                puls b,x,pc                     ; restore registers and return
LCDEC           sta FCBCDT,x                    ; save unget character
                com FCBCFL,x                    ; flag that we have an ungot character
                puls b,x,pc                     ; restore registers and return
; CVN function
CVN             jsr LB654                       ; evaluate argument string
                cmpb #5                         ; is it at least 5 bytes (packed FP number)?
                lblo LB44A                      ; brif not - raise error
                clr VALTYP                      ; result is numeric
                jmp LBC14                       ; unpack string into return value
; MKN$ function
MKN             jsr LB143                       ; make sure we have a number
                ldb #5                          ; string will be 5 bytes long
                jsr LB50F                       ; reserve space for it
                jsr LBC35                       ; pack argument into the string
                jmp LB69B                       ; return the newly created string
; LOC function
LOC             bsr LCE19                       ; get pointer to correct FCB
                ldd FCBREC,x                    ; get record number (random file) or sector counter
                ifeq DISKVER
LCE14           jmp GIVABF                      ; return result as integer
                else
LCE14           std FPA0+2                      ; return result as an unsigned integer
                jmp L880E
                endc
; Evaluate device number, set print parameters, and point to FCB
LCE19           lda DEVNUM                      ; save current device number
                pshs a
                jsr LB143                       ; make sure we have a number
                jsr LA5AE                       ; check device and set print params
                tst DEVNUM                      ; is it a disk file?
                lble LB44A                      ; brif not
                jsr LC744                       ; point to FCB
                puls a                          ; restore original device number
                sta DEVNUM
                tst <<FCBTYP,x                  ; is file open?
                lbeq LA3FB                      ; brif not, do NO error
                rts
; LOF function
LOF             bsr LCE19                       ; point to FCB
                lda FCBDRV,x                    ; tell DSKCON the drive number
                sta DCDRV
                ldb FCBFGR,x                    ; get first granule of file
                pshs x                          ; save FCB pointer
                jsr LCD1E                       ; count granules in file
                deca                            ; subtract out last granule
                andb #0x3f                      ; get number of sectors in last granule
                pshs b                          ; save it
                tfr a,b                         ; zero extend granule number to D
                clra
                jsr LC779                       ; multiply by 9 for total sector count
                addb ,s+                        ; add in sectors in last granule
                adca #0
                puls x                          ; get back FCB pointer
                pshs a                          ; temp save
                lda <<FCBTYP,x                  ; is it random file?
                cmpa #RANFIL
                puls a                          ; restore register
                bne LCE14                       ; brif not random file - return number of sectors
                pshs x                          ; save FCB pointer
                subd ZERO                       ; "tstd"
                beq LCE68                       ; brif file is empty
                subd #1                         ; don't count last sector as fully used
LCE68           bsr LCE14                       ; put D into FPA0
                ldb FP0EXP                      ; is it 0?
                beq LCE72                       ; brif so
                addb #8                         ; multiply by 256
                stb FP0EXP
LCE72           jsr LBC5F                       ; save result in FPA1
                ldx ,s                          ; get back FCB pointer
                ldd FCBLST,x                    ; get number of bytes in last sector
                anda #0x7f                      ; clear out pre-save flag
                bsr LCE14                       ; stuff that number in FPA0
                clr RESSGN                      ; result will be positive
                lda FP1EXP                      ; get exponents
                ldb FP0EXP
                jsr LB9C5                       ; add number of bytes in last sector
                jsr LBC5F                       ; save total in FPA1
                puls x                          ; get FCB
                ldd FCBRLN,x                    ; get record length
                bsr LCE14                       ; turn it into a FP number
                clr RESSGN                      ; make result positive
                lda FP1EXP                      ; get exponents
                ldb FP0EXP
                jsr LBB91                       ; divide total by record size
                jmp INT                         ; return the result as an integer
; FREE function
FREE            jsr LB143                       ; make sure we have a number
                jsr LB70E                       ; get value in B
                cmpb #3                         ; valid drive?
                lbhi LA61F                      ; brif not
                stb DCDRV                       ; set drive
                jsr LC79D                       ; read FAT
                jsr LC755                       ; point to FAT
                leax FATCON,x                   ; point to actual granule data
                clr ,-s                         ; initialize free count
                ldb #GRANMX                     ; total granules to check
LCEB6           lda ,x+                         ; get granule data
                coma                            ; is it free?
                bne LCEBD                       ; brif not
                inc ,s                          ; bump free count
LCEBD           decb                            ; checked them all?
                bne LCEB6                       ; brif not
                puls b                          ; get free count
                jmp LB4F3                       ; return free count
; DRIVE command
DRIVE           jsr EVALEXPB                    ; evaluate drive number to B
                cmpb #3                         ; valid?
                lbhi LA61F                      ; brif not
                stb DEFDRV                      ; set default drive
                rts
; Expression evaluation handler; this is needed so we can move strings into string space
; if regular assignment to a FIELDed string is done. There really isn't a better place to
; intercept this, unfortunately.
DVEC15          lda 4,s                         ; is it end of operation?
                bne LCEE9                       ; brif not
                ldx 5,s                         ; are we comming from LET?
                cmpx #LAF9A
                bne LCEE9                       ; brif not
                ldx 2,s
                cmpx #LB166
                bne LCEE9                       ; and brif not again
                ldx #LCEEC                      ; install intercept for LET
                stx 5,s
LCEE9           jmp XVEC15                      ; let ECB do its thing
; LET modifier
LCEEC           puls a                          ; get variable type
                rora                            ; set C if string
                jsr LB148                       ; make sure things match
                lbeq LBC33                      ; brif numeric - we can go back to mainline
                ldx FPA0+2                      ; get string descriptor
                ldd 2,x                         ; get data pointer
                cmpd #DFLBUF                    ; is it below random buffers?
                blo LCF07                       ; brif so
                subd FCBADR                     ; is it within the random buffers?
                lblo LAFB1                      ; brif so - move string to string space
LCF07           jmp LAFA4                       ; return to mainline code
; ECB interpretation handler intercept; the PMODE intercept fixes a stupid usage of a constant 6 for the
; start of graphics memory in PMODE.  The DLOAD intercept fixes the problem where DLOADM couldn't be
; detected due to A being clobbered before it was checked. Both of those bugs were fixed in ECB 1.1.
DXCVEC          cmpa #0xca                      ; DLOAD?
                beq LCF2A                       ; brif so
                cmpa #0xc8                      ; PMODE?
                lbne L813C                      ; brif not - return to ECB's handler
                jsr GETNCH                      ; get input character
                cmpa #',                        ; no PMODE argument?
                lbeq L9650                      ; brif not - return to mainline
                jsr EVALEXPB                    ; evaluate PMODE number
                cmpb #4                         ; valid?
                lbhi LB44A                      ; brif not
                lda GRPRAM                      ; fetch start of grahpics memory (work around usage of constant 6 in ECB 1.0)
                jmp L962E                       ; return to mainline PMODE
LCF2A           jsr LA429                       ; close files 
                jsr GETNCH                      ; fetch input character
                jmp L8C1B                       ; return to mainlnie
; ECB function interpetation handler intercept; this is needed to patch into the POS() function.
DXIVEC          cmpb #(0x9a-0x80)*2             ; is it POS?
                lbne L8168                      ; brif not - return to ECB mainline
                jsr LB262                       ; evaluate argument
                lda DEVNUM                      ; get device number
                pshs a                          ; save it
                jsr LA5AE                       ; evaluate device number
                jsr LA406                       ; make sure it's open
                tst DEVNUM                      ; disk file?
                ble LCF5C                       ; brif not
                jsr LC744                       ; point to FCB
                ldb <<FCBTYP,x                  ; get file type
                cmpb #RANFIL                    ; random file?
                bne LCF5C                       ; brif not
                puls a                          ; get back saved device number
                sta DEVNUM
                ldd FCBPUT,x                    ; get "put" position
                jmp GIVABF                      ; return that as the position
LCF5C           jsr LA35F                       ; set print parameters
                puls a                          ; restore device number
                sta DEVNUM
                ldb DEVPOS                      ; get print position
                jmp LB4F3                       ; return B as unsigned
; SAVEM command (comes from SAVE command)
LCF68           jsr GETNCH                      ; eat the "M"
                bsr LCFBB                       ; parse filename
                jsr L836C                       ; evaluate start address
                jsr L836C                       ; evaluate end address
                cmpx 2,s                        ; is start > end?
                lblo LB44A                      ; brif so - throw an error
                jsr L836C                       ; evaluate execution address
                jsr LA5C7                       ; make sure there's nothing more
                ldd #0x200                      ; file type 2 (M/L) and binary
                std DFLTYP
                jsr LCA04                       ; open file for output
                clra                            ; write preamble header
                bsr LCFB5
                ldd 2,s                         ; get end address
                subd 4,s                        ; subtract start - gets length
                addd #1                         ; length is inclusive
                tfr d,y                         ; set data counter
                bsr LCFB3                       ; output the length of the block
                ldd 4,s                         ; output the load address
                bsr LCFB3
                ldx 4,s                         ; point to start of block
LCF9B           lda ,x+                         ; grab output byte
                jsr LCC24                       ; write it
                leay -1,y                       ; done yet?
                bne LCF9B                       ; brif not
                lda #0xff                       ; write header for postamble
                bsr LCFB5
                clra                            ; write dummy 16 bits (would be block length)
                clrb
                bsr LCFB3
                puls d,x,y                      ; get back execution address and clean stack
                bsr LCFB3                       ; write out execution address
                jmp LA42D                       ; close file
LCFB3           bsr LCFB5                       ; write MSB of word; fall through for LSB
LCFB5           jsr LCC24                       ; write byte out
                exg a,b                         ; swap bytes in word
                rts
LCFBB           ldx #BINEXT                     ; set default extension to "BIN"
                jmp LC938                       ; parse filename
; LOADM command (comes from LOAD command)
LCFC1           jsr GETNCH                      ; eat the "M"
                bsr LCFBB                       ; parse filename
                jsr LCA07                       ; open file for input
                ldd DFLTYP                      ; get type of file
                subd #0x200                     ; is it M/L and binary?
                lbne LA616                      ; bad file mode if not
                ldx ZERO                        ; set default offset value
                jsr GETCCH                      ; is there a load offset?
                beq LCFDE                       ; brif not
                jsr SYNCOMMA                    ; insist on a comma
                jsr LB73D                       ; evaluate offset to X
LCFDE           stx VD3                         ; save offset
                jsr LA5C7                       ; insist on end of statement
LCFE3           jsr LCDBC                       ; read "amble" header
                pshs a                          ; save "amble" type
                bsr LD013                       ; read block length
                tfr d,y                         ; save it (in counter)
                bsr LD013                       ; read block address
                addd VD3                        ; add load offset
                std EXECJP                      ; set execution address
                tfr d,x                         ; put it also in a pointer
                lda ,s+                         ; set flags on "amble" type
                lbne LA42D                      ; brif postamble - stop reading
LCFFA           jsr LC5C4                       ; read a byte
                ldb CINBFL                      ; EOF?
                beq LD004                       ; brif not
                jmp LC352                       ; raise "IE" error
LD004           sta ,x                          ; save byte in memory
                cmpa ,x+                        ; does the byte match?
                beq LD00D                       ; brif so
                jmp LD709                       ; bad store - throw I/O error
LD00D           leay -1,y                       ; done whole block?
                bne LCFFA                       ; brif not
                bra LCFE3                       ; process another "amble"
LD013           bsr LD015                       ; read MSB then fall through for LSB
LD015           jsr LCDBC                       ; read a byte from the file
                exg a,b                         ; swap bytes in word
                rts
; RENAME command
RENAME          ldx CHARAD                      ; get input pointer
                pshs x                          ; save it
                bsr LD056                       ; evaluate source file name
                lda DCDRV                       ; save drive for first file
                pshs a
                bsr LD051                       ; evaluate TO and destination file
                puls a                          ; get back original drive number
                cmpa DCDRV                      ; does it match?
                lbne LB44A                      ; brif not - we can't rename across drives
                bsr LD059                       ; make sure new file does not already exist
                puls x                          ; get back input pointer
                stx CHARAD
                bsr LD056                       ; re-evaluate source file
                jsr LC68C                       ; find the source file
                jsr LC6E5                       ; throw error if not found
                bsr LD051                       ; evaluate destination file name
                ldx #DNAMBF                     ; point to destinatoin file name
                ldu V974                        ; point to directory entry
                ldb #11                         ; 8 characters file name and 3 characters extension
                jsr LA59A                       ; replace file name
                ldb #3                          ; operation code for write
                stb DCOPC
                jmp LD6F2                       ; write updated directory sector
LD051           ldb #0xa5                       ; insist on "TO"
                jsr LB26F
LD056           jmp LC935                       ; evaluate file name with default blank extension
LD059           jsr LC68C                       ; find file
                ldb #33*2                       ; code for already exists
                tst V973                        ; does it exist?
                lbne LAC46                      ; brif so - raise error
                rts
; WRITE command
WRITE           lbeq LB958                      ; do CR if end of statement
                bsr LD06F                       ; write an item list
                clr DEVNUM                      ; reset device to screen
LD06E           rts
LD06F           cmpa #'#                        ; device number?
                bne LD082                       ; brif not
                jsr LA5A5                       ; evaluate device number
                jsr LA406                       ; check for output
                jsr GETCCH                      ; end of statement?
                lbeq LB958                      ; brif so - do newline
LD07F           jsr SYNCOMMA                    ; need a comma after device
LD082           jsr LB156                       ; evaluate expression
                lda VALTYP                      ; number or string?
                bne LD0A7                       ; brif string
                jsr LBDD9                       ; convert number to strng
                jsr LB516                       ; stash it as the current value
                jsr LB99F                       ; output the string
LD092           jsr GETCCH                      ; is there more?
                lbeq LB958                      ; brif not - do newline
                lda #',                         ; comma for non-tape separator
                jsr LA35F                       ; set print parameters
                tst PRTDEV                      ; tape?
                beq LD0A3                       ; brif not
                lda #0x0d                       ; carriage return for tape separator
LD0A3           bsr LD0B9                       ; send separator
                bra LD07F                       ; process another item
LD0A7           bsr LD0B0                       ; print leading string delimiter
                jsr LB99F                       ; print string
                bsr LD0B0                       ; print ending string delimiter
                bra LD092                       ; handle separator or next item
LD0B0           jsr LA35F                       ; set print parameters
                tst PRTDEV                      ; tape?
                bne LD06E                       ; brif so
                lda #'"                         ; string delimiter
LD0B9           jmp PUTCHR                      ; send character out
; FIELD command
FIELD           jsr LC82E                       ; evaluate device number and make sure it's a random file
                clra                            ; clear total field length counter
                clrb
                pshs x,b,a                      ; save field length and FCB pointer
LD0C3           jsr GETCCH                      ; are we at the end of the statement?
                bne LD0C9                       ; brif not
                puls a,b,x,pc                   ; clean up stack and return
LD0C9           jsr LB738                       ; evaluate comma and expression
                pshs x,b                        ; save field length (B) and make a hole for a temp
                clra                            ; zero extend length
                addd 3,s                        ; add in current accumulated size
                bcs LD0DA                       ; brif we overflowed
                ldx 5,s                         ; point to FCB
                cmpd FCBRLN,x                   ; have we overflowed the record?
                bls LD0DF                       ; brif not
LD0DA           ldb #34*2                       ; code for field overflow
                jmp LAC46                       ; raise error
LD0DF           ldu 3,s                         ; get old accumulated length
                std 3,s                         ; save new accumulated length
                ldd FCBBUF,x                    ; get start of random buffer
                leau d,u                        ; now U is the start of the field in the buffer
                stu 1,s                         ; save it so we can set string descriptor
                ldb #0xff                       ; insist on two byte "AS" token
                jsr LB26F
                ldb #0xa7
                jsr LB26F
                jsr LB357                       ; evaluate variable
                jsr LB146                       ; error if it's a number
                puls b,u                        ; get back field length and buffer address
                stb ,x                          ; put those in the string descriptor
                stu 2,x
                bra LD0C3                       ; look for another entry
; RSET command
RSET            skip1lda                        ; set nonzero for right justify and fall through
; LSET command
LSET            clra                            ; set zero to flag left justify
                pshs a                          ; save justification type
                jsr LB357                       ; evaluate variable
                jsr LB146                       ; make sure it's a string
                pshs x                          ; save descriptor address
                ldx 2,x                         ; get address of string data
                cmpx #DFLBUF                    ; is it below random buffer area?
                blo LD119                       ; brif below - throw error
                cmpx FCBADR                     ; is it above the random buffer area?
                blo LD11E                       ; brif not - it's good
LD119           ldb #2*35                       ; code for "set to non-fielded string"
                jmp LAC46                       ; raise error
LD11E           ldb #0xb3                       ; insist on =
                jsr LB26F
                jsr L8748                       ; evaluate string expression; return details
                puls y                          ; get back destination descriptor pointer
                lda ,y                          ; get length of field string
                beq LD15A                       ; brif empty destination
                pshs b                          ; save length of new string
                ldb #0x20                       ; pad characteris space
                ldu 2,y                         ; point to destination string
LD132           stb ,u+                         ; blank out string
                deca                            ; done yet?
                bne LD132                       ; brif not
                ldb ,s+                         ; get length of data string
                beq LD15A                       ; brif that one is NULL
                cmpb ,y                         ; is data string smaller than destination?
                blo LD143                       ; brif not
                ldb ,y                          ; get length of destination string as the copy length
                clr ,s                          ; we'll do left justify if string is longer
LD143           ldu 2,y                         ; get address of the destination
                tst ,s+                         ; left or right justify?
                beq LD157                       ; brif left set
                pshs b                          ; save number of bytes to move into field string
                clra                            ; get negation of that in D (do -DLEN+FLEN)
                negb
                sbca #0
                addb ,y                         ; then add string length of destination to it
                adca #0
                leau d,u                        ; now U points to destination offset
                puls b                          ; get back destination size
LD157           jmp LA59A                       ; copy data and return
LD15A           puls a,pc                       ; clean up stack and return
; FILES command
FILES           jsr L95AC                       ; reset video display
                ldd FCBADR                      ; get current size of buffer space
                subd #DFLBUF
                pshs d                          ; save it as the default size
                ldb FCBACT                      ; get number of available disk files
                pshs b                          ; save it as the default number
                jsr GETCCH                      ; get input character
                cmpa #',                        ; is numer of files specified?
                beq LD181                       ; brif not
                jsr EVALEXPB                    ; evaluate the number of files wanted
                cmpb #15                        ; we only allow 15
                lbhi LB44A                      ; raise error if too many
                stb ,s                          ; save number of FCBs to allocate
                jsr GETCCH                      ; see what's after the number
                beq LD189                       ; brif no buffer size specified
LD181           jsr SYNCOMMA                    ; insist on a comma
                jsr LB3E6                       ; evaluate buffer size
                ifeq DISKVER
                addd #1
                endc
                std 1,s                         ; save buffer size
LD189           jsr DVEC7                       ; close all disk files
                ldb ,s                          ; get number of files
                pshs b                          ; initialize the file number count
                ldd #DFLBUF                     ; point to start of random buffers
                addd 2,s                        ; add in size requested for buffer space
                bcs LD208                       ; raise error if we carry
                std 2,s                         ; save start of FCBs
LD199           addd #FCBLEN                    ; add size of one FCB
                bcs LD208                       ; brif we overflowed
                dec ,s                          ; added on for all files?
                bpl LD199                       ; brif not yet (BPL so we set up the system one as well)
                tstb                            ; are we at an even page boundary?
                ifeq DISKVER
                beq LD1AF                       ; brif so
                else
                beq LD1A8                       ; brif so
                endc
                inca                            ; round up
                beq LD208                       ; brif we overflowed
                ifeq DISKVER-1
LD1A8           bita #1                         ; on an even 512 byte boundary?
                beq LD1AF                       ; brif so
                inca                            ; round up
                beq LD208                       ; brif we overflowed
                endc
LD1AF           sta ,s                          ; save MSB of graphics memory
                ldd VARTAB                      ; get end of program
                suba GRPRAM                     ; subtract out start of graphics (D is now size of program and graphics)
                adda ,s                         ; add in the new start of graphics
                bcs LD208                       ; brif overflow
                tfr d,x                         ; save new top of program
                inca                            ; add some extra room for the stack
                beq LD208                       ; brif overflow
                cmpd FRETOP                     ; does it fit in memory?
                bhs LD208                       ; brif not
                deca                            ; restore actual top of program
                subd VARTAB                     ; get difference compared to the original top of program
                addd TXTTAB                     ; add that to the program start
                tfr d,y                         ; now Y is the new start of the program
                lda ,s                          ; get back start of graphics memory
                suba GRPRAM                     ; this gives difference between old graphics start and new grahpics start
                tfr a,b                         ; we need this twice
                adda BEGGRP                     ; set new start of active page
                sta BEGGRP
                addb ENDGRP                     ; set new end of active page
                stb ENDGRP
                puls a,b,u                      ; get back graphics start, number of files, and start of buffers
                sta GRPRAM                      ; set graphics memory start
                stb FCBACT                      ; set number of active FCBs
                stu FCBADR                      ; set start of FCBs
                ifeq DISKVER-1
                lda CURLIN                      ; in immediate mode?
                inca
                beq LD1EF                       ; brif so
                tfr y,d                         ; calculate how much the program is moving
                subd TXTTAB
                addd CHARAD                     ; adjust input pointer for the change
                std CHARAD
                endc
LD1EF           ldu VARTAB                      ; get old end of program
                stx VARTAB                      ; save new end of program
                cmpu VARTAB                     ; which way did it move?
                bhi LD20B                       ; brif it moved up
LD1F8           lda ,-u                         ; move a byte down
                sta ,-x
                cmpu TXTTAB                     ; at start?
                bne LD1F8                       ; brif not
                sty TXTTAB                      ; set new start of program
                clr -1,y                        ; make sure there's a NUL before the program
                bra LD21B                       ; clean up
LD208           jmp LAC44                       ; raise OM error
LD20B           ldu TXTTAB                      ; get old start of program
                sty TXTTAB                      ; save new start of program
                clr -1,y                        ; make sure there's a NUL before the program
LD212           lda ,u+                         ; move a byte up
                sta ,y+
                cmpy VARTAB                     ; at end yet?
                bne LD212                       ; brif not
LD21B           ldu #FCBV1                      ; point to FCB pointers
                ldx FCBADR                      ; point to start of FCBs
                clrb                            ; file counter
LD222           stx ,u++                        ; set FCB pointer
                clr <<FCBTYP,x                  ; mark FCB as closed
                leax FCBLEN,x                   ; point to next FCB
                incb                            ; bump file counter
                cmpb FCBACT                     ; do we have enough of them yet?
                bls LD222                       ; brif not (BLS so we include system FCB)
                jmp L96CB                       ; fix up line pointers, etc.
; UNLOAD command
UNLOAD          bsr LD24F                       ; get drive number
                clrb                            ; clear file counter
LD236           incb                            ; bump file counter
                jsr LC749                       ; point to FCB
                beq LD249                       ; brif file not open
                lda FCBDRV,x                    ; is it on the right drive?
                cmpa DCDRV
                bne LD249                       ; brif not
                pshs b                          ; save file counter
                jsr LCB06                       ; close the file
                puls b                          ; restore file counter
LD249           cmpb FCBACT                     ; done all files?
                bls LD236                       ; brif not (includes system FCB)
                rts
; Parse drive number; use default if none given
LD24F           ldb DEFDRV                      ; set default drive
                jsr GETCCH                      ; is there something there?
                beq LD25F                       ; brif not
LD256           jsr EVALEXPB                    ; evaluate drive number
                cmpb #3                         ; valid?
                lbhi LA61F                      ; brif not
LD25F           stb DCDRV                       ; set drive number
                rts
; BACKUP command
BACKUP          lbeq LA61F                      ; raise error if no drive numbers
                jsr L95AC                       ; reset display
                jsr LD256                       ; get source drive number
                stb DBUF0+255                   ; save it (we're going to put our stack in DBUF0)
                jsr GETCCH                      ; is there something else?
                beq LD27B                       ; brif not
                ldb #0xa5                       ; insist on TO
                jsr LB26F
                jsr LD256                       ; fetch destination drive
LD27B           lds #DBUF0+255                  ; put the stack somewhere safe (source drive number already there)
                pshs b                          ; save destination drive number
                jsr LA5C7                       ; bail of there's more
                jsr DVEC7                       ; close files
                clr ,-s                         ; initialize track counter
                ldx #DFLBUF-1                   ; point to start of the heap
LD28C           inc ,s                          ; bump track counter
                leax SECMAX*SECLEN,x            ; add a whole track to the count
                cmpx MEMSIZ                     ; does it fit in memory?
                bls LD28C                       ; brif so
                dec ,s                          ; decrement track counter
                lbeq LAC44                      ; error if less than one track memory available
                lda #TRKMAX                     ; get maximum number of tracks
                clrb                            ; set tracks copied to 0
                pshs a,b                        ; save track counters
                com DRESFL                      ; force a "reset" of the disk system
LD2A4           clrb                            ; initialize write counter
LD2A5           incb                            ; add one to track counter
                dec ,s                          ; whole disk done?
                beq LD2AE                       ; brif not
                cmpb 2,s                        ; will it fit in memory?
                bne LD2A5                       ; brif so
LD2AE           stb TMPLOC                      ; save number of tracks to copy
                ldb 4,s                         ; get source drive number
                bsr LD2FC                       ; read TMPLOC tracks
                lda #0xff                       ; set source/dest flag to dest
                jsr LD322                       ; show prompt if needed
                ldb 3,s                         ; get destination drive
                bsr LD2FF                       ; write TMPLOC tracks
                tst ,s                          ; is there anything left?
                beq LD2CD                       ; brif not - we're done
                clra                            ; set source/desetination to source
                jsr LD322                       ; show prompt
                ldb 1,s                         ; get tracks written
                addb TMPLOC                     ; account for the ones we just wrote
                stb 1,s                         ; save new written counter
                bra LD2A4                       ; go copy some more tracks
LD2CD           bsr LD2D2                       ; check for re-init
                jmp LAC73                       ; return to immediate mode
LD2D2           puls u                          ; get return address (we might be resetting the stack)
                lda DRESFL                      ; reset desired?
                beq LD2EF                       ; brif not
                ldx #FCBV1                      ; point to FCB addresses
                clra                            ; set file counter to 0
LD2DD           clr [,x++]                      ; mark FCB as closed
                inca                            ; bump file counter
                cmpa FCBACT                     ; end of allocated FCBs?
                bls LD2DD                       ; brif not
                ldx TXTTAB                      ; get start of program
                clr -1,x                        ; make sure there's a NUL there
                jsr LAD19                       ; do a "NEW"
                clr DRESFL                      ; mark reset as not needed
LD2EF           lda DLODFL                      ; were we loading something?
                beq LD2FA                       ; brif not
                clr DLODFL                      ; clear out the loading state
                jsr LAD19                       ; empty out the program
LD2FA           jmp ,u                          ; return to caller
LD2FC           lda #2                          ; opcode for read
                skip2
LD2FF           lda #3                          ; opcode for write
                std DCOPC                       ; save operation and drive number
                lda 3,s                         ; get number of the first track to write
                sta DCTRK                       ; tell DSKCON
                ldx #DFLBUF                     ; put track buffer at the start of the heap
                stx DCBPT
                lda TMPLOC                      ; get track counter
LD30E           ldb #1                          ; start at sector 1
LD310           stb DSEC                        ; set sector
                jsr LD6F2                       ; read or write a sector
                inc DCBPT                       ; bump buffer pointer
                incb                            ; bump sector number
                cmpb #SECMAX                    ; end of track?
                bls LD310                       ; brif not
                inc DCTRK                       ; bump track
                deca                            ; done all the tracks?
                bne LD30E                       ; brif not
                rts
LD322           ldb 5,s                         ; get destination drive number
                cmpb 6,s                        ; compare to source
LD326           bne LD35E                       ; brif no prompt needed
                clr RDYTMR                      ; reset drive motor
                clr DSKREG
                clr DRGRAM
                pshs a                          ; save source/dest flag
                jsr LA928                       ; clear screen
                ldx #LD35F                      ; point to "source"
                ldb #13                         ; 13 bytes
                lda ,s+                         ; set flags on source/dest flag
                beq LD344                       ; brif source
                ldx #LD36C                      ; point to "dest"
                ldb #18                         ; 18 bytes
LD344           jsr LB9A2                       ; display message
                ldx #LD37E                      ; point to remainder of message
                ldb #27                         ; 27 bytes
                jsr LB9A2                       ; display it
                ldd #0x6405                     ; set up SOUND parameters
                sta SNDTON
                jsr LA951                       ; do a beep
LD357           jsr LA171                       ; read generic input (shows cursor)
                cmpa #0x0d                      ; carriage return?
                bne LD357                       ; bri fnot
LD35E           rts
LD35F           fcc 'INSERT SOURCE'
LD36C           fcc 'INSERT DESTINATION'
LD37E           fcc ' DISKETTE AND'
                fcb 0x0d
                fcc "PRESS 'ENTER'"
; Save file name and extension on stack, and also the current drive number
LD399           puls y                          ; get return address
                ldb #11                         ; 11 characters for both name and extension
                ldx #DNAMBF+11                  ; point to end of buffer
LD3A0           lda ,-x                         ; fetch a file name character
                pshs a                          ; stuff it on the stack
                decb                            ; done yet?
                bne LD3A0                       ; brif not
                lda DCDRV                       ; save drive number
                pshs a
                jmp ,y                          ; return to caller
; Copy drive, filename, and extension from X to state
LD3AD           lda ,x+                         ; set drive number
                sta DCDRV
                ldb #11                         ; 11 characters in file name and extension
                ldu #DNAMBF                     ; point to disk file name buffer
                jmp LA59A                       ; copy the file name
; COPY command
; NOTE: an error during COPY will cause the system to hang due to the FCB's buffer pointer
; being moved out of normal buffer space.
COPY            jsr LC935                       ; get source file name
                bsr LD399                       ; save it on the stack
                clr ,-s                         ; set flag for "single disk" copy
                jsr GETCCH                      ; is there a destination?
                beq LD3CE                       ; brif not - single disk (swapping)
                com ,s                          ; set to "two parameter" copy
                ldb #0xa5                       ; insist on TO
                jsr LB26F
                jsr LC935                       ; parse the destination file name
LD3CE           bsr LD399                       ; save destination file name
                jsr LA5C7                       ; bail if more stuff
                jsr DVEC7                       ; close everything
                clr ,-s                         ; clear sector counter
                ifeq DISKVER
                leax -100,s                     ; leave a buffer below the stack
                else
                leax -SECLEN,s                  ; point one sector below the stack
                endc
LD3DC           inc ,s                          ; bump sector counter
                leax -SECLEN,x                  ; move back a sector
                cmpx ARYEND                     ; did we hit the top of variables?
                bhs LD3DC                       ; brif not
                dec ,s                          ; decrement off the last one that didn't fit
                lbeq LAC44                      ; brif not at least one sector free memory
                leax 14,s                       ; set up for source file name/drive
                bsr LD3AD
                jsr LC68C                       ; find file
                jsr LC6E5                       ; error if not found
                ldx V974                        ; get directory data pointer
                ldu DIRLST,x                    ; get file type and last sector data
                ldx DIRTYP,x
                pshs u,x                        ; save them
                jsr LC79D                       ; read FAT data
                ldb V976                        ; get first granule in file
                jsr LCD1E                       ; count granules in chain
                pshs a                          ; save number of granules in file
                deca                            ; subtract off last granule (may be partial)
                andb #0x3f                      ; get number of sectors in last granule
                pshs b                          ; save sectors in last granule
                tfr a,b                         ; zero extend to granule count to D
                clra
                jsr LC779                       ; get number of sectors in complete granules
                addb ,s                         ; add in partial sector count
                adca #0
                ldx #1                          ; initialize record counter to 1
                pshs x,b,a                      ; save record counter and sector counter
LD41E           clrb                            ; set sector counter to 0
                ldx ,s                          ; get number of sectors remaining in the file
                beq LD42C                       ; brif none left
LD423           incb                            ; add a sector to counter
                leax -1,x                       ; at bottom of file?
                beq LD42C                       ; brif so
                cmpb 10,s                       ; at maximum memory space?
                bne LD423                       ; brif not
LD42C           stx ,s                          ; save number of sectors that will be left after this iteration
                stb 4,s                         ; save number of sectors to be copied this time
                bsr LD482                       ; get sectors to buffer
                lda #0xff                       ; show swap message for dest
                bsr LD476
                tst 5,s                         ; do we need to test for enough free space?
                beq LD45F                       ; brif not
                leax 11,s                       ; retrieve destination file parameters
                jsr LD3AD
                jsr LD059                       ; find the file, AE error if it exists
                jsr LC79D                       ; get FAT data
                jsr LC755                       ; point to FAT
                leax FATCON,x                   ; point to granuledata
                lda 5,s                         ; get number of granules in file
                ldb #GRANMX                     ; maximum granules to check
LD44E           com ,x                          ; is granule free?
                bne LD455                       ; brif not
                deca                            ; found enough?
                beq LD45D                       ; brif not
LD455           com ,x+                         ; restore FAT data
                decb                            ; run through whole fat?
                bne LD44E                       ; brif not
                jmp LC7F8                       ; do "disk full"
LD45D           com ,x                          ; restore FAT data
LD45F           bsr LD47C                       ; put data from memory to destination file
                ldx ,s                          ; get number of sectors left
                beq LD472                       ; brif none - we're done
                ldd 2,s                         ; get current recordcounter
                addb 4,s                        ; add in number of sectors
                adca #0
                std 2,s                         ; save new record counter
                clra                            ; show source message if needed
                bsr LD476
                bra LD41E                       ; copy some more stuff
LD472           leas 36,s                       ; clean up stack
                rts
LD476           tst 25,s                        ; doing a "single disk" copy?
                jmp LD326                       ; show message if needed
; put or get data for copy
LD47C           lda #0xff                       ; put flag
                leax 13,s                       ; point to destination file
                bra LD486                       ; go do the write
LD482           clra                            ; get flag
                leax 26,s                       ; point to source file
LD486           sta VD8                         ; save get/put flag
                jsr LD3AD                       ; fetch file parameters from stack
                ldx 8,s                         ; get file type and ASCII flag
                stx DFLTYP                      ; save it
                ldx #SECLEN                     ; set record length to one sector
                stx DFFLEN
                lda #'R                         ; set type to "random"
                ldb FCBACT                      ; point to system FCB
                incb
                jsr LC48D
                ldx FCBTMP                      ; get FCB pointer
                ldd #SECLEN                     ; set number of bytes in last sector to one sector
                std FCBLST,x
                ldb 6,s                         ; get number of sectors to read/write
                beq LD4D4                       ; brif none
                ldb VD8                         ; get or put?
                andb 7,s                        ; is it first time on put?
                beq LD4BA                       ; brif not
                ldd 2,s                         ; get number of sectors remaining
                addb 6,s                        ; add to number copied this time
                adca #0
                jsr LC2E6                       ; put the last record in the file (this allocates the file)
LD4BA           ldx FCBTMP                      ; point to FCB
                ldu 4,s                         ; get current record number
                stu FCBREC,x                    ; save in FCB
                ldb 6,s                         ; get number of sectors to move
                ldu ARYEND                      ; point to start of free memory
LD4C4           pshs u,b                        ; save buffer pointer and counter
                ldx FCBTMP                      ; fetch FCB pointer
                stu FCBBUF,x                    ; set buffer to free memory (will cause hang on error)
                jsr LC2EA                       ; do get or put
                inc 1,s                         ; bump buffer pointer
                puls b,u                        ; get back buffer pointer and sector count
                decb                            ; done all yet?
                bne LD4C4                       ; brif not
LD4D4           ldx FCBTMP                      ; get FCB pointer
                ldu #DFLBUF                     ; reset buffer pointer to bottom of buffer area
                stu FCBBUF,x
                ldb VD8                         ; first time through on PUT?
                andb 7,s
                beq LD4EA                       ; brif not
                clr 7,s                         ; reset the "first time" flag
                ldd 10,s                        ; get bytes in last sector
                ora #0x80                       ; set "pre-save" flag
                std FCBLST,x                    ; set correct last sector size
LD4EA           jmp LCB06                       ; close the file
; DSKI$ command
DSKI            bsr LD527                       ; get drive, track, and sector
                bsr LD51C                       ; evaluate frist string sand save descriptor address
                pshs x
                bsr LD51C                       ; evaluate second string and save descriptor address
                pshs x
                ldb #2                          ; read operation
                jsr LD58F                       ; read sector
                ldu #DBUF0+128                  ; point to second half
                puls x                          ; get descriptor for second string
                bsr LD508                       ; stow second string
                ldu #DBUF0                      ; point to first half
                puls x                          ; get descriptor for first string
LD508           pshs u,x                        ; save source data and descriptor
                ldb #128                        ; do 128 bytes exactly
                jsr LB50F                       ; reserve space
                leau ,x                         ; point to reserved space
                puls x                          ; get string descriptor address
                stb ,x                          ; save length in descriptor
                stu 2,x                         ; save data pointer
                puls x                          ; get buffer pointer
LD519           jmp LA59A                       ; copy bytes to string
LD51C           jsr SYNCOMMA                    ; make sure there's a comma
                ldx #LB357                      ; point to variable evaluation routine
                bsr LD553                       ; evaluate variable
LD524           jmp LB146                       ; make sure we have a string
LD527           jsr EVALEXPB                    ; evaluate 8 bit expression
                cmpb #3                         ; valid drive?
                bhi LD54A                       ; brif not
                pshs b                          ; save it
                jsr LB738                       ; evaluate track expression (after a comma)
                cmpb #TRKMAX-1                  ; valid track?
                bhi LD54A                       ; brif not
                pshs b                          ; save track number
                jsr LB738                       ; evaluate comma followed by sector number
                stb DSEC                        ; set DSKCON variable
                decb                            ; zero-base it
                cmpb #SECMAX-1                  ; is it a valid sector?
                bhi LD54A                       ; brif not
                puls a,b                        ; get drive and track
                sta DCTRK                       ; set DSKCON
                stb DCDRV
                rts
LD54A           jmp LB44A                       ; raise FC error
LD54D           jsr SYNCOMMA                    ; insist on a comma
                ldx #LB156                      ; evaluate expression pointer
LD553           ldb DCDRV                       ; save drive, track, and sector values
                ldu DCTRK
                pshs u,b                        ; save them
                jsr ,x                          ; evaluate variable or expression
                puls b,u                        ; restore DSKCON
                stb DCDRV
                stu DCTRK
                rts
; DSKO$ command
DSKO            bsr LD527                       ; evaluate drive, track, and sector
                bsr LD54D                       ; evaluate string 1
                bsr LD524                       ; make sure it's a string
                ldx FPA0+2                      ; get descriptor address
                pshs x                          ; save it
                bsr LD54D                       ; evaluate string 2
                jsr LB654                       ; get string details
                pshs x,b                        ; save them
                clrb                            ; clear full sector (so junk doesn't get in if strings are short)
                ldx #DBUF0                      ; point to sector buffer
LD577           clr ,x+                         ; clear a byte
                decb                            ; done whole sector?
                bne LD577                       ; brif not
                puls b,x                        ; get string data
                ldu #DBUF0+128                  ; point to second half of sector
                bsr LD519                       ; copy string data (anything over 128 will go in second I/O buffer so harmless)
                puls x                          ; get first string
                jsr LB659                       ; fetch string details
                ldu #DBUF0                      ; point to start of sector buffer
                bsr LD519                       ; copy string data (this will overwrite up to 255 bytes!)
                ldb #3                          ; write operation
LD58F           ldx #DBUF0                      ; point to sector buffer
                stx DCBPT
                stb DCOPC                       ; set read/write
                jmp LD6F2                       ; go read/write sector
; DSKINI command
DSKINI          lbeq LA61F                      ; error if no drive number specified
                jsr LD256                       ; parse driven umber
                ldb #4                          ; default skip factor is 4
                jsr GETCCH                      ; is there a skip factor?
                beq LD5B2                       ; brif not
                jsr LB738                       ; evaluate comma followed by skip factor
                cmpb #17                        ; max value is 16
                lbhs LB44A                      ; brif too high
                jsr LA5C7                       ; carp if there's anything else
LD5B2           pshs b                          ; save skip factor
                ldx #DBUF1+SECMAX               ; poitn to end of sector number scratch area
                ldb #SECMAX                     ; get the maximum sector number
LD5B9           clr ,-x                         ; mark sector number unset
                decb                            ; done all of them?
                bne LD5B9                       ; brif not
                clra                            ; reset sector counter
                bra LD5CE                       ; start assigning sector numbers
LD5C1           addb ,s                         ; add in skip factor
LD5C3           incb                            ; bump sector number
LD5C4           subb #SECMAX                    ; remove a whole track worth
                bhs LD5C4                       ; brif we can still do more
                addb #SECMAX                    ; undo extra subtraction
                tst b,x                         ; has this sector been numbered?
                bne LD5C3                       ; brif so - try again on next one
LD5CE           inca                            ; bump sector number
                sta b,x                         ; set actual sector number
                cmpa #SECMAX                    ; done all?
                blo LD5C1                       ; brif not
                leas 1,s                        ; remove skip factor - we don't need it
                ldx #DFLBUF+0x1888-2            ; point to top of memory used by DSKINI (for track image)
                cmpx MEMSIZ                     ; does it fit?
                lbhi LAC44                      ; brif not
                jsr DVEC7                       ; close files
                com DRESFL                      ; cause reset of things
                lds #DBUF1+SECLEN               ; put stack somewhere safe
                jsr L95AC                       ; reset display
                lda #0                          ; restore head to track 0
                sta DCOPC
                ifeq DISKVER-1
                clr DCTRK                       ; set track number to 0 (used as a track counter for the format)
                endc
                jsr LD6F2                       ; restorehead to track 0
                clr RDYTMR                      ; don't allow motor to turn off
                lda #0xc0                       ; FDC read address code
                sta FDCREG                      ; instruct FDC
                jsr LD7D1                       ; wait until drive ready
                ifeq DISKVER
                lbne LD688                      ; brif drive not ready
                clr DCTRK                       ; reset track counter
                bra LD620                       ; go format tracks
                else
                beq LD620                       ; brif drive ready
                jmp LD688                       ; raise error if not ready
                endc
LD606           cmpa #22                        ; precomp?
                blo LD612                       ; brif not
                lda DRGRAM                      ; enable precomp
                ora #0x10
                sta DSKREG
LD612           lda #0x53                       ; "step in"
                sta FDCREG                      ; go do a step
                exg a,a                         ; wait for FDC status to stabilize
                exg a,a
                jsr LD7D1                       ; wait for ready
                bne LD688                       ; bri fnot ready - raise error
LD620           jsr LD7F0                       ; wait for a bit
                bsr LD691                       ; build formatted track
                ldy #FDCREG+3                   ; point to data register
                orcc #0x50                      ; disable interrupts
                ldx #LD64F                      ; where to return to
                stx DNMIVC                      ; set up NMI escaper
                ldx #DFLBUF                     ; point to track image
                lda FDCREG                      ; reset status of FDC
                lda #0xff                       ; enable NMI escaper
                sta NMIFLG
                ldb #0xf4                       ; write track command
                stb FDCREG                      ; instruct FDC
                lda DRGRAM                      ; enable HALT
                ora #0x80
                sta DSKREG
LD649           ldb ,x+                         ; fetch track byte
                stb ,y                          ; stuff it out to FDC
                bra LD649                       ; do another ASAP (HALT will clock this)
LD64F           lda FDCREG                      ; fetch status
                andcc #0xaf                     ; restore interrupts
                anda #0x44                      ; keep only write protect and lost data
                sta DCSTA                       ; save status
                bne LD688                       ; brif error
                inc DCTRK                       ; bump track number
                lda DCTRK                       ; done all tracks?
                cmpa #TRKMAX
                bne LD606                       ; brif not
                lda #2                          ; DSKCON read operation
                sta DCOPC
                ldx #DBUF0                      ; point to disk buffer
                stx DCBPT
                ldu #DBUF1                      ; point to sector numbers
                clra                            ; reset track counter
LD66F           sta DCTRK                       ; set track
                clrb                            ; reset sector counter
LD672           lda b,u                         ; get real sector number
                sta DSEC                        ; tell DSKCON
                jsr LD6F2                       ; read a sector
                incb                            ; bump sector counter
                cmpb #SECMAX                    ; done whole track?
                blo LD672                       ; brif not
                lda DCTRK                       ; get track number
                inca                            ; bump it
                cmpa #TRKMAX                    ; done all?
                blo LD66F                       ; brif not
                jmp LD2CD                       ; do the reset thing if needed
LD688           clr DRGRAM                      ; stop drive motors and selects
                clr DSKREG
                jmp LD701                       ; wait for ready signal
LD691           ldx #DFLBUF                     ; point to track buffer
                ldd #0x204e                     ; write out 32 * 0x4e
                bsr LD6C2
                clrb                            ; reset sector counter
LD69A           pshs b                          ; save sector counter
                ldu #DBUF1                      ; point to sector numbers
                ldb b,u                         ; get real sector number
                stb DSEC                        ; save it
                ldu #LD6D4                      ; point to format table for a sector
                ldb #3                          ; process three blocks
                bsr LD6C8
                lda DCTRK                       ; save track number
                sta ,x+
                clr ,x+                         ; set side number to 0
                lda DSEC                        ; set sector number
                sta ,x+
                ldb #9                          ; process 9 blocks
                bsr LD6C8
                puls b                          ; get sector counter
                incb                            ; bump it
                cmpb #SECMAX                    ; done all?
                blo LD69A                       ; brif not - do another sector
                ldd #0xc84e                     ; write 200 times 0x4e for track trailer
LD6C2           stb ,x+                         ; stow a byte
                deca                            ; done enough?
                bne LD6C2                       ; brif not
                rts
LD6C8           pshs b                          ; save item counter
                ldd ,u++                        ; get count and data byte
                bsr LD6C2                       ; process it
                puls b                          ; get item count back
                decb                            ; done all?
                bne LD6C8                       ; brif not
                rts
LD6D4           fcb 8,0                         ; SYNC field
                fcb 3,0xf5
                fcb 1,0xfe                      ; address mark
                ; track, side, sector here
                fcb 1,1                         ; sector size flag
                fcb 1,0xf7                      ; CRC request
                fcb 22,0x4e                     ; post-ID gap
                fcb 12,0                        ; sync field
                fcb 3,0xf5
                fcb 1,0xfb                      ; data address mark
                fcb 0,0xff                      ; default track data
                fcb 1,0xf7                      ; CRC request
                fcb 24,0x4e                     ; post data gap
                ifeq DISKVER-1
; DOS command
DOS             bne LD742                       ; brif argument given
                jmp [DOSVEC]                    ; transfer control to DOS command
                endc
; General sector read/write routine; this implements VERIFY on write and does several retries
LD6F2           pshs b                          ; save register
                ldb #5                          ; we'll try 5 times on VERIFY failure
                stb ATTCTR
                puls b                          ; restore register
LD6FB           bsr DSKCON                      ; execute command
                tst DCSTA                       ; success?
                beq LD70E                       ; brif so
LD701           lda DCSTA                       ; get status
                ldb #2*30                       ; code for write protect
                bita #0x40                      ; was it write protected?
                bne LD70B                       ; brif so
LD709           ldb #2*20                       ; I/O error code
LD70B           jmp LAC46                       ; raise error
LD70E           pshs a                          ; save A
                lda DCOPC                       ; was it write?
                cmpa #3
                puls a                          ; restore register
                bne LD742                       ; brif not
                tst DVERFL                      ; verify?
                beq LD742                       ; brif not
                pshs u,x,b,a                    ; save registers
                lda #2                          ; set for read
                sta DCOPC
                ldu DCBPT                       ; get original buffer pointer
                ldx #DBUF1                      ; point to secondary buffer
                stx DCBPT
                bsr DSKCON                      ; read the sector
                stu DCBPT                       ; restore buffer pointer
                lda #3                          ; restore write operation
                sta DCOPC
                lda DCSTA                       ; did we have a problem?
                bne LD743                       ; brif so
                clrb                            ; check 256 bytes
LD737           lda ,x+                         ; compare two bytes
                cmpa ,u+
                bne LD743                       ; brif no match - error
                decb                            ; done all?
                bne LD737                       ; brif not
                puls a,b,x,u                    ; restore registers
LD742           rts
LD743           puls a,b,x,u                    ; restore registers
                dec ATTCTR                      ; tried enough times?
                bne LD6FB                       ; brif not - try again
                ldb #2*36                       ; code for verify error
                bra LD70B                       ; raise error
; VERIFY command
VERIFY          clrb                            ; off flag
                cmpa #0xaa                      ; OFF?
                beq LD75A                       ; brif so
                comb                            ; set to on flag
                cmpa #0x88                      ; ON?
                lbne LB277                      ; brif not - raise error
LD75A           stb DVERFL                      ; set verify state
                jmp GETNCH                      ; eat the ON/OFF and return
; DSKCON - the main disk I/O driver
DSKCON          pshs u,y,x,b,a                  ; save registers
                lda #5                          ; retry 5 times
                pshs a                          ; save retry counter
LD765           clr RDYTMR                      ; reset drive timeout (so drive won't turn off if it's already on)
                ldb DCDRV                       ; get drive number
                ldx #LD89D                      ; point to drive enable masks
                lda DRGRAM                      ; get control register value
                anda #0xa8                      ; keep only motor, halt, double density
                ora b,x                         ; set drive select lines
                ora #0x20                       ; set double density
                ldb DCTRK                       ; get desired track
                cmpb #22                        ; precomp?
                blo LD77E                       ; brif not
                ora #0x10                       ; enable precomp
LD77E           tfr a,b                         ; save image prior to enabling motors
                ora #8                          ; turn on motors
                sta DRGRAM                      ; actuall do all that stuff above
                sta DSKREG
                bitb #8                         ; were motors already on?
                bne LD792                       ; brif so - don't wait
                jsr LA7D1                       ; wait quite a while
                jsr LA7D1                       ; wait quite a while longer
LD792           bsr LD7D1                       ; wait until read
                bne LD7A0                       ; brif timed out
                clr DCSTA                       ; clear status (set no error)
                ldx #LD895                      ; point to command jump table
                ldb DCOPC                       ; get operation code
                aslb                            ; two bytes per routine address
                jsr [b,x]                       ; do operation
LD7A0           puls a                          ; get back retry count
                ldb DCSTA                       ; get status
                beq LD7B1                       ; brif no error
                deca                            ; retried enough?
                beq LD7B1                       ; brif so
                pshs a                          ; save retry counter again
                bsr LD7B8                       ; restore head to track 0
                bne LD7A0                       ; brif error
                bra LD765                       ; try command again
LD7B1           lda #120                        ; drive timeout is 120 VSYNC ticks (2 seconds for 60Hz)
                sta RDYTMR
                puls a,b,x,y,u,pc               ; restore registers and return
LD7B8           ldx #DR0TRK                     ; point to track table
                ldb DCDRV                       ; get drive number
                clr b,x                         ; mark drive on track 0
                lda #3                          ; restore head to track 0, unloaded, 30ms step
                sta FDCREG                      ; go do it
                exg a,a                         ; wait for status to stabilize
                exg a,a
                bsr LD7D1                       ; wait for ready
                bsr LD7F0                       ; wait somemore
                anda #0x10                      ; keep only seek error
                sta DCSTA                       ; set result
LD7D0           rts
LD7D1           ldx ZERO                        ; get timeout counter
LD7D3           leax -1,x                       ; count down
                beq LD7DF                       ; brif timed out
                lda FDCREG                      ; get status
                bita #1                         ; is it ready?
                bne LD7D3                       ; brif not
                rts
LD7DF           lda #0xd0                       ; force interrupt
                sta FDCREG
                exg a,a                         ; wait for status to stabilize
                exg a,a
                lda FDCREG                      ; clear status
                lda #0x80                       ; return not ready status
                sta DCSTA
                rts
LD7F0           ldx #8750                       ; delay for about half of a long while
LD7F3           leax -1,x                       ; count down
                bne LD7F3                       ; brif not done
                rts
LD7F8           lda #0x80                       ; code for read sector
                skip2
LD7FB           lda #0xa0                       ; code for write sector
                pshs a                          ; save operation
                ldx #DR0TRK                     ; point to track state table
                ldb DCDRV                       ; get drive number
                abx                             ; point to correct drive table
                ldb ,x                          ; get current track number
                stb FDCREG+1                    ; tell FDC about it
                cmpb DCTRK                      ; is it the one we want?
                beq LD82C                       ; brif so - no stepping needed
                lda DCTRK                       ; get desired track
                sta FDCREG+3                    ; tell the FDC that too
                sta ,x                          ; record that drive is there
                lda #0x17                       ; seek to desired track, unloaded, 30ms step, verify destination
                sta FDCREG
                exg a,a                         ; wait for status to be stable
                exg a,a
                bsr LD7D1                       ; wait for ready
                bne LD82A                       ; brif timed out
                bsr LD7F0                       ; wait some more
                anda #0x18                      ; keep only seek error or CRC error in ID
                beq LD82C                       ; brif no errors
                sta DCSTA                       ; save error state
LD82A           puls a,pc                       ; clean up stack and return
LD82C           lda DSEC                        ; get desired sector
                sta FDCREG+2                    ; tell FDC
                ldx #LD88B                      ; point to escape routine
                stx DNMIVC                      ; set up NMI escaper
                ldx DCBPT                       ; point to I/O buffer
                lda FDCREG                      ; reset FDC status
                lda DRGRAM                      ; get control register image
                ora #0x80                       ; enable HALT
                puls b                          ; get operation code
                ldy ZERO                        ; timeout value
                ldu #FDCREG                     ; point to FDC
                com NMIFLG                      ; enable escaper
                orcc #0x50                      ; disable interrupts
                stb FDCREG                      ; give FDC its marching orders
                exg a,a                         ; wait for stable status
                exg a,a
                cmpb #0x80                      ; read?
                beq LD875                       ; brif so
                ldb #2                          ; DRQ mask
LD85B           bitb ,u                         ; is it ready for a byte?
                bne LD86B                       ; brif not
                leay -1,y                       ; timed out?
                bne LD85B                       ; brif not
LD863           clr NMIFLG                      ; disable NMI escaper
                andcc #0xaf                     ; enable interrupts
                jmp LD7DF                       ; force interrupt, etc.
LD86B           ldb ,x+                         ; get byte from buffer
                stb FDCREG+3                    ; send it out
                sta DSKREG                      ; reprogram control register
                bra LD86B                       ; send more
LD875           ldb #2                          ; DRQ mask bit
LD877           bitb ,u                         ; is a byte ready?
                bne LD881                       ; brif not
                leay -1,y                       ; timed out?
                bne LD877                       ; brif not
                bra LD863                       ; bail out
LD881           ldb FDCREG+3                    ; get input data
                stb ,x+                         ; put in buffer
                sta DSKREG                      ; reprogram control register
                bra LD881                       ; read more
LD88B           andcc #0xaf                     ; enable interrupts
                lda FDCREG                      ; get status from FDC
                anda #0x7c                      ; keep write protect, write fault, not found, CRC, or lost data
                sta DCSTA                       ; set status
                rts
LD895           fdb LD7B8                       ; reset head to track 0
                fdb LD7D0                       ; no-op - just spin up drives
                fdb LD7F8                       ; read sector
                fdb LD7FB                       ; write sector
LD89D           fcb 0x01                        ; drive select 0
                fcb 0x02                        ; drive select 1
                fcb 0x04                        ; drive select 2
                fcb 0x40                        ; drive select 3/side select
; NMI handler
DNMISV          lda NMIFLG                      ; is the escaper enabled?
                beq LD8AE                       ; brif not
                ldx DNMIVC                      ; set return to escape hatch
                stx 10,s
                clr NMIFLG                      ; disable escaper now that we used it
LD8AE           rti
; Disk IRQ handler
DIRQSV          lda PIA0+3                      ; is it VSYNC?
                bpl LD8AE                       ; brif HSYNC
                lda PIA0+2                      ; clear interrupt status
                lda RDYTMR                      ; are drives waiting to stop?
                beq LD8CD                       ; brif not
                deca                            ; count down a tick
                sta RDYTMR                      ; save new count
                bne LD8CD                       ; brif they haven't timed out yet
                lda DRGRAM                      ; get control register image
                anda #0xb0                      ; turn off motors and drive selects
                sta DRGRAM
                sta DSKREG
LD8CD           jmp L8955                       ; transfer control to Extended Basic's handler
                ifeq DISKVER-1
; From here to the DOS command is unused
                fcb 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
                fcb 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
                fcb 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
                fcb 0x13,0x34,0x06,0x9D,0xA5,0x27,0x03,0xBD,0x95,0x81,0x96,0xB5,0x97,0xD8,0x35,0x06
                fcb 0xDD,0xB4,0x4F,0x34,0x56,0xBD,0x95,0x22,0xBD,0x92,0x8F,0xDF,0xD9,0xBD,0x99,0xDF
                fcb 0x27,0x0F,0xBD,0x99,0xCB,0x86,0x01,0x97,0xD7,0xBD,0x99,0xBA,0x00,0xD7,0xBD,0x99
                fcb 0xBA,0x10,0xDF,0xDC,0x0D,0xDB,0x26,0x03,0x10,0xDE,0xDC,0x35,0x56,0x0F,0xDB,0x10
                fcb 0xDF,0xDC,0x30,0x01,0x9F,0xBD,0xDF,0xD1,0x97,0xD7,0x27,0x9F,0x2B,0x06,0x5C,0xD1
                fcb 0xD6,0x23,0x05,0x5F,0x5D,0x27,0xDD,0x5A,0xD7,0xC0,0xBD,0x99,0xDF,0x27,0x0F,0x10
                fcb 0x83,0x00,0x03,0x25,0x04,0x30,0x1E,0x8D,0x38,0xBD,0x99,0xCB,0x8D,0x4C,0x43,0x53
                fcb 0xD3,0xD1,0xDD,0xD1,0x2F,0x16,0xBD,0x95,0x06,0xBD,0x9A,0x12,0x26,0x05,0xCC,0xFF
                fcb 0xFF,0x20,0xED,0xBD,0x95,0x14,0x8D,0x3E,0x8D,0x5E,0x20,0xE0,0xBD,0x95,0x06,0x30
                fcb 0x8B,0x9F,0xBD,0x43,0x53,0x83,0x00,0x01,0x2F,0x04,0x1F,0x01,0x8D,0x03,0x7E,0x99
                fcb 0x34,0xDD,0xCB,0x35,0x20,0xDC,0xBD,0x34,0x16,0x96,0xD7,0x40,0xD6,0xC0,0x34,0x06
                fcb 0x34,0x20,0xC6,0x02,0xBD,0xAC,0x33,0xDC,0xCB,0x39,0xDD,0xCB,0x35,0x20,0xDC,0xC3
                fcb 0x34,0x16,0x96,0xD7,0x20,0xE6,0x9E,0xBD,0x9F,0xC3,0x39,0xDD,0xCD,0x10,0x9E,0xC3
                fcb 0x8D,0xF4,0x10,0x9F,0xBD,0x8D,0x11,0x9E,0xCD,0x30,0x8B,0xC3,0x00,0x01,0x39,0xBD
                fcb 0x99,0xC6,0x10,0x8E,0x95,0x14,0x20,0x06,0x10,0x8E,0x95,0x06,0xAD,0xA4,0xDE,0x8A
                fcb 0x9E,0xBD,0x2B,0x17,0x9C,0xD3,0x22,0x13,0x34,0x60,0x8D,0x16,0x27,0x0B,0xBD,0x93
                fcb 0x77,0x35,0x60,0x33,0x41,0xAD,0xA4,0x20,0xE9,0x35,0x60,0x1F,0x30,0x1F,0x01,0x93
                fcb 0x8A,0x39,0xAD,0x9F,0x00,0xD9,0x1F,0x89,0xD4,0xD8,0x34,0x06,0xA4,0x84,0xA1,0x61
                fcb 0x35,0x86,0x9E,0x8A,0xC6,0x01,0x34,0x14,0xBD,0xB1,0x56,0x5F,0xBD,0xA9,0xA2,0xBD
                fcb 0xA9,0x76,0xBD,0xB6,0x54,0x20,0x02,0x35,0x14,0xD7,0xD8,0x27,0xFA,0x9F,0xD9,0x10
                fcb 0x27,0x0F,0x31,0x0D,0xD8,0x27,0xF0,0xBD,0x9B,0x98,0x81,0x3B,0x27,0xF5,0x81,0x27
                fcb 0x27,0xF1,0x81,0x58,0x10,0x27,0x01,0xB2,0x8D,0x02,0x20,0xE7,0x81,0x4F,0x26,0x0D
                fcb 0xD6,0xDE,0x5C,0x8D,0x5B,0x5A,0xC1,0x04,0x22,0x63,0xD7,0xDE,0x39,0x81,0x56,0x26
                fcb 0x1A,0xD6,0xDF,0x54,0x54,0xC0,0x1F,0x8D,0x47,0xC1,0x1F,0x22,0x50,0x58,0x58,0x34
                fcb 0x04,0xCC,0x7E,0x7E,0xAB,0xE4,0xE0,0xE0,0xDD,0xDF,0x39,0x81,0x4C,0x26,0x23,0xD6
                fcb 0xE1,0x8D,0x2D,0x5D,0x27,0x37,0xD7,0xE1,0x0F,0xE5,0x8D,0x03,0x24,0xFC,0x39,0x0D
                fcb 0xD8,0x27,0x0A,0xBD,0x9B,0x98,0x81,0x2E,0x27,0x05,0xBD,0x9B,0xE2,0x43,0x39,0x0C
                fcb 0xE5,0x39,0x81,0x54,0x26,0x0D,0xD6,0xE2,0x8D,0x06,0x5D,0x27,0x10,0xD7,0xE2,0x39
                fcb 0x7E,0x9B,0xAC,0x81,0x50,0x26,0x24,0xBD,0x9C,0xCB,0x5D,0x26,0x03,0x7E,0xB4,0x4A
                fcb 0x96,0xE5,0x9E,0xDF,0x34,0x12,0x86,0x7E,0x97,0xDF,0x97,0xE0,0x0F,0xE5,0x8D,0x07
                fcb 0x35,0x12,0x97,0xE5,0x9F,0xDF,0x39,0x6F,0xE2,0x20,0x40,0x81,0x4E,0x26,0x03,0xBD
                fcb 0x9B,0x98,0x81,0x41,0x25,0x04,0x81,0x47,0x23,0x05,0xBD,0x9B,0xBE,0x20,0x23,0x80
                fcb 0x41,0x8E,0x9C,0x5B,0xE6,0x86,0x0D,0xD8,0x27,0x18,0xBD,0x9B,0x98,0x81,0x23,0x27
                fcb 0x04,0x81,0x2B,0x26,0x03,0x5C,0x20,0x0A,0x81,0x2D,0x26,0x03,0x5A,0x20,0x03,0xBD
                fcb 0x9B,0xE2,0x5A,0xC1,0x0B,0x22,0xA6,0x34,0x04,0xD6,0xE1,0x96,0xE2,0x3D,0xDD,0xD5
                fcb 0x33,0x61,0x96,0xDE,0x81,0x01,0x22,0x2C,0x8E,0x9C,0x62,0xC6,0x18,0x3D,0x3A,0x35
                fcb 0x04,0x58,0x3A,0x31,0x84,0x8D,0x45,0xDD,0xE3,0x8D,0x0C,0x96,0xDF,0x8D,0x0B,0x8D
                fcb 0x06,0x96,0xE0,0x8D,0x05,0x20,0xF2,0x86,0x7E,0x12,0xB7,0xFF,0x20,0xAE,0xA4,0x30
                fcb 0x1F,0x26,0xFC,0x39,0x8E,0x9C,0x7A,0xC6,0x0C,0x3D,0x3A,0x35,0x04,0x3A,0x8D,0x1C
                fcb 0xDD,0xE3,0x8D,0x0C,0x96,0xDF,0x8D,0x0B,0x8D,0x06,0x96,0xE0,0x8D,0x05,0x20,0xF2
                fcb 0x86,0x7E,0x12,0xB7,0xFF,0x20,0xA6,0x84,0x4A,0x26,0xFD,0x39,0xC6,0xFF,0x96,0xE5
                fcb 0x27,0x05,0x8B,0x02,0x3D,0x44,0x56,0x39,0x34,0x10,0x0D,0xD8,0x27,0x4D,0x9E,0xD9
                fcb 0xA6,0x80,0x9F,0xD9,0x0A,0xD8,0x81,0x20,0x27,0xF0,0x35,0x90,0x8D,0xEA,0x81,0x2B
                fcb 0x27,0x3C,0x81,0x2D,0x27,0x3C,0x81,0x3E,0x27,0x42,0x81,0x3C,0x27,0x39,0x81,0x3D
                fcb 0x27,0x3F,0xBD,0x90,0xAA,0x25,0x24,0x5F,0x80,0x30,0x97,0xD7,0x86,0x0A,0x3D,0x4D
                fcb 0x26,0x19,0xDB,0xD7,0x25,0x15,0x0D,0xD8,0x27,0x17,0xBD,0x9B,0x98,0xBD,0x90,0xAA
                fcb 0x24,0xE6,0x0C,0xD8,0x9E,0xD9,0x30,0x1F,0x9F,0xD9,0x39,0x7E,0xB4,0x4A,0x5C,0x27
                fcb 0xFA,0x39,0x5D,0x27,0xF6,0x5A,0x39,0x5D,0x27,0xF1,0x54,0x39,0x5D,0x2B,0xEC,0x58
                fcb 0x39,0x34,0x60,0x8D,0x16,0xBD,0xB7,0x0E,0x35,0xE0,0xBD,0x9C,0x1B,0xC6,0x02,0xBD
                fcb 0xAC,0x33,0xD6,0xD8,0x9E,0xD9,0x34,0x14,0x7E,0x9A,0x32,0x9E,0xD9,0x34,0x10,0xBD
                fcb 0x9B,0x98,0xBD,0xB3,0xA2,0x25,0xC4,0xBD,0x9B,0x98,0x81,0x3B,0x26,0xF9,0x35,0x10
                fcb 0xDE,0xA6,0x34,0x40,0x9F,0xA6,0xBD,0xB2,0x84,0x35,0x10,0x9F,0xA6,0x39,0x4F,0x1F
                fcb 0x8B,0xDC,0xE3,0x10,0x27,0x0D,0x74,0x93,0xD5,0xDD,0xE3,0x22,0x0D,0x0F,0xE3,0x0F
                fcb 0xE4,0x35,0x02,0x10,0xEE,0x67,0x84,0x7F,0x34,0x02,0x3B,0x0A,0x0C,0x01,0x03,0x05
                fcb 0x06,0x08,0x01,0xA8,0x01,0x90,0x01,0x7A,0x01,0x64,0x01,0x50,0x01,0x3D,0x01,0x2B
                fcb 0x01,0x1A,0x01,0x0A,0x00,0xFB,0x00,0xED,0x00,0xDF,0x00,0xD3,0x00,0xC7,0x00,0xBB
                fcb 0x00,0xB1,0x00,0xA6,0x00,0x9D,0x00,0x94,0x00,0x8B,0x00,0x83,0x00,0x7C,0x00,0x75
                fcb 0x00,0x6E,0xA6,0x9C,0x93,0x8B,0x83,0x7B,0x74,0x6D,0x67,0x61,0x5B,0x56,0x51,0x4C
                fcb 0x47,0x43,0x3F,0x3B,0x37,0x34,0x31,0x2E,0x2B,0x28,0x26,0x23,0x21,0x1F,0x1D,0x1B
                fcb 0x19,0x18,0x16,0x14,0x13,0x12,0x9E,0x8A,0xC6,0x01,0x34,0x14,0xD7,0xC2,0x9F,0xD5
                fcb 0xBD,0x95,0x9A,0xBD,0xB1,0x56,0xBD,0xB6,0x54,0x20,0x08,0xBD,0x9B,0x98,0x7E,0x9B
                fcb 0xBE,0x35,0x14,0xD7,0xD8,0x27,0xFA,0x9F,0xD9,0x10,0x27,0x00,0xEA,0x0D,0xD8,0x27
                fcb 0xF0,0xBD,0x9B,0x98,0x81,0x3B,0x27,0xF5,0x81,0x27,0x27,0xF1,0x81,0x4E,0x26,0x04
                fcb 0x03,0xD5,0x20,0xE9,0x81,0x42,0x26,0x04,0x03,0xD6,0x20,0xE1,0x81,0x58,0x10,0x27
                fcb 0x00,0x96,0x81,0x4D,0x10,0x27,0x01,0x2A,0x34,0x02,0xC6,0x01,0x0D,0xD8,0x27,0x11
                fcb 0xBD,0x9B,0x98,0xBD,0xB3,0xA2,0x34,0x01,0xBD,0x9B,0xE2,0x35,0x01,0x24,0x02,0x8D
                fcb 0xAA,0x35,0x02,0x81,0x43,0x27,0x28,0x81,0x41,0x27,0x2E,0x81,0x53,0x27,0x32,0x81
                fcb 0x55,0x27,0x5C,0x81,0x44,0x27,0x55,0x81,0x4C,0x27,0x4C,0x81,0x52,0x27,0x43,0x80
                fcb 0x45,0x27,0x2F,0x4A,0x27,0x27,0x4A,0x27,0x32,0x4A,0x27,0x1D,0x7E,0xB4,0x4A,0xBD
                fcb 0x95,0x5D,0xD7,0xB2,0xBD,0x95,0x9A,0x20,0x84,0xC1,0x04,0x24,0xEF,0xD7,0xE8,0x20
                fcb 0xF6,0xC1,0x3F,0x24,0xE7,0xD7,0xE9,0x20,0xEE,0x4F,0x8D,0x58,0x21,0x4F,0x1F,0x01
                fcb 0x20,0x59,0x4F,0x1F,0x01,0x8D,0x4D,0x1E,0x01,0x20,0x50,0x4F,0x1F,0x01,0x8D,0x44
                fcb 0x20,0x49,0x4F,0x9E,0x8A,0x20,0x44,0x4F,0x8D,0x3A,0x20,0xF7,0x4F,0x20,0x03,0x4F
                fcb 0x8D,0x32,0x9E,0x8A,0x1E,0x10,0x20,0x33,0xBD,0x9C,0x1B,0xC6,0x02,0xBD,0xAC,0x33
                fcb 0xD6,0xD8,0x9E,0xD9,0x34,0x14,0x7E,0x9C,0xC6,0xD6,0xE9,0x27,0x1B,0x4F,0x1E,0x01
                fcb 0xA7,0xE2,0x2A,0x02,0x8D,0x0D,0xBD,0x9F,0xB5,0x1F,0x30,0x44,0x56,0x44,0x56,0x6D
                fcb 0xE0,0x2A,0x04,0x40,0x50,0x82,0x00,0x39,0x1F,0x10,0x39,0x34,0x06,0x8D,0xDA,0x35
                fcb 0x10,0x34,0x06,0x8D,0xD4,0x35,0x10,0x10,0x9E,0xE8,0x34,0x20,0x6D,0xE4,0x27,0x08
                fcb 0x1E,0x10,0x8D,0xDF,0x6A,0xE4,0x20,0xF4,0x35,0x20,0xDE,0x8A,0xD3,0xC7,0x2B,0x02
                fcb 0x1F,0x03,0x1F,0x10,0x9E,0x8A,0xD3,0xC9,0x2B,0x02,0x1F,0x01,0x11,0x83,0x01,0x00
                fcb 0x25,0x03,0xCE,0x00,0xFF,0x8C,0x00,0xC0,0x25,0x03,0x8E,0x00,0xBF,0xDC,0xC7,0xDD
                fcb 0xBD,0xDC,0xC9,0xDD,0xBF,0x9F,0xC5,0xDF,0xC3,0x0D,0xD5,0x26,0x04,0x9F,0xC9,0xDF
                fcb 0xC7,0xBD,0x94,0x20,0x0D,0xD6,0x26,0x03,0xBD,0x94,0xA1,0x0F,0xD5,0x0F,0xD6,0x7E
                fcb 0x9C,0xDD,0xBD,0x9B,0x98,0x34,0x02,0xBD,0x9E,0x5E,0x34,0x06,0xBD,0x9B,0x98,0x81
                fcb 0x2C,0x10,0x26,0xFF,0x07,0xBD,0x9E,0x5B,0x1F,0x01,0x35,0x40,0x35,0x02,0x81,0x2B
                fcb 0x27,0x04,0x81,0x2D,0x26,0xA6,0x1F,0x30,0x7E,0x9D,0xCB,0xBD,0x9B,0x98,0x81,0x2B
                fcb 0x27,0x07,0x81,0x2D,0x27,0x04,0xBD,0x9B,0xE2,0x4F,0x34,0x02,0xBD,0x9C,0xCB,0x35
                fcb 0x02,0x4D,0x27,0x04,0x4F,0x50,0x82,0x00,0x39,0x00,0x00,0x00,0x01,0xFE,0xC5,0x19
                fcb 0x19,0xFB,0x16,0x31,0xF2,0xF4,0xFB,0x4A,0x51,0xEC,0x84,0x61,0xF9,0xE1,0xC7,0x78
                fcb 0xAE,0xD4,0xDC,0x8E,0x3B,0xC5,0xE5,0xA2,0x69,0xB5,0x06,0xB5,0x06,0x81,0x40,0x26
                fcb 0x02,0x9D,0x9F,0xBD,0x95,0x22,0xBD,0x93,0xB2,0xBD,0x93,0x1D,0xAE,0xC4,0x9F,0xCB
                fcb 0xAE,0x42,0x9F,0xCD,0xBD,0xB2,0x6D,0xBD,0xB7,0x3D,0xCE,0x00,0xCF,0xAF,0xC4,0xBD
                fcb 0x93,0x20,0x86,0x01,0x97,0xC2,0xBD,0x95,0x81,0x8E,0x01,0x00,0x9D,0xA5,0x27,0x0F
                fcb 0xBD,0xB2,0x6D,0xBD,0xB1,0x41,0x96,0x4F,0x8B,0x08,0x97,0x4F,0xBD,0xB7,0x40,0x96
                fcb 0xB6,0x85,0x02,0x27,0x04,0x1F,0x10,0x30,0x8B,0x9F,0xD1,0xC6,0x01,0xD7,0xC2,0xD7
                fcb 0xD8,0xBD,0x9F,0xE2,0x34,0x06,0xBD,0x9F,0xE2,0xDD,0xD9,0x35,0x06,0x34,0x06,0x9E
; The actual implementation of the DOS command follows; presumably this is here because it was
; implemented by a different group of people given that it doesn't call DSKCON directly and uses
; the DSKCON variables pointer as well.
DOSCOM          swi3                            ; do a software interrupt for some reason (why?)
                clr TMPLOC                      ; reset sector counter
                ldd #DOSBUF                     ; initialize load address for boot track
                pshs d                          ; save buffer address
LDF09           ldx DSKVAR                      ; point to DSKCON variables
                inc TMPLOC                      ; bump sector counter
                lda TMPLOC                      ; get current sector
                cmpa #SECMAX                    ; loaded whole track?
                bhi LDF36                       ; brif so
                sta 3,x                         ; tell DSKCON the sector number
                ldd #0x0200                     ; read code and drive 0
                sta ,x                          ; set operation code (should be std to set drive)
                lda #34                         ; track 34
                sta 2,x                         ; tell DSKCON
                puls a,b                        ; get buffer pointer
                std 4,x                         ; tell DSKCON
                adda #1                         ; bump buffer pointer by one sector
                pshs a,b                        ; save it again
                jsr [DCNVEC]                    ; call DSKCON to read a sector
                tst 6,x                         ; error?
                beq LDF09                       ; brif not - read another
                puls a,b                        ; clean stack
                ldb #2*20                       ; I/O error code
                jmp LAC46                       ; raise error
LDF36           puls a,b                        ; clear up stack
                ldd DOSBUF                      ; get start of loaded track
                cmpd #'O*256+'S                 ; is it the "OS" tag?
                lbeq DOSBUF+2                   ; brif so - transfer control to it
                clr DOSBUF                      ; clear first two bytes (why?)
                clr DOSBUF+1
                jmp BAWMST                      ; do a warm start
DOSINI          ldd #0x3b3b                     ; set up SWI3 and SWI2 with RTIs (kind of pointless)
                std SW3VEC
                std SW3VEC+2
                std SW2VEC+1
                rts
; The remainder to the end is unused garbage bytes
                fcb 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x10,0x93,0xD3,0x25,0x02,0xDC,0xD3,0xDD
                fcb 0xC3,0xA6,0xE4,0x81,0x04,0x25,0x0A,0xDC,0xCD,0x93,0xC5,0x24,0x11,0x4F,0x5F,0x20
                fcb 0x0D,0xDC,0xCD,0xD3,0xC5,0x25,0x05,0x10,0x93,0xD5,0x25,0x02,0xDC,0xD5,0xDD,0xC5
                fcb 0x0D,0xD8,0x26,0x02,0x8D,0x50,0x35,0x06,0x04,0xD8,0x25,0x05,0x10,0x93,0xD9,0x27
                fcb 0x0C,0x5C,0xC1,0x08,0x26,0x04,0x4C,0x5F,0x84,0x07,0x7E,0x9E,0xFD,0x39,0x9E,0xCF
                fcb 0xEC,0xC4,0x27,0x07,0x83,0x00,0x01,0x8D,0x03,0x1F,0x21,0x39,0x34,0x76,0x6F,0x64
                fcb 0xA6,0x63,0x3D,0xED,0x66,0xEC,0x61,0x3D,0xEB,0x66,0x89,0x00,0xED,0x65,0xE6,0xE4
                fcb 0xA6,0x63,0x3D,0xE3,0x65,0xED,0x65,0x24,0x02,0x6C,0x64,0xA6,0xE4,0xE6,0x62,0x3D
                fcb 0xE3,0x64,0xED,0x64,0x35,0xF6,0x7E,0x94,0xA1,0x5F,0x9D,0xA5,0x27,0x11,0xBD,0xB2
                fcb 0x6D,0xBD,0xB1,0x41,0x96,0x4F,0x8B,0x06,0x97,0x4F,0xBD,0xB7,0x0E,0xC4,0x3F,0x1F
                fcb 0x98,0xC4,0x07,0x44,0x44,0x44,0x39
                else
; From here to the end of the ROM is unused garbage bytes
	fcb 0x00,0x00,0x00
	fcb 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
	fcb 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
	fcb 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
	fcb 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
	fcb 0xa7,0xfc,0x8f,0xec,0x94,0xbc,0x8c,0xf5
	fcb 0xbc,0xf8,0xd1,0xfa,0xfd,0xfd,0xac,0xe5
	fcb 0xec,0xf8,0x8a,0xea,0xad,0xec,0xb9,0xff
	fcb 0xbc,0xfd,0xcc,0xed,0x8c,0xe5,0x9c,0xf4
	fcb 0xa2,0xa6,0xe8,0xfc,0xae,0xe5,0x94,0xec
	fcb 0xbe,0xee,0x8c,0xed,0xea,0xe5,0xed,0x7c
	fcb 0xbe,0xfc,0x8e,0xed,0xfe,0xec,0x9c,0xac
	fcb 0xdc,0xfd,0xfb,0xf5,0xad,0xfd,0xaf,0xe9
	fcb 0xa0,0x30,0x24,0x8a,0x14,0x84,0x2c,0xc4
	fcb 0x24,0x08,0xe0,0x21,0x20,0x80,0x28,0x00
	fcb 0x20,0x88,0xa4,0xa0,0xa4,0x80,0xac,0x11
	fcb 0x30,0x90,0x24,0xd4,0x01,0xa1,0xa0,0x84
	fcb 0x64,0x80,0x34,0x04,0x34,0x80,0x20,0x21
	fcb 0xa1,0x81,0xa4,0x80,0x20,0x90,0x88,0xc0
	fcb 0x00,0x9a,0xa0,0xa0,0xe0,0x80,0xb6,0xa4
	fcb 0x20,0xa2,0x20,0x98,0x20,0x88,0x7c,0xae
	fcb 0xbd,0xee,0xee,0xfe,0xf1,0xec,0xad,0xbc
	fcb 0xed,0xec,0xdd,0xf9,0xec,0x75,0xb5,0xbd
	fcb 0xef,0xfd,0xa9,0xe4,0x96,0xfc,0x94,0xe4
	fcb 0xae,0xad,0xda,0xb4,0xac,0x7c,0xc3,0xec
	fcb 0xbd,0xfc,0xae,0xfd,0xee,0xfd,0x85,0xf4
	fcb 0xad,0xef,0x76,0xfc,0xd6,0x6e,0xef,0xed
	fcb 0xf6,0xbd,0xed,0xfe,0x58,0xed,0xf7,0xfd
	fcb 0x85,0xec,0xfc,0xe8,0xf2,0xe4,0xbf,0xa8
	fcb 0x30,0x80,0xa0,0x05,0xa4,0x20,0xb0,0x80
	fcb 0x20,0x84,0x04,0x80,0x30,0x8e,0xe0,0xa4
	fcb 0xb0,0x02,0x04,0x80,0x61,0x84,0x20,0x00
	fcb 0xa0,0x80,0x20,0x88,0x24,0x94,0x24,0xa4
	fcb 0x80,0x04,0x00,0x84,0x24,0x84,0x28,0x9c
	fcb 0x44,0x28,0xa0,0x80,0x80,0x90,0x30,0x80
	fcb 0xe8,0x80,0xa4,0x88,0x30,0x94,0x20,0x80
	fcb 0x00,0x8c,0x68,0xac,0xa4,0x84,0x30,0x06
	fcb 0x86,0xe4,0xbc,0xfc,0xae,0xec,0x87,0xbd
	fcb 0x9c,0xfd,0xec,0xbc,0xfd,0xb5,0xa9,0xed
	fcb 0xa7,0xac,0x8b,0x7c,0xa5,0xfc,0xcc,0xbc
	fcb 0xaa,0xb6,0xc9,0xfc,0xa5,0xfc,0x47,0xfc
	fcb 0xdd,0x6d,0x84,0xfe,0xac,0xee,0x20,0xf4
	fcb 0xc5,0xff,0xf4,0xee,0xf7,0xf4,0xaa,0xfc
	fcb 0xef,0xff,0x9c,0xfd,0xee,0xe4,0xaf,0xfc
	fcb 0xbe,0xbc,0xdf,0xa5,0xeb,0xec,0xee,0xa4
	fcb 0x34,0x86,0xac,0x84,0xa4,0x21,0x90,0x88
	fcb 0xa0,0xa0,0x24,0xc0,0xe0,0x80,0x70,0xe5
	fcb 0x3c,0xa5,0xa1,0x8c,0x34,0xa4,0xe4,0x84
	fcb 0x24,0x80,0xf8,0x81,0xa0,0x8d,0xec,0x4a
	fcb 0x2c,0xe2,0xa4,0x93,0x20,0x88,0xb0,0xc0
	fcb 0x34,0x10,0x20,0x91,0xa4,0x84,0xa4,0xae
	fcb 0x0c,0x92,0xb0,0xcd,0xb0,0xaa,0x74,0xe8
	fcb 0xa0,0x12,0xb9,0x85,0x21,0xf5,0xe0,0x8e
	fcb 0x9e,0xbd,0x81,0xf5,0xcf,0xe4,0xcc,0x66
	fcb 0xa7,0xad,0x98,0xbd,0xbc,0xbc,0x88,0xbc
	fcb 0x8e,0xed,0xa4,0xa8,0xad,0x88,0xee,0xfe
	fcb 0xcd,0xfc,0xac,0xfd,0x8c,0xfc,0x9a,0xf5
	fcb 0xb4,0xe4,0x8e,0xfc,0xfe,0xe4,0xcc,0xac
	fcb 0x9d,0xfc,0x97,0xe4,0x8b,0xec,0xea,0xec
	fcb 0xdb,0xec,0xdf,0xec,0xac,0xe4,0xae,0xfc
	fcb 0xd4,0xf4,0xcd,0xec,0xb4,0xec,0xef,0xee
	fcb 0xb2,0x24,0x28,0x20,0xac,0xd0,0x24,0x1c
	fcb 0x30,0x81,0xac,0x84,0x80,0x01,0xa4,0xa4
	fcb 0x70,0x88,0xa4,0xc4,0xa4,0x84,0x24,0x60
	fcb 0x08,0x04,0xa0,0x88,0x20,0x98,0x64,0xa8
	fcb 0x24,0x10,0xd4,0x90,0xa0,0x81,0x30,0xec
	fcb 0xac,0x09,0x64,0xe0,0x60,0x18,0x30,0xb0
	fcb 0x24,0x80,0x6c,0x88,0xa4,0x8c,0xa4,0x8c
	fcb 0xa8,0x10,0x21,0xa8,0x68,0x84,0xa8,0xa0
	fcb 0x8d,0xe5,0xa4,0x66,0x98,0xfd,0x87,0xfc
	fcb 0xde,0xac,0x9c,0xf4,0x8c,0xf5,0xb5,0xf5
	fcb 0xb6,0xf5,0xa9,0xf8,0xaf,0xed,0xe6,0xe5
	fcb 0xb8,0xf1,0xb1,0xfc,0xfc,0xe9,0x8c,0xec
	fcb 0x86,0xf9,0xb5,0xf7,0xcd,0xbc,0x84,0xe6
	fcb 0x8c,0xfc,0x81,0xe4,0xbc,0xe4,0x4f,0xfc
	fcb 0x8c,0xfc,0xae,0xe7,0xbd,0xfc,0xdc,0xfc
	fcb 0xf4,0xe8,0x9f,0xec,0xea,0xfc,0xef,0x6c
	fcb 0x20,0x82,0xa4,0x40,0xa8,0x8c,0xac,0x08
	fcb 0x60,0x82,0xa1,0x95,0xe0,0x30,0x60,0x80
	fcb 0x64,0x48,0x20,0x04,0x20,0x84,0xa4,0x82
	fcb 0xa0,0x04,0x20,0x94,0x44,0xa0,0xe0,0x80
	fcb 0x04,0xc8,0x2c,0x82,0x24,0x04,0x30,0xb8
	fcb 0x24,0x00,0x20,0xa0,0xa4,0x82,0xa0,0x80
	fcb 0x84,0x81,0x2c,0x84,0x20,0x80,0x24,0x8c
	fcb 0x80,0x80,0x24,0x02,0x64,0xa8,0x24,0x88
	fcb 0xed,0xbd,0xd1,0xff,0xb4,0xe4,0xaa,0xec
	fcb 0x80,0xf1,0x8c,0xed,0x89,0xac,0xb6,0xfc
	fcb 0x6e,0xfd,0xae,0xed,0x89,0xec,0xb6,0xec
	fcb 0xae,0xfd,0xee,0xf0,0x9f,0x7e,0x9f,0xfe
	fcb 0xd9,0xec,0xae,0xed,0xc6,0xec,0xfe,0x7d
	fcb 0xbc,0xfc,0xb9,0xac,0xda,0xfc,0xa5,0xbd
	fcb 0xcc,0xfd,0xad,0xe6,0xae,0xf4,0xcd,0xf4
	fcb 0xf2,0xed,0x84,0x78,0xcc,0xec,0xab,0x74
	fcb 0xa4,0x94,0x20,0x84,0x20,0x00,0xa0,0x00
	fcb 0xa4,0x05,0x28,0x0c,0x24,0x04,0x24,0x00
	fcb 0xa0,0x84,0x80,0x80,0x18,0x80,0x24,0x0c
	fcb 0xe0,0x88,0x04,0x8a,0x2c,0x88,0x0c,0x84
	fcb 0x00,0x80,0xe0,0x04,0x20,0xa1,0x20,0x85
	fcb 0x20,0x90,0x80,0x9c,0x24,0xc0,0xe0,0x8d
	fcb 0xa0,0x80,0x20,0x82,0xa0,0xa2,0x20,0x40
	fcb 0x80,0x82,0x10,0xb8,0x00,0x84,0x60,0x92
	fcb 0xdf,0xef,0xd1,0xec,0xa4,0xec,0xc9,0xfd
	fcb 0xe6,0xad,0xc6,0xe5,0xd4,0xfd,0x9a,0xed
	fcb 0xae,0xe4,0xac,0xbc,0x9f,0xec,0x8a,0xed
	fcb 0x0f,0xe5,0x8f,0xec,0xd7,0xe4,0xac,0xec
	fcb 0xce,0xef,0x9e,0xf4,0xd7,0xe4,0xcf,0xf5
	fcb 0xce,0xf4,0xe6,0x6c,0x81,0xec,0x9b,0xee
	fcb 0x9f,0x7c,0xbc,0xf7,0xcc,0x6d,0xfe,0xef
	fcb 0x8e,0x6e,0xef,0xbd,0xbe,0xbd,0x8f,0xe4
	fcb 0xa0,0x04,0x20,0xe0,0xb4,0x82,0xb4,0x82
	fcb 0x20,0x8c,0xb0,0x90,0xb0,0x90,0xb8,0x84
	fcb 0x24,0x90,0x6a,0x86,0x28,0x84,0xa0,0xa8
	fcb 0x24,0xcf,0xb8,0x88,0xa0,0xa0,0xb1,0x81
	fcb 0x10,0xb6,0xe0,0x98,0xc8,0xb4,0x34,0xaf
	fcb 0x34,0x00,0xb0,0x82,0x20,0x90,0xe4,0xac
	fcb 0x28,0x84,0x84,0x88,0x24,0xac,0xac,0xa4
	fcb 0x25,0x98,0x20,0xa0,0x20,0x80,0x32,0x00
	fcb 0xae,0xec,0x8d,0xbd,0x9f,0xf7,0xff,0xa1
	fcb 0xca,0xbe,0x8d,0x7c,0x8e,0x74,0xef,0xec
	fcb 0xd4,0xf5,0x9e,0xb8,0x8e,0x35,0xc6,0xe4
	fcb 0x90,0xed,0xed,0xfc,0x8c,0x25,0xbe,0xa4
	fcb 0xfc,0x6c,0x89,0xee,0xec,0xad,0xae,0x78
	fcb 0xee,0xec,0xad,0xed,0xad,0xec,0xbc,0xbd
	fcb 0x2e,0x76,0xae,0xec,0x8e,0xbd,0xef,0xfd
	fcb 0xac,0xec,0xef,0xb5,0xbe,0xa4,0xbf,0xe8
	fcb 0x04,0x00,0x24,0x08,0x04,0x84,0x24,0x80
	fcb 0x28,0x82,0x60,0x04,0x24,0x94,0x28,0x00
	fcb 0x2c,0x84,0x20,0x80,0xb5,0x86,0x30,0x04
	fcb 0x23,0x84,0xa0,0x80,0xa0,0x06,0x24,0xad
	fcb 0xa4,0x80,0xa6,0x86,0x80,0x00,0xe0,0x80
	fcb 0x66,0x90,0x20,0x8c,0x00,0x8c,0x04,0x82
	fcb 0xa4,0x46,0x00,0x01,0x20,0x98,0xa0,0x88
	fcb 0x20,0x2a,0x24,0xe0,0x00,0x08,0x64,0x02
	fcb 0x8d,0xa5,0xb5,0xe5,0xad,0xf7,0xcd,0xf4
	fcb 0xa8,0x29,0xbc,0x64,0xf8,0xec,0xad,0xae
	fcb 0xa8,0xf5,0x8c,0xa7,0xe7,0xe5,0xa9,0xf4
	fcb 0xf4,0xfd,0x94,0xed,0x5c,0xe4,0xc0,0xbe
	fcb 0x8c,0xfd,0xcd,0xa4,0x94,0xff,0xa5,0xec
	fcb 0xfc,0xe5,0xac,0xe4,0xae,0xbd,0x9d,0xbd
	fcb 0xa8,0xec,0x84,0x68,0xc9,0xad,0x8e,0xac
	fcb 0xea,0xed,0x8f,0xec,0xbf,0xaf,0xf7,0xed
	fcb 0x24,0x91,0xa0,0x04,0xb4,0x04,0x82,0x90
	fcb 0xac,0x08,0xb0,0xa0,0xc0,0x08,0x34,0xa0
	fcb 0x65,0x88,0x73,0x80,0x20,0x80,0x2c,0x04
	fcb 0x20,0x84,0x21,0x26,0x20,0x94,0x00,0x20
	fcb 0xa4,0x96,0xa4,0x80,0xb0,0x84,0x24,0x82
	fcb 0x25,0x86,0xa0,0x00,0x7c,0x30,0xa2,0x25
	fcb 0x24,0x9e,0xa0,0x88,0x20,0x80,0x20,0x00
	fcb 0x20,0xa9,0x20,0xa2,0xc0,0xb2,0xa1,0x0e
	fcb 0xae,0xec,0xa8,0xee,0xac,0xf8,0xfa,0xb4
	fcb 0xa4,0xfe,0xfc,0xf4,0x1c,0xed,0xae,0xf4
	fcb 0xd7,0xf8,0xfd,0xed,0x8e,0xfe,0xdc,0xe8
	fcb 0xfe,0xed,0xfc,0xed,0x9f,0xfc,0x9c,0xed
	fcb 0xb0,0xe7,0xbe,0xfe,0x84,0xe4,0xa7,0xfe
	fcb 0xad,0xe4,0xbc,0x64,0x8d,0xbf,0xaf,0xfd
	fcb 0xaa,0x2c,0xcd,0xed,0x8f,0xe4,0xfc,0xbd
	fcb 0xbf,0xef,0xe5,0xed,0xbf,0xfe,0xe5,0xfd
	fcb 0x84,0x82,0xa4,0x83,0xa4,0x08,0xa0,0x80
	fcb 0x00,0x84,0x30,0x86,0x08,0x20,0xb0,0x90
	fcb 0x14,0xb4,0xa0,0x80,0x20,0x90,0xa4,0x88
	fcb 0xec,0x80,0xa4,0x84,0xa0,0x84,0x28,0x80
	fcb 0xb4,0x81,0xf0,0xa0,0xe4,0x80,0x00,0x84
	fcb 0x34,0xb1,0xe4,0x80,0x24,0x5d,0x20,0xd2
	fcb 0x44,0x83,0xb0,0x88,0x20,0x14,0x30,0xbc
	fcb 0x20,0xa0,0xc4,0x9d,0x68,0x00,0xa0,0x20
	fcb 0xcf,0xec,0xaa,0x66,0xb8,0x75,0x9e,0xfc
	fcb 0xfe,0xb4,0xbc,0xff,0xac,0xfd,0x9a,0xbc
	fcb 0xba,0xec,0x8e,0xf4,0xec,0xfc,0x96,0xfd
	fcb 0xd2,0xea,0x84,0xfc,0xae,0xe4,0xe5,0xfd
	fcb 0xbd,0xec,0xdc,0xac,0xa5,0xb0,0xcf,0xec
	fcb 0x7a,0xb5,0xe4,0xea,0xef,0xec,0xa4,0xfe
	fcb 0xe5,0xff,0xf8,0xbc,0x86,0xe4,0xff,0xe5
	fcb 0xaf,0x6c,0xee,0xec,0xee,0x6c,0x2a,0x6c
	fcb 0x28,0xa0,0x64,0x84,0xb4,0x92,0x04,0x94
	fcb 0x80,0x00,0xb8,0x0c,0x20,0x88,0xa0,0x84
	fcb 0xa0,0x40,0xb0,0x00,0xa0,0x84,0xa0,0xca
	fcb 0x00,0x14,0x24,0xc0,0xa0,0x64,0x24,0x88
	fcb 0x00,0x18,0xed,0x88,0x28,0x80,0xa1,0x80
	fcb 0x00,0x85,0x20,0x80,0xa4,0x34,0x00,0x04
	fcb 0x24,0xa4,0xac,0x8c,0x34,0x88,0x2c,0x04
	fcb 0x24,0x84,0x60,0x88,0xa0,0xa0,0xa0,0x9c
	fcb 0xb9,0xf4,0x97,0xec,0x68,0xad,0xe4,0xf0
	fcb 0xf4,0xec,0xcb,0xfc,0xa8,0xf5,0xfd,0x3e
	fcb 0xfc,0xee,0x9d,0xec,0x5e,0xfc,0x9c,0xf6
	fcb 0x80,0xed,0xa2,0xe4,0xad,0xb6,0xbf,0xf4
	fcb 0xed,0xfe,0xb3,0xfc,0xdc,0xb5,0xb3,0xed
	fcb 0xef,0xfc,0xbf,0xfc,0xbc,0xfe,0xea,0xf4
	fcb 0xc5,0xe4,0x89,0xfc,0x7c,0xbd,0xde,0xfd
	fcb 0x87,0xe4,0x9e,0xec,0xaf,0xe4,0xfe,0xe4
	fcb 0x34,0xc6,0x30,0x26,0x24,0x80,0x20,0x1c
	fcb 0xb4,0x04,0xb4,0x28,0x24,0x98,0x20,0x00
	fcb 0xa4,0xa4,0xa0,0x80,0x21,0x48,0xb9,0x24
	fcb 0x20,0x80,0x28,0x00,0x20,0x80,0x84,0x1e
	fcb 0x60,0xbc,0x28,0x88,0xac,0x74,0xe0,0x04
	fcb 0x24,0xa6,0x00,0x20,0x70,0x85,0xa0,0x89
	fcb 0x30,0x0b,0xa0,0x80,0x20,0x10,0xa0,0x14
	fcb 0x24,0x04,0x20,0x82,0xa0,0x80,0x35,0xa0
	fcb 0xee,0xbc,0xbe,0xfd,0xbe,0xb9,0x89,0xe4
	fcb 0xfd,0x3d,0x13,0xe4,0x9e,0xec,0x8d,0xec
	fcb 0xde,0xfc,0x8e,0xe5,0x8f,0xf4,0xbe,0xff
	fcb 0xe6,0xe6,0x8c,0xe6,0xcd,0xae,0xee,0xed
	fcb 0xfe,0xec,0xdc,0xec,0x8e,0xfc,0x96,0xfd
	fcb 0xa6,0xfc,0xce,0xcd,0xbe,0xfe,0xee,0xfc
	fcb 0x9e,0xf4,0xee,0x6e,0xcf,0xed,0xee,0xe0
	fcb 0xfc,0xee,0xae,0xa0,0xfd,0xed,0xa6,0x6c
	fcb 0xa8,0x04,0x20,0x00,0x30,0x80,0xa0,0x90
	fcb 0x20,0x80,0x60,0x00,0x20,0x82,0x90,0x40
	fcb 0x24,0x10,0x04,0x00,0x84,0x00,0x24,0x18
	fcb 0xe0,0x00,0x00,0x02,0x20,0xb4,0x24,0x00
	fcb 0x22,0x80,0x04,0x04,0xa0,0x80,0x84,0x0a
	fcb 0x28,0x14,0xa0,0x80,0x00,0x86,0x40,0x86
	fcb 0x20,0x90,0x10,0x30,0x84,0x84,0x00,0x00
	fcb 0x74,0x80,0x30,0x00,0x20,0x08,0x20,0x80
	fcb 0xfb,0xfd,0xc9,0xe6,0x91,0xfd,0xc8,0xee
	fcb 0xb4,0x7c,0xbe,0xec,0x89,0xec,0xbd,0xfc
	fcb 0xa5,0xfd,0xd9,0xec,0x8a,0xfd,0xae,0xec
	fcb 0xad,0xfc,0xae,0xec,0x8d,0xec,0x8f,0xf4
	fcb 0xbf,0x6d,0xac,0xbd,0xea,0xed,0xaf,0xac
	fcb 0xfd,0xfc,0xea,0xfd,0xf0,0xf9,0xb3,0xee
	fcb 0x8e,0xe4,0xfd,0xec,0xff,0xe0,0x8e,0xe4
	fcb 0xfd,0xad,0xdc,0x6c,0xa0,0xe4,0x8e,0xe4
	fcb 0x28,0x00,0xb4,0x00,0x22,0x00,0xb4,0x00
	fcb 0x6c,0x00,0xa4,0x1b,0xb2,0x9c,0x20,0x84
	fcb 0x24,0xc4,0x24,0xa8,0xa0,0x80,0x64,0x88
	fcb 0x80,0xac,0x30,0x85,0x20,0x9c,0x74,0xf2
	fcb 0x88,0x88,0x38,0x80,0x2c,0xa0,0x20,0x04
	fcb 0xb8,0x80,0x24,0x90,0xa8,0xf8,0xbc,0x88
	fcb 0x20,0x20,0xa0,0xe0,0x6c,0x80,0x00,0xe8
	fcb 0x20,0x80,0x24,0xc0,0x23,0x9c,0x24,0x82
	fcb 0xb5,0xe0,0xa4,0xed,0x8e,0xe4,0xa9,0xfc
	fcb 0xf8,0xee,0xce,0xfc,0x89,0xe4,0x98,0xf5
	fcb 0xa1,0xec,0xa1,0xe0,0xb8,0xec,0xd0,0xfc
	fcb 0xcf,0xf9,0xae,0xec,0x8a,0xfd,0x6b,0x6e
	fcb 0x94,0xa8,0xb8,0xe4,0xce,0xa6,0x8c,0xf4
	fcb 0xee,0xbd,0x8d,0xec,0xed,0xf4,0xcf,0x6c
	fcb 0x99,0x6c,0xc8,0xf9,0xf9,0xa5,0xb6,0x79
	fcb 0x8c,0xc1,0xe4,0xf5,0xaa,0x24,0xf7,0x64
	fcb 0x24,0xa8,0xa4,0x80,0xa0,0x96,0x20,0x09
	fcb 0x20,0x18,0xa8,0x08,0xb0,0xc0,0x7c,0xcd
	fcb 0x24,0xdc,0x20,0x98,0x64,0x84,0xe0,0x82
	fcb 0x34,0xa0,0xea,0x88,0x60,0xc4,0x70,0xe8
	fcb 0x30,0x06,0xe5,0x1c,0x20,0x84,0x20,0x9c
	fcb 0xa0,0x80,0xa0,0x1c,0xa8,0x80,0x88,0x22
	fcb 0x24,0x80,0x24,0xb0,0xe4,0x14,0xe4,0x80
	fcb 0xe0,0x86,0x00,0xd6,0x8c,0x80,0xb8,0xab
	fcb 0xaf,0xa2,0x84,0xe8,0x86,0x2f,0x8a,0xf5
	fcb 0xd4,0xff,0x86,0xef,0x8e,0xf4,0xc8,0x6c
	fcb 0xf5,0xf4,0x4c,0xf4,0xe8,0x74,0x04,0xee
	fcb 0xee,0xe0,0x26,0x2c,0x9f,0xec,0x90,0xe5
	fcb 0xbc,0xe5,0xf8,0xe0,0xfb,0xf4,0xb4,0xed
	fcb 0x4e,0xe4,0xe6,0xec,0x8c,0xe4,0xbf,0xed
	fcb 0x9f,0xe0,0xcc,0x7c,0xbf,0xed,0x9d,0xed
	fcb 0xad,0xf8,0xaf,0x64,0xef,0xed,0xed,0xe4
	fcb 0xa0,0x8c,0x20,0x95,0x30,0x38,0xa0,0x84
	fcb 0x64,0x80,0xe0,0x76,0x2c,0x20,0xb4,0x04
	fcb 0x3f,0xb1,0xa4,0x24,0x24,0x80,0x24,0xa9
	fcb 0x31,0x97,0xac,0x28,0x64,0x50,0xa0,0x04
	fcb 0x38,0x80,0xb4,0x8e,0x20,0xcc,0xbc,0x38
	fcb 0x64,0x8c,0xa0,0x90,0xe4,0xa0,0x64,0x99
	fcb 0x64,0xaf,0x24,0xe5,0x60,0x80,0xa4,0x3c
	fcb 0x2c,0x8e,0xb4,0xbc,0xa4,0xcc,0x24,0xcc
                endc