TRS-80 DOS - NEWDOS/80 v2.0 for the Model III - SYS4/SYS Disassembled

Page Customization

Page Index

SYS4/SYS

Introduction/Summary Memory Map Major Routines Error Code Quick Reference Disassembly

Other Navigation

Main NEWDOS/80 v2.0 Page Main NEWDOS/80 v2.0 Disassembly Page

Introduction / Summary

SYS4/SYS — NEWDOS/80 v2.0 Error Message Handler Overlay (Model III)

SYS4/SYS is the NEWDOS/80 error message display overlay for the TRS-80 Model III. It is loaded into memory at 4D00H when an error condition is detected by the operating system. The module's sole purpose is to decode a numeric error code (00H-3FH) into a human-readable error message and display it on screen.

SYS4 uses a two-level compression scheme to minimize memory usage. Error messages are not stored as complete strings. Instead, each error code maps to a sequence of word indices in the Error Message Index Table at 4D84H. Each word index references a word in the Word Component Table at 4E74H, where 95 commonly used words like "ERROR", "FILE", "DISK", "DIRECTORY", etc. are stored. Because many error messages share the same words, this approach is far more memory-efficient than storing 64 separate full-text strings.

The word component strings use a high-bit termination encoding: each word is stored as standard ASCII characters (bit 7 = 0) with bit 7 set on the final character to mark the word boundary. For example, "ERROR" is stored as 45H 52H 52H 4FH D2H — the last byte D2H is the ASCII code for 'R' (52H) with bit 7 OR'd on (52H | 80H = D2H).

The executable code portion is compact at only 132 bytes (4D00H-4D83H). The error message index table consumes 241 bytes (4D84H-4E74H), and the word component table consumes 568 bytes (4E74H-50ABH). The remaining 316 bytes (50ACH-51E7H) are unused NOP padding. The total module allocation is 1,256 bytes.

Entry Point: 4D00H. Register A contains the error code or a special command code (E6H = no error/return immediately, 46H = FORMAT context, 66H = error code is in Register H). The error code is masked to 6 bits (AND 3FH) to index into the 64-entry message table.

Exit Paths: Standard errors (bit 7 clear) exit via JP 402DH to the DOS Ready prompt. Fatal errors (bit 7 set) exit via a self-modifying JP M instruction at 4D7EH, which defaults to JP 0000H (cold boot) but can be patched with the caller's return address.

Variables

Complete table of all memory locations referenced by SYS4, including system variables, self-modifying code locations, and data areas. Locations marked [SMC] are self-modifying code targets — their values are patched at runtime.

Address Region Size Referenced At Description
4289H SYS0 1 byte 4D27H Secondary system state flags. Bit 5: SVC E3H enable condition — when set, indicates that SVC E3H should be called for system housekeeping before displaying the error message.
428AH SYS0 1 byte 4D08H, 4D1CH, 4D2CH Primary system state flags. Bit 2: FORMAT active flag — set at 4D0BH when entry code is 46H ('F'). Bit 6: Secondary SVC E3H condition — tested at 4D2DH; when clear, the SVC call is skipped.
4D7FH-4D80H SYS4 [SMC] 2 bytes 4D0FH, 4D7EH [SELF-MODIFYING CODE] Operand of the JP M instruction at 4D7EH. Written by LD (4D7FH),HL at 4D0FH with the caller's return address. Default value is 0000H (cold boot). Used as the fatal error exit target — allows callers to redirect fatal error recovery.
4D84H SYS4 241 bytes 4D40H Error Message Index Table. Contains 64 variable-length entries (error codes 00H-3FH) plus a 1-byte sentinel at position 0. Each entry is a sequence of word indices (bits 0-6) with bit 7 set on the last byte. Ends at 4E74H.
4E74H SYS4 568 bytes 4D54H Word Component Table. Contains 95 ASCII words (indices 00H-5EH) using high-bit termination encoding. Each word's last character has bit 7 set. The first byte (4E74H = 80H) is a sentinel that serves as both word index 00H and the end marker for the last error index table entry. Ends at 50ABH.

Memory Map

Physical layout of SYS4 in memory from 4D00H through 51E7H. The module is divided into one executable code region and two data tables, followed by unused padding. Unlike other SYS overlays, SYS4 contains no subroutines or branch tables — its code is a single linear routine with embedded loops.

Address RangeSizeTypeDescription
4D00H-4D83H132 bytesCodeError Message Handler — Entry point at 4D00H. Validates the error code, optionally calls SVC E3H for housekeeping, scans the error message index table, looks up and prints word components, then exits to DOS Ready (402DH) or cold boot (0000H). Contains self-modifying code at 4D7FH-4D80H (the JP M operand).
4D84H-4E74H241 bytesDataError Message Index Table — 64 variable-length entries mapping error codes 00H-3FH to sequences of word indices, plus a 1-byte sentinel (80H) at the start. Each entry's last byte has bit 7 set.
4E74H-50ABH568 bytesDataWord Component Table — 95 ASCII strings (word indices 00H-5EH) with high-bit termination encoding. Shares the sentinel byte at 4E74H with the error index table. Includes words such as ERROR, READ, WRITE, FILE, DIRECTORY, DISK, DRIVE, SYSTEM, FORMAT, etc.
50ACH-51E7H316 bytesPaddingUnused — All 00H bytes. Reserved space within the fixed SYS4 module allocation for potential expansion of the error message tables.

Major Routines

All routines within SYS4 (internal) and all external routines called by SYS4 (SYS0 and ROM). SYS4 is unique among the SYS overlays in that it contains only a single routine — the error message handler — with no subroutines. All external calls are to ROM character output and the SVC dispatcher.

Internal Routines (within SYS4: 4D00H-51E7H)

Address Type Description
4D00H Entry Point Error Message Handler — Main and only entry point for SYS4. Accepts error code in Register A (or Register H if A=66H). Decodes and displays the corresponding error message. Exits to DOS Ready (402DH) for standard errors or cold boot/caller redirect (via self-modifying JP M at 4D7EH) for fatal errors.
4D84H Data Table Error Message Index Table — 64 entries + sentinel mapping error codes to word index sequences.
4E74H Data Table Word Component Table — 95 ASCII words with high-bit termination encoding.

External Routines Called by SYS4

AddressRegionCalled FromDescription
0000H ROM 4D7EH Cold Boot / System Reset — Default target of the self-modifying JP M instruction. Used for fatal error recovery when no caller-supplied handler address has been installed at 4D7FH.
0028H ROM 4D3BH RST 28H — SVC Dispatcher — Called with A=E3H, C=07H to invoke SVC E3H function 07H for system housekeeping before error message display. Only called when specific flag conditions at 4289H/428AH are met.
0033H ROM 4D61H, 4D6BH, 4D76H Display Character — Displays the character in Register A at the current cursor position and advances the cursor. Called three times: once per word character (4D61H), once for the space separator between words (4D6BH), and once for the carriage return at end of message (4D76H).
402DH SYS0 4D81H DOS Ready Warm Start — Returns control to the DOS command processor and displays the READY prompt. Used as the exit path for standard (non-fatal) errors where bit 7 of the error code is clear.

Error Code Quick Reference

Complete listing of all 64 NEWDOS/80 error messages decoded from the compressed tables in SYS4. Error codes are the values passed to the handler in Register A (after AND 3FH masking). The message text is reconstructed by looking up each word index in the Error Message Index Table at 4D84H and printing the corresponding word from the Word Component Table at 4E74H, separated by spaces.

Code Dec Table Addr Decoded Message
00H04D85HNO ERROR
01H14D87HBAD FILE DATA
02H24D8AHSEEK ERROR DURING READ
03H34D8EHLOST DATA DURING READ
04H44D92HPARITY ERROR DURING READ
05H54D96HDATA RECORD NOT FOUND DURING READ
06H64D9CHTRIED TO READ LOCKED/DELETED RECORD
07H74DA0HTRIED TO READ SYSTEM RECORD
08H84DA4HDEVICE NOT AVAILABLE
09H94DA7HUNDEFINED ERROR CODE
0AH104DAAHSEEK ERROR DURING WRITE
0BH114DAEHLOST DATA DURING WRITE
0CH124DB2HPARITY ERROR DURING WRITE
0DH134DB6HDATA RECORD NOT FOUND DURING WRITE
0EH144DBCHWRITE FAULT ON DISK DRIVE
0FH154DC1HWRITE PROTECTED DISKETTE
10H164DC4HDEVICE NOT AVAILABLE
11H174DC7HDIRECTORY READ ERROR
12H184DCAHDIRECTORY WRITE ERROR
13H194DCDHILLEGAL FILE NAME
14H204DD0HTRACK # TOO HIGH
15H214DD4HILLEGAL FUNCTION UNDER DOS-CALL
16H224DD8HUNDEFINED ERROR CODE
17H234DDBHUNDEFINED ERROR CODE
18H244DDEHFILE NOT IN DIRECTORY
19H254DE2HFILE ACCESS DENIED
1AH264DE5HDIRECTORY SPACE FULL
1BH274DE8HDISKETTE SPACE FULL
1CH284DEBHEND OF FILE ENCOUNTERED
1DH294DEFHPAST END OF FILE
1EH304DF3HDIRECTORY FULL . CAN'T EXTEND FILE
1FH314DF9HPROGRAM NOT FOUND
20H324DFCHILLEGAL OR MISSING DRIVE #
21H334E01HNO DEVICE SPACE AVAILABLE
22H344E05HLOAD FILE FORMAT ERROR
23H354E09HMEMORY FAULT
24H364E0BHTRIED TO LOAD READ ONLY MEMORY
25H374E10HILLEGAL ACCESS NOT FUNCTION FILE
26H384E15HFILE NOT OPEN
27H394E18HILLEGAL INITIALIZATION DATA ON SYSTEM DISKETTE
28H404E1EHILLEGAL DISKETTE TRACK COUNT
29H414E22HILLEGAL LOGICAL FILE #
2AH424E26HILLEGAL DOS FUNCTION
2BH434E29HILLEGAL FUNCTION UNDER CHAINING
2CH444E2DHBAD DIRECTORY DATA
2DH454E30HBAD FCB DATA
2EH464E33HSYSTEM PROGRAM NOT FOUND
2FH474E37HBAD PARAMETER(S)
30H484E39HBAD FILESPEC
31H494E3BHWRONG DISKETTE RECORD TYPE
32H504E3FHBOOT READ ERROR
33H514E42HDOS FATAL ERROR
34H524E45HILLEGAL KEYWORD OR SEPARATOR OR TERMINATOR
35H534E4BHFILE ALREADY EXISTS
36H544E4EHCOMMAND TOO LONG
37H554E51HDISKETTE ACCESS DENIED
38H564E54HILLEGAL MINI DOS FUNCTION
39H574E58HOPERATOR/PROGRAM/PARAMETER REQUIRE FUNCTION TERMINATION
3AH584E5CHDATA COMPARE MISMATCH
3BH594E5FHINSUFFICIENT MEMORY
3CH604E61HINCOMPATIBLE DRIVES OR DISKETTES
3DH614E65HASE=N ATTRIBUTE . CAN'T EXTEND FILE
3EH624E6BHCAN'T EXTEND FILE VIA READ

Disassembly

4D00H - Error Message Handler Entry Point (SYS4)

This is the entry point for SYS4, the NEWDOS/80 error message handler. Register A contains either a command code or an error code. The routine checks for special codes first, then displays the appropriate compressed error message by looking up word indices from the Error Message Index Table at 4D84H and printing the corresponding words from the Word Component Table at 4E74H.

4D00
CP E6H FE E6
Compare Register A against E6H (the "no error" or "success" sentinel code). If Register A equals E6H, the Z FLAG is set; otherwise the NZ FLAG is set.
4D02
RET Z C8
If the Z FLAG (Zero) has been set (meaning A = E6H, indicating no error), RETURN immediately to the caller without displaying any message.

The code did not return, so Register A contains something other than E6H. Now check if A is 46H (ASCII F), which indicates a FORMAT command context.

4D03
CP 46H FE 46
Compare Register A against 46H (ASCII: F). If Register A equals 46H, the Z FLAG is set; otherwise the NZ FLAG is set.
4D05
If the NZ FLAG (Not Zero) has been set (meaning A ≠ 46H, not a FORMAT command), JUMP forward to 4D0EH to skip the FORMAT flag-setting code.

A = 46H (ASCII F), indicating this call is in the context of FORMAT command processing. Set the FORMAT flag at 428AH bit 2.

4D07
PUSH HL E5
Save Register Pair HL onto the stack to preserve its value during the flag modification.
4D08
LD HL,428AH 21 8A 42
Point Register Pair HL to 428AH, the system state flags byte in SYS0 RAM. This byte tracks various DOS operational modes.
4D0B
SET 2,(HL) CB D6
SET bit 2 of the byte at address 428AH (pointed to by HL), turning on the FORMAT active flag. This tells the system that a FORMAT operation is in progress.
4D0D
POP HL E1
Restore Register Pair HL from the stack, recovering the value saved at 4D07H.

[REGISTER PRESERVATION AND RETURN ADDRESS CAPTURE] The next section captures the caller's return address and saves all working registers. The stack currently has the caller's return address on top. The code uses EX (SP),HL to swap HL with the return address, stores it for potential modification by the exit logic, then restores the original stack layout.

4D0E
EX (SP),HL E3
Exchange Register Pair HL with the value on top of the stack. HL now contains the caller's return address (which was on the stack), and the stack now holds the old HL value.
4D0F
Store the caller's return address (now in HL) to memory location 4D7FH. This is a [SELF-MODIFYING CODE] target: the address stored here becomes the operand of the JP M instruction at 4D7EH, allowing the fatal-error exit to jump to the caller's return address instead of cold-booting in certain cases.
4D12
POP HL E1
Restore Register Pair HL from the stack (this recovers the original HL value that was pushed onto the stack by the EX (SP),HL at 4D0EH).
4D13
EX (SP),HL E3
Exchange Register Pair HL with the top of the stack again. This restores the caller's return address back onto the stack and puts the original HL value back into HL. The stack is now in its original state.
4D14
PUSH DE D5
Save Register Pair DE onto the stack to preserve it during error message processing.
4D15
PUSH BC C5
Save Register Pair BC onto the stack to preserve it during error message processing.
4D16
PUSH HL E5
Save Register Pair HL onto the stack to preserve it during error message processing.

[SVC CALL DECISION LOGIC] The next block determines whether to call SVC E3H (function 07H) before displaying the error message. This SVC call performs system housekeeping. The decision depends on the error code value and several system state flags at 4289H-428AH.

4D17
CP 66H FE 66
Compare Register A (the error/command code) against 66H. If A equals 66H, the Z FLAG is set. The value 66H (ASCII f) is a special command code indicating that the SVC call should be skipped and the error code is in Register H instead of Register A.
4D19
LD A,H 7C
Load Register A with the value from Register H. If this is a 66H call, H contains the actual error code. If not a 66H call, this value will be overridden by the AND 3FH at 4D3CH, but A is loaded here speculatively for the Z branch path.
4D1A
If the Z FLAG (Zero) has been set (meaning the original A was 66H), JUMP to 4D3CH to begin message lookup using the error code now in A (loaded from H). This skips the SVC call entirely.

A ≠ 66H. Now check system flags to decide whether to call SVC E3H. First check bit 2 of 428AH (the FORMAT active flag).

4D1C
LD HL,428AH 21 8A 42
Point Register Pair HL to 428AH, the system state flags byte in SYS0 RAM.
4D1F
BIT 2,(HL) CB 56
Test bit 2 of the byte at address 428AH (the FORMAT active flag). If bit 2 is set (FORMAT is active), the NZ FLAG is set; if clear, the Z FLAG is set.
4D21
If the NZ FLAG (Not Zero) has been set (meaning the FORMAT flag at 428AH bit 2 is ON), JUMP to 4D3CH to display the error message without calling SVC E3H. During FORMAT operations, the SVC call is bypassed.

FORMAT flag is not set. Check if bit 7 of Register A (the error code) is set, which indicates a high-severity error that should bypass the SVC call.

4D23
BIT 7,A CB 7F
Test bit 7 of Register A (the error code). If bit 7 is set (error code ≥ 80H, indicating a fatal/high-severity error), the NZ FLAG is set; if clear, the Z FLAG is set.
4D25
If the NZ FLAG (Not Zero) has been set (meaning error code has bit 7 set, a fatal error), JUMP to 4D3CH to display the error message without calling SVC E3H.

Error code has bit 7 clear (a standard error, code 00H-7FH). Now check additional system flags at 4289H to decide about the SVC call.

4D27
DEC HL 2B
DECrement Register Pair HL by 1. HL was 428AH, now HL = 4289H, the secondary system state flags byte in SYS0 RAM.
4D28
BIT 5,(HL) CB 6E
Test bit 5 of the byte at address 4289H. If bit 5 is set, the NZ FLAG is set; if clear, the Z FLAG is set. Bit 5 of 4289H controls whether SVC E3H should be called for error processing.
4D2A
If the NZ FLAG (Not Zero) has been set (meaning bit 5 of 4289H is set), JUMP to 4D31H to proceed with the SVC E3H call.

Bit 5 of 4289H is clear. Check bit 6 of 428AH as a secondary condition.

4D2C
INC HL 23
INCrement Register Pair HL by 1. HL was 4289H, now HL = 428AH again (back to the primary flags byte).
4D2D
BIT 6,(HL) CB 76
Test bit 6 of the byte at address 428AH. If bit 6 is set, the NZ FLAG is set; if clear, the Z FLAG is set. Bit 6 of 428AH is another condition controlling the SVC E3H call.
4D2F
If the Z FLAG (Zero) has been set (meaning bit 6 of 428AH is clear), JUMP to 4D3CH to skip the SVC call and go directly to message display. Neither condition for calling SVC E3H has been met.

[SVC E3H CALL] The conditions for calling SVC E3H have been met. Prepare and execute the system call. First mask the error code to 6 bits and set up the carry flag.

4D31
AND 3FH E6 3F
Mask Register A with 3FH (binary 00111111), clearing bits 7 and 6 to isolate the 6-bit error code (range 00H-3FH). This ensures the error code indexes into the 64-entry message table.
4D33
CP FFH FE FF
Compare Register A against FFH. Since A is in range 00H-3FH after the AND 3FH, A will always be less than FFH, so the CARRY FLAG is set.
4D35
CCF 3F
Complement (invert) the Carry Flag. Since the CP FFH set the Carry, CCF clears it. The NO CARRY FLAG is now set. This prepares the flags for the SVC call, where carry clear may indicate a specific condition to the SVC handler.
4D36
PUSH AF F5
Save Register A (the masked error code) and the Flags register onto the stack. The error code is preserved across the SVC call.
4D37
LD A,E3H 3E E3
Load Register A with E3H, the SVC (Supervisor Call) function number. SVC E3H calls SYS1/SYS function 07H, which performs system housekeeping operations before the error message is displayed.
4D39
LD C,07H 0E 07
Load Register C with 07H, the sub-function number for SVC E3H. This selects function 7 within the SVC handler.
4D3B
RST 28H EF
Execute RST 28H, the NEWDOS/80 SVC dispatcher at ROM address 0028H. This calls SVC E3H with sub-function 07H (in Register C) to perform system housekeeping. After the SVC returns, the error code will be restored from the stack by POP AF at 4D79H.

[MESSAGE TABLE LOOKUP] At this point, Register A contains the error code (either directly, or from Register H if the 66H path was taken, or the masked value after AND 3FH). The code now uses this value as an index into the Error Message Index Table at 4D84H to find the corresponding compressed error message.

4D3C
AND 3FH E6 3F
Mask Register A with 3FH (binary 00111111), isolating the 6-bit error code (range 00H-3FH) for use as the table index. This handles both the direct path and the SVC path uniformly.
4D3E
LD B,A 47
Load Register B with the masked error code from Register A. B will serve as a counter for the table scan.
4D3F
INC B 04
INCrement Register B by 1. B now equals (error code + 1). This adjustment is needed because the DJNZ instruction at 4D4BH decrements B before testing for zero. The table has a 1-byte sentinel entry at position 0 (4D84H = 80H), so error code 00H must skip 1 entry, error code 01H must skip 2 entries, and so on.
4D40
Point Register Pair HL to 4D84H, the start of the Error Message Index Table. This table contains variable-length entries of word indices, with bit 7 set on the last byte of each entry to mark its end.

[LOOP START - Table Entry Scan] Scan through the table entries, counting end-of-entry markers (bytes with bit 7 set). When B entries have been skipped, HL will point to the first byte of the target error message entry.

4D43
LD A,(HL) 7E
Fetch the current byte from the Error Message Index Table (pointed to by HL) into Register A.
4D44
RLC A CB 07
Rotate Register A Left through Carry. Bit 7 of the original byte moves into the Carry Flag. If the byte had bit 7 set (end-of-entry marker), carry is set. If bit 7 was clear, carry is clear. The Z flag is set if the result after rotation is zero (which occurs when the original byte was 00H or 80H).
4D46
INC HL 23
INCrement Register Pair HL by 1, advancing the pointer to the next byte in the table.
4D47
If the Z FLAG (Zero) has been set (meaning the RLC result was zero, which occurs when the original byte was 00H), JUMP to 4D4DH to begin processing the current entry. A 00H byte in the table is a special null word index that causes the display loop to skip to the next word index.
4D49
If the NO CARRY FLAG has been set (meaning bit 7 of the original byte was clear, so this is NOT the last byte of the current entry), JUMP back to 4D43H to continue scanning within the same entry.
4D4B
DECrement Register B and loop back to 4D43H if B is not zero. Each time we reach here, one complete table entry has been skipped (its end-of-entry marker was found). When B reaches zero, all required entries have been skipped and HL points to the first byte of the target error message entry.

[LOOP END - Table Entry Scan] HL now points to the first word index byte of the error message entry for the requested error code. The following code reads each word index, looks up the word in the Word Component Table at 4E74H, and prints it character by character using ROM routine 0033H.

4D4D
LD A,(HL) 7E
Fetch the current byte from the Error Message Index Table (pointed to by HL) into Register A. This byte is a word index (bits 0-6) with a possible end-of-entry flag in bit 7.
4D4E
AND 7FH E6 7F
Mask Register A with 7FH, stripping bit 7 (the end-of-entry flag) to isolate the 7-bit word index (range 00H-7FH). This word index identifies which word from the Word Component Table to print.
4D50
LD B,A 47
Load Register B with the word index from Register A. B will serve as a countdown counter for scanning through the Word Component Table to find the correct word.
4D51
If the Z FLAG (Zero) has been set (meaning the word index is 00H, a null/skip marker), JUMP to 4D6FH to advance past this byte in the error message entry and process the next word index without printing anything. Word index 0 references the sentinel byte at 4E74H and is used as a placeholder.

[WORD LOOKUP AND PRINT] The word index in B is non-zero. Look up the corresponding word in the Word Component Table at 4E74H by scanning past B word boundaries (each word ends with a byte that has bit 7 set), then print the word's characters.

4D53
PUSH HL E5
Save Register Pair HL (the current position in the Error Message Index Table) onto the stack. HL will be reused to scan the Word Component Table.
4D54
Point Register Pair HL to 4E74H, the start of the Word Component Table. This table contains ASCII strings for all error message words, with bit 7 set on the last character of each word to mark its boundary.

[LOOP START - Word Table Scan] Scan through the Word Component Table, counting word boundaries (bytes with bit 7 set). When B words have been skipped, HL will point to the first character of the target word.

4D57
LD A,(HL) 7E
Fetch the current byte from the Word Component Table (pointed to by HL) into Register A.
4D58
RLCA 07
Rotate Register A Left (fast rotate). Bit 7 of the original byte moves into the Carry Flag. If the byte had bit 7 set (end-of-word marker), carry is set.
4D59
INC HL 23
INCrement Register Pair HL by 1, advancing the pointer to the next byte in the Word Component Table.
4D5A
If the NO CARRY FLAG has been set (meaning bit 7 of the original byte was clear, so this is not the last character of the current word), JUMP back to 4D57H to continue scanning within the same word.
4D5C
DECrement Register B and loop back to 4D57H if B is not zero. Each iteration of the DJNZ has skipped one complete word (found its end-of-word marker). When B reaches zero, HL points to the first character of the target word.

[LOOP END - Word Table Scan] HL now points to the first character of the word to print. The following loop reads and prints each character, stripping bit 7, until a byte with bit 7 set (end-of-word) is found.

[LOOP START - Character Print Loop]

4D5E
LD A,(HL) 7E
Fetch the current character byte from the Word Component Table (pointed to by HL) into Register A.
4D5F
AND 7FH E6 7F
Mask Register A with 7FH, stripping bit 7 (the end-of-word flag) to isolate the 7-bit ASCII character code.
4D61
GOSUB to ROM routine at 0033H to display the character in Register A at the current cursor position and advance the cursor.
4D64
LD A,(HL) 7E
Fetch the same byte again from the Word Component Table to test its bit 7 (the AND 7FH at 4D5FH destroyed the original bit 7 information).
4D65
RLCA 07
Rotate Register A Left (fast rotate). Bit 7 of the byte moves into the Carry Flag. If bit 7 is set (this was the last character of the word), carry is set.
4D66
INC HL 23
INCrement Register Pair HL by 1, advancing the pointer to the next byte in the Word Component Table.
4D67
If the NO CARRY FLAG has been set (meaning bit 7 was clear, this is not the last character), JUMP back to 4D5EH to print the next character of this word.

[LOOP END - Character Print Loop] The entire word has been printed. Now print a space character as a word separator, then return to process the next word index in the error message entry.

4D69
LD A,20H 3E 20
Load Register A with 20H (ASCII space character). This provides the separator between words in the error message.
4D6B
GOSUB to ROM routine at 0033H to display the space character and advance the cursor.
4D6E
POP HL E1
Restore Register Pair HL from the stack, recovering the current position in the Error Message Index Table (saved at 4D53H before the word lookup).

[NEXT WORD INDEX CHECK] Check whether the current byte in the error message entry has bit 7 set (end of message) or clear (more word indices follow).

4D6F
LD A,(HL) 7E
Fetch the current byte from the Error Message Index Table (pointed to by HL). This is the same byte whose word index was just processed (or a null 00H byte that was skipped).
4D70
RLCA 07
Rotate Register A Left (fast rotate). Bit 7 of the byte moves into the Carry Flag. If bit 7 is set (this was the last word index in the error message entry), carry is set.
4D71
INC HL 23
INCrement Register Pair HL by 1, advancing the pointer to the next byte in the Error Message Index Table.
4D72
If the NO CARRY FLAG has been set (meaning bit 7 was clear, there are more word indices in this error message), JUMP back to 4D4DH to process the next word index.

[MESSAGE COMPLETE - CLEANUP AND EXIT] The entire error message has been printed. Output a carriage return, restore all saved registers, then exit. The exit method depends on bit 7 of the original error code: if set (fatal error), the JP M instruction jumps to the address stored at 4D7FH; if clear (standard error), control passes to the DOS Ready prompt at 402DH.

4D74
LD A,0DH 3E 0D
Load Register A with 0DH (ASCII carriage return). This terminates the error message output line.
4D76
GOSUB to ROM routine at 0033H to display the carriage return character, moving the cursor to the beginning of the next line.
4D79
POP AF F1
Restore Register A and Flags from the stack. If the SVC E3H path was taken (via 4D36H PUSH AF), this restores the masked error code and carry-clear flag. If the SVC path was skipped, this pops whatever was previously on the stack (the saved HL from 4D16H), effectively adjusting the stack for the non-SVC path. The Sign flag (bit 7) reflects the original error code's bit 7.
4D7A
POP BC C1
Restore Register Pair BC from the stack (saved at 4D15H).
4D7B
POP DE D1
Restore Register Pair DE from the stack (saved at 4D14H).
4D7C
POP HL E1
Restore Register Pair HL from the stack (saved at 4D16H or adjusted by the POP AF).
4D7D
OR A B7
OR Register A with itself. This does not change A but sets the flags: specifically, the Sign Flag (S) is set if bit 7 of A is 1. This tests whether the error code indicates a fatal error (bit 7 set) or a standard error (bit 7 clear).
4D7E
JP M,0000H FA 00 00
If the SIGN FLAG (Minus/Negative) has been set (meaning Register A bit 7 = 1, a fatal error), JUMP to 0000H (system cold boot / reset). [SELF-MODIFYING CODE] The operand at bytes 4D7FH-4D80H was written by the LD (4D7FH),HL instruction at 4D0FH with the caller's return address. If the caller stored a custom handler address, this jumps there instead of 0000H. The default value 0000H triggers a full system restart for unrecoverable fatal errors.
4D81
JUMP to 402DH, the DOS Ready warm start entry point in SYS0. This returns control to DOS and displays the READY prompt for the next command. This path is taken for standard (non-fatal) errors where bit 7 of the error code was clear.

4D84H - Error Message Index Table

This is the Error Message Index Table, a compressed data structure containing 64 error message definitions plus a sentinel entry. Each entry consists of one or more word indices (7-bit values) that reference the Word Component Table at 4E74H. Bit 7 set on the last byte of each entry marks the end of that error message. The disassembler incorrectly interpreted these data bytes as Z80 instructions; they are pure data. Error code N (after AND 3FH masking) maps to table entry (N+1), with entry 0 being a 1-byte sentinel (80H).

Entry 0 (Sentinel) — This single-byte entry serves as a sentinel/guard value. The table scan loop at 4D43H-4D4BH skips past this entry when looking up any error code. The value 80H is byte 00H with bit 7 set, marking it as a complete 1-byte entry containing null word index 00H.

4D84
DEFB 80H 80
Sentinel entry: word index 00H with bit 7 set (end-of-entry marker). This byte is skipped by the table scan before any error message lookup begins.

Error Code 00H — NO ERROR

4D85
DEFB 13H 13
Entry 1: Word index 13H = "NO".
4D86
DEFB 81H 81
Word index 01H = "ERROR". Bit 7 is set, marking the end of this error message entry.

Error Code 01H — BAD FILE DATA

4D87
DEFB 22H 22
Entry 2: Word index 22H = "BAD".
4D88
DEFB 05H 05
Word index 05H = "FILE".
4D89
DEFB 8BH 8B
Word index 0BH = "DATA". Bit 7 is set, marking the end of this error message entry.

Error Code 02H — SEEK ERROR DURING READ

4D8A
DEFB 0EH 0E
Entry 3: Word index 0EH = "SEEK".
4D8B
DEFB 01H 01
Word index 01H = "ERROR".
4D8C
DEFB 04H 04
Word index 04H = "DURING".
4D8D
DEFB 82H 82
Word index 02H = "READ". Bit 7 is set, marking the end of this error message entry.

Error Code 03H — LOST DATA DURING READ

4D8E
DEFB 0DH 0D
Entry 4: Word index 0DH = "LOST".
4D8F
DEFB 0BH 0B
Word index 0BH = "DATA".
4D90
DEFB 04H 04
Word index 04H = "DURING".
4D91
DEFB 82H 82
Word index 02H = "READ". Bit 7 is set, marking the end of this error message entry.

Error Code 04H — PARITY ERROR DURING READ

4D92
DEFB 0CH 0C
Entry 5: Word index 0CH = "PARITY".
4D93
DEFB 01H 01
Word index 01H = "ERROR".
4D94
DEFB 04H 04
Word index 04H = "DURING".
4D95
DEFB 82H 82
Word index 02H = "READ". Bit 7 is set, marking the end of this error message entry.

Error Code 05H — DATA RECORD NOT FOUND DURING READ

4D96
DEFB 0BH 0B
Entry 6: Word index 0BH = "DATA".
4D97
DEFB 08H 08
Word index 08H = "RECORD".
4D98
DEFB 12H 12
Word index 12H = "NOT".
4D99
DEFB 31H 31
Word index 31H = "FOUND".
4D9A
DEFB 04H 04
Word index 04H = "DURING".
4D9B
DEFB 82H 82
Word index 02H = "READ". Bit 7 is set, marking the end of this error message entry.

Error Code 06H — TRIED TO READ LOCKED/DELETED RECORD

4D9C
DEFB 11H 11
Entry 7: Word index 11H = "TRIED TO".
4D9D
DEFB 02H 02
Word index 02H = "READ".
4D9E
DEFB 4CH 4C
Word index 4CH = "LOCKED/DELETED".
4D9F
DEFB 88H 88
Word index 08H = "RECORD". Bit 7 is set, marking the end of this error message entry.

Error Code 07H — TRIED TO READ SYSTEM RECORD

4DA0
DEFB 11H 11
Entry 8: Word index 11H = "TRIED TO".
4DA1
DEFB 02H 02
Word index 02H = "READ".
4DA2
DEFB 3CH 3C
Word index 3CH = "SYSTEM".
4DA3
DEFB 88H 88
Word index 08H = "RECORD". Bit 7 is set, marking the end of this error message entry.

Error Code 08H — DEVICE NOT AVAILABLE

4DA4
DEFB 15H 15
Entry 9: Word index 15H = "DEVICE".
4DA5
DEFB 12H 12
Word index 12H = "NOT".
4DA6
DEFB 96H 96
Word index 16H = "AVAILABLE". Bit 7 is set, marking the end of this error message entry.

Error Code 09H — UNDEFINED ERROR CODE

4DA7
DEFB 49H 49
Entry 10: Word index 49H = "UNDEFINED".
4DA8
DEFB 01H 01
Word index 01H = "ERROR".
4DA9
DEFB A9H A9
Word index 29H = "CODE". Bit 7 is set, marking the end of this error message entry.

Error Code 0AH — SEEK ERROR DURING WRITE

4DAA
DEFB 0EH 0E
Entry 11: Word index 0EH = "SEEK".
4DAB
DEFB 01H 01
Word index 01H = "ERROR".
4DAC
DEFB 04H 04
Word index 04H = "DURING".
4DAD
DEFB 83H 83
Word index 03H = "WRITE". Bit 7 is set, marking the end of this error message entry.

Error Code 0BH — LOST DATA DURING WRITE

4DAE
DEFB 0DH 0D
Entry 12: Word index 0DH = "LOST".
4DAF
DEFB 0BH 0B
Word index 0BH = "DATA".
4DB0
DEFB 04H 04
Word index 04H = "DURING".
4DB1
DEFB 83H 83
Word index 03H = "WRITE". Bit 7 is set, marking the end of this error message entry.

Error Code 0CH — PARITY ERROR DURING WRITE

4DB2
DEFB 0CH 0C
Entry 13: Word index 0CH = "PARITY".
4DB3
DEFB 01H 01
Word index 01H = "ERROR".
4DB4
DEFB 04H 04
Word index 04H = "DURING".
4DB5
DEFB 83H 83
Word index 03H = "WRITE". Bit 7 is set, marking the end of this error message entry.

Error Code 0DH — DATA RECORD NOT FOUND DURING WRITE

4DB6
DEFB 0BH 0B
Entry 14: Word index 0BH = "DATA".
4DB7
DEFB 08H 08
Word index 08H = "RECORD".
4DB8
DEFB 12H 12
Word index 12H = "NOT".
4DB9
DEFB 31H 31
Word index 31H = "FOUND".
4DBA
DEFB 04H 04
Word index 04H = "DURING".
4DBB
DEFB 83H 83
Word index 03H = "WRITE". Bit 7 is set, marking the end of this error message entry.

Error Code 0EH — WRITE FAULT ON DISK DRIVE

4DBC
DEFB 03H 03
Entry 15: Word index 03H = "WRITE".
4DBD
DEFB 32H 32
Word index 32H = "FAULT".
4DBE
DEFB 19H 19
Word index 19H = "ON".
4DBF
DEFB 17H 17
Word index 17H = "DISK".
4DC0
DEFB 98H 98
Word index 18H = "DRIVE". Bit 7 is set, marking the end of this error message entry.

Error Code 0FH — WRITE PROTECTED DISKETTE

4DC1
DEFB 03H 03
Entry 16: Word index 03H = "WRITE".
4DC2
DEFB 46H 46
Word index 46H = "PROTECTED".
4DC3
DEFB C4H C4
Word index 44H = "DISKETTE". Bit 7 is set, marking the end of this error message entry.

Error Code 10H — DEVICE NOT AVAILABLE

4DC4
DEFB 15H 15
Entry 17: Word index 15H = "DEVICE".
4DC5
DEFB 12H 12
Word index 12H = "NOT".
4DC6
DEFB 96H 96
Word index 16H = "AVAILABLE". Bit 7 is set, marking the end of this error message entry.

Error Code 11H — DIRECTORY READ ERROR

4DC7
DEFB 07H 07
Entry 18: Word index 07H = "DIRECTORY".
4DC8
DEFB 02H 02
Word index 02H = "READ".
4DC9
DEFB 81H 81
Word index 01H = "ERROR". Bit 7 is set, marking the end of this error message entry.

Error Code 12H — DIRECTORY WRITE ERROR

4DCA
DEFB 07H 07
Entry 19: Word index 07H = "DIRECTORY".
4DCB
DEFB 03H 03
Word index 03H = "WRITE".
4DCC
DEFB 81H 81
Word index 01H = "ERROR". Bit 7 is set, marking the end of this error message entry.

Error Code 13H — ILLEGAL FILE NAME

4DCD
DEFB 06H 06
Entry 20: Word index 06H = "ILLEGAL".
4DCE
DEFB 05H 05
Word index 05H = "FILE".
4DCF
DEFB 89H 89
Word index 09H = "NAME". Bit 7 is set, marking the end of this error message entry.

Error Code 14H — TRACK # TOO HIGH

4DD0
DEFB 34H 34
Entry 21: Word index 34H = "TRACK".
4DD1
DEFB 1EH 1E
Word index 1EH = "#".
4DD2
DEFB 24H 24
Word index 24H = "TOO".
4DD3
DEFB AFH AF
Word index 2FH = "HIGH". Bit 7 is set, marking the end of this error message entry.

Error Code 15H — ILLEGAL FUNCTION UNDER DOS-CALL

4DD4
DEFB 06H 06
Entry 22: Word index 06H = "ILLEGAL".
4DD5
DEFB 47H 47
Word index 47H = "FUNCTION".
4DD6
DEFB 37H 37
Word index 37H = "UNDER".
4DD7
DEFB C5H C5
Word index 45H = "DOS-CALL". Bit 7 is set, marking the end of this error message entry.

Error Code 16H — UNDEFINED ERROR CODE

4DD8
DEFB 49H 49
Entry 23: Word index 49H = "UNDEFINED".
4DD9
DEFB 01H 01
Word index 01H = "ERROR".
4DDA
DEFB A9H A9
Word index 29H = "CODE". Bit 7 is set, marking the end of this error message entry.

Error Code 17H — UNDEFINED ERROR CODE

4DDB
DEFB 49H 49
Entry 24: Word index 49H = "UNDEFINED".
4DDC
DEFB 01H 01
Word index 01H = "ERROR".
4DDD
DEFB A9H A9
Word index 29H = "CODE". Bit 7 is set, marking the end of this error message entry.

Error Code 18H — FILE NOT IN DIRECTORY

4DDE
DEFB 05H 05
Entry 25: Word index 05H = "FILE".
4DDF
DEFB 12H 12
Word index 12H = "NOT".
4DE0
DEFB 1AH 1A
Word index 1AH = "IN".
4DE1
DEFB 87H 87
Word index 07H = "DIRECTORY". Bit 7 is set, marking the end of this error message entry.

Error Code 19H — FILE ACCESS DENIED

4DE2
DEFB 05H 05
Entry 26: Word index 05H = "FILE".
4DE3
DEFB 3EH 3E
Word index 3EH = "ACCESS".
4DE4
DEFB BDH BD
Word index 3DH = "DENIED". Bit 7 is set, marking the end of this error message entry.

Error Code 1AH — DIRECTORY SPACE FULL

4DE5
DEFB 07H 07
Entry 27: Word index 07H = "DIRECTORY".
4DE6
DEFB 0AH 0A
Word index 0AH = "SPACE".
4DE7
DEFB 94H 94
Word index 14H = "FULL". Bit 7 is set, marking the end of this error message entry.

Error Code 1BH — DISKETTE SPACE FULL

4DE8
DEFB 44H 44
Entry 28: Word index 44H = "DISKETTE".
4DE9
DEFB 0AH 0A
Word index 0AH = "SPACE".
4DEA
DEFB 94H 94
Word index 14H = "FULL". Bit 7 is set, marking the end of this error message entry.

Error Code 1CH — END OF FILE ENCOUNTERED

4DEB
DEFB 20H 20
Entry 29: Word index 20H = "END".
4DEC
DEFB 1CH 1C
Word index 1CH = "OF".
4DED
DEFB 05H 05
Word index 05H = "FILE".
4DEE
DEFB CBH CB
Word index 4BH = "ENCOUNTERED". Bit 7 is set, marking the end of this error message entry.

Error Code 1DH — PAST END OF FILE

4DEF
DEFB 2EH 2E
Entry 30: Word index 2EH = "PAST".
4DF0
DEFB 20H 20
Word index 20H = "END".
4DF1
DEFB 1CH 1C
Word index 1CH = "OF".
4DF2
DEFB 85H 85
Word index 05H = "FILE". Bit 7 is set, marking the end of this error message entry.

Error Code 1EH — DIRECTORY FULL . CAN'T EXTEND FILE

4DF3
DEFB 07H 07
Entry 31: Word index 07H = "DIRECTORY".
4DF4
DEFB 14H 14
Word index 14H = "FULL".
4DF5
DEFB 1DH 1D
Word index 1DH = ". ".
4DF6
DEFB 36H 36
Word index 36H = "CAN'T".
4DF7
DEFB 3FH 3F
Word index 3FH = "EXTEND".
4DF8
DEFB 85H 85
Word index 05H = "FILE". Bit 7 is set, marking the end of this error message entry.

Error Code 1FH — PROGRAM NOT FOUND

4DF9
DEFB 42H 42
Entry 32: Word index 42H = "PROGRAM".
4DFA
DEFB 12H 12
Word index 12H = "NOT".
4DFB
DEFB B1H B1
Word index 31H = "FOUND". Bit 7 is set, marking the end of this error message entry.

Error Code 20H — ILLEGAL OR MISSING DRIVE #

4DFC
DEFB 06H 06
Entry 33: Word index 06H = "ILLEGAL".
4DFD
DEFB 1BH 1B
Word index 1BH = "OR".
4DFE
DEFB 57H 57
Word index 57H = "MISSING".
4DFF
DEFB 18H 18
Word index 18H = "DRIVE".
4E00
DEFB 9EH 9E
Word index 1EH = "#". Bit 7 is set, marking the end of this error message entry.

Error Code 21H — NO DEVICE SPACE AVAILABLE

4E01
DEFB 13H 13
Entry 34: Word index 13H = "NO".
4E02
DEFB 15H 15
Word index 15H = "DEVICE".
4E03
DEFB 0AH 0A
Word index 0AH = "SPACE".
4E04
DEFB 96H 96
Word index 16H = "AVAILABLE". Bit 7 is set, marking the end of this error message entry.

Error Code 22H — LOAD FILE FORMAT ERROR

4E05
DEFB 27H 27
Entry 35: Word index 27H = "LOAD".
4E06
DEFB 05H 05
Word index 05H = "FILE".
4E07
DEFB 41H 41
Word index 41H = "FORMAT".
4E08
DEFB 81H 81
Word index 01H = "ERROR". Bit 7 is set, marking the end of this error message entry.

Error Code 23H — MEMORY FAULT

4E09
DEFB 40H 40
Entry 36: Word index 40H = "MEMORY".
4E0A
DEFB B2H B2
Word index 32H = "FAULT". Bit 7 is set, marking the end of this error message entry.

Error Code 24H — TRIED TO LOAD READ ONLY MEMORY

4E0B
DEFB 11H 11
Entry 37: Word index 11H = "TRIED TO".
4E0C
DEFB 27H 27
Word index 27H = "LOAD".
4E0D
DEFB 02H 02
Word index 02H = "READ".
4E0E
DEFB 28H 28
Word index 28H = "ONLY".
4E0F
DEFB C0H C0
Word index 40H = "MEMORY". Bit 7 is set, marking the end of this error message entry.

Error Code 25H — ILLEGAL ACCESS TRIED TO PROTECTED FILE

4E10
DEFB 06H 06
Entry 38: Word index 06H = "ILLEGAL".
4E11
DEFB 3EH 3E
Word index 3EH = "ACCESS".
4E12
DEFB 11H 11
Word index 11H = "TRIED TO".
4E13
DEFB 46H 46
Word index 46H = "PROTECTED".
4E14
DEFB 85H 85
Word index 05H = "FILE". Bit 7 is set, marking the end of this error message entry.

Error Code 26H — FILE NOT OPEN

4E15
DEFB 05H 05
Entry 39: Word index 05H = "FILE".
4E16
DEFB 12H 12
Word index 12H = "NOT".
4E17
DEFB A6H A6
Word index 26H = "OPEN". Bit 7 is set, marking the end of this error message entry.

Error Code 27H — ILLEGAL INITIALIZATION DATA ON SYSTEM DISKETTE

4E18
DEFB 06H 06
Entry 40: Word index 06H = "ILLEGAL".
4E19
DEFB 4AH 4A
Word index 4AH = "INITIALIZATION".
4E1A
DEFB 0BH 0B
Word index 0BH = "DATA".
4E1B
DEFB 19H 19
Word index 19H = "ON".
4E1C
DEFB 3CH 3C
Word index 3CH = "SYSTEM".
4E1D
DEFB C4H C4
Word index 44H = "DISKETTE". Bit 7 is set, marking the end of this error message entry.

Error Code 28H — ILLEGAL DISKETTE TRACK COUNT

4E1E
DEFB 06H 06
Entry 41: Word index 06H = "ILLEGAL".
4E1F
DEFB 44H 44
Word index 44H = "DISKETTE".
4E20
DEFB 34H 34
Word index 34H = "TRACK".
4E21
DEFB B5H B5
Word index 35H = "COUNT". Bit 7 is set, marking the end of this error message entry.

Error Code 29H — ILLEGAL LOGICAL FILE #

4E22
DEFB 06H 06
Entry 42: Word index 06H = "ILLEGAL".
4E23
DEFB 43H 43
Word index 43H = "LOGICAL".
4E24
DEFB 05H 05
Word index 05H = "FILE".
4E25
DEFB 9EH 9E
Word index 1EH = "#". Bit 7 is set, marking the end of this error message entry.

Error Code 2AH — ILLEGAL DOS FUNCTION

4E26
DEFB 06H 06
Entry 43: Word index 06H = "ILLEGAL".
4E27
DEFB 21H 21
Word index 21H = "DOS".
4E28
DEFB C7H C7
Word index 47H = "FUNCTION". Bit 7 is set, marking the end of this error message entry.

Error Code 2BH — ILLEGAL FUNCTION UNDER CHAINING

4E29
DEFB 06H 06
Entry 44: Word index 06H = "ILLEGAL".
4E2A
DEFB 47H 47
Word index 47H = "FUNCTION".
4E2B
DEFB 37H 37
Word index 37H = "UNDER".
4E2C
DEFB C8H C8
Word index 48H = "CHAINING". Bit 7 is set, marking the end of this error message entry.

Error Code 2CH — BAD DIRECTORY DATA

4E2D
DEFB 22H 22
Entry 45: Word index 22H = "BAD".
4E2E
DEFB 07H 07
Word index 07H = "DIRECTORY".
4E2F
DEFB 8BH 8B
Word index 0BH = "DATA". Bit 7 is set, marking the end of this error message entry.

Error Code 2DH — BAD FCB DATA

4E30
DEFB 22H 22
Entry 46: Word index 22H = "BAD".
4E31
DEFB 23H 23
Word index 23H = "FCB".
4E32
DEFB 8BH 8B
Word index 0BH = "DATA". Bit 7 is set, marking the end of this error message entry.

Error Code 2EH — SYSTEM PROGRAM NOT FOUND

4E33
DEFB 3CH 3C
Entry 47: Word index 3CH = "SYSTEM".
4E34
DEFB 42H 42
Word index 42H = "PROGRAM".
4E35
DEFB 12H 12
Word index 12H = "NOT".
4E36
DEFB B1H B1
Word index 31H = "FOUND". Bit 7 is set, marking the end of this error message entry.

Error Code 2FH — BAD PARAMETER(S)

4E37
DEFB 22H 22
Entry 48: Word index 22H = "BAD".
4E38
DEFB CDH CD
Word index 4DH = "PARAMETER(S)". Bit 7 is set, marking the end of this error message entry.

Error Code 30H — BAD FILESPEC

4E39
DEFB 22H 22
Entry 49: Word index 22H = "BAD".
4E3A
DEFB CEH CE
Word index 4EH = "FILESPEC". Bit 7 is set, marking the end of this error message entry.

Error Code 31H — WRONG DISKETTE RECORD TYPE

4E3B
DEFB 38H 38
Entry 50: Word index 38H = "WRONG".
4E3C
DEFB 44H 44
Word index 44H = "DISKETTE".
4E3D
DEFB 08H 08
Word index 08H = "RECORD".
4E3E
DEFB ABH AB
Word index 2BH = "TYPE". Bit 7 is set, marking the end of this error message entry.

Error Code 32H — BOOT READ ERROR

4E3F
DEFB 2AH 2A
Entry 51: Word index 2AH = "BOOT".
4E40
DEFB 02H 02
Word index 02H = "READ".
4E41
DEFB 81H 81
Word index 01H = "ERROR". Bit 7 is set, marking the end of this error message entry.

Error Code 33H — DOS FATAL ERROR

4E42
DEFB 21H 21
Entry 52: Word index 21H = "DOS".
4E43
DEFB 39H 39
Word index 39H = "FATAL".
4E44
DEFB 81H 81
Word index 01H = "ERROR". Bit 7 is set, marking the end of this error message entry.

Error Code 34H — ILLEGAL KEYWORD OR SEPARATOR OR TERMINATOR

4E45
DEFB 06H 06
Entry 53: Word index 06H = "ILLEGAL".
4E46
DEFB 50H 50
Word index 50H = "KEYWORD".
4E47
DEFB 1BH 1B
Word index 1BH = "OR".
4E48
DEFB 51H 51
Word index 51H = "SEPARATOR".
4E49
DEFB 1BH 1B
Word index 1BH = "OR".
4E4A
DEFB D2H D2
Word index 52H = "TERMINATOR". Bit 7 is set, marking the end of this error message entry.

Error Code 35H — FILE ALREADY EXISTS

4E4B
DEFB 05H 05
Entry 54: Word index 05H = "FILE".
4E4C
DEFB 4FH 4F
Word index 4FH = "ALREADY".
4E4D
DEFB BBH BB
Word index 3BH = "EXISTS". Bit 7 is set, marking the end of this error message entry.

Error Code 36H — COMMAND TOO LONG

4E4E
DEFB 55H 55
Entry 55: Word index 55H = "COMMAND".
4E4F
DEFB 24H 24
Word index 24H = "TOO".
4E50
DEFB ADH AD
Word index 2DH = "LONG". Bit 7 is set, marking the end of this error message entry.

Error Code 37H — DISKETTE ACCESS DENIED

4E51
DEFB 44H 44
Entry 56: Word index 44H = "DISKETTE".
4E52
DEFB 3EH 3E
Word index 3EH = "ACCESS".
4E53
DEFB BDH BD
Word index 3DH = "DENIED". Bit 7 is set, marking the end of this error message entry.

Error Code 38H — ILLEGAL MINI DOS FUNCTION

4E54
DEFB 06H 06
Entry 57: Word index 06H = "ILLEGAL".
4E55
DEFB 2CH 2C
Word index 2CH = "MINI".
4E56
DEFB 21H 21
Word index 21H = "DOS".
4E57
DEFB C7H C7
Word index 47H = "FUNCTION". Bit 7 is set, marking the end of this error message entry.

Error Code 39H — OPERATOR/PROGRAM/PARAMETER REQUIRE FUNCTION TERMINATION

4E58
DEFB 56H 56
Entry 58: Word index 56H = "OPERATOR/PROGRAM/PARAMETER".
4E59
DEFB 53H 53
Word index 53H = "REQUIRE".
4E5A
DEFB 47H 47
Word index 47H = "FUNCTION".
4E5B
DEFB D4H D4
Word index 54H = "TERMINATION". Bit 7 is set, marking the end of this error message entry.

Error Code 3AH — DATA COMPARE MISMATCH

4E5C
DEFB 0BH 0B
Entry 59: Word index 0BH = "DATA".
4E5D
DEFB 58H 58
Word index 58H = "COMPARE".
4E5E
DEFB D9H D9
Word index 59H = "MISMATCH". Bit 7 is set, marking the end of this error message entry.

Error Code 3BH — INSUFFICIENT MEMORY

4E5F
DEFB 5AH 5A
Entry 60: Word index 5AH = "INSUFFICIENT".
4E60
DEFB C0H C0
Word index 40H = "MEMORY". Bit 7 is set, marking the end of this error message entry.

Error Code 3CH — INCOMPATIBLE DRIVES OR DISKETTES

4E61
DEFB 5BH 5B
Entry 61: Word index 5BH = "INCOMPATIBLE".
4E62
DEFB 5CH 5C
Word index 5CH = "DRIVES".
4E63
DEFB 1BH 1B
Word index 1BH = "OR".
4E64
DEFB DDH DD
Word index 5DH = "DISKETTES". Bit 7 is set, marking the end of this error message entry.

Error Code 3DH — ASE=N ATTRIBUTE . CAN'T EXTEND FILE

4E65
DEFB 3AH 3A
Entry 62: Word index 3AH = "ASE=N".
4E66
DEFB 5EH 5E
Word index 5EH = "ATTRIBUTE".
4E67
DEFB 1DH 1D
Word index 1DH = ". ".
4E68
DEFB 36H 36
Word index 36H = "CAN'T".
4E69
DEFB 3FH 3F
Word index 3FH = "EXTEND".
4E6A
DEFB 85H 85
Word index 05H = "FILE". Bit 7 is set, marking the end of this error message entry.

Error Code 3EH — CAN'T EXTEND FILE VIA READ

4E6B
DEFB 36H 36
Entry 63: Word index 36H = "CAN'T".
4E6C
DEFB 3FH 3F
Word index 3FH = "EXTEND".
4E6D
DEFB 05H 05
Word index 05H = "FILE".
4E6E
DEFB 25H 25
Word index 25H = "VIA".
4E6F
DEFB 82H 82
Word index 02H = "READ". Bit 7 is set, marking the end of this error message entry.

Error Code 3FH — UNDEFINED ERROR CODE

4E70
DEFB 00H 00
Null word index (00H). This placeholder is skipped by the display loop (JR Z at 4D51H).
4E71
DEFB 49H 49
Word index 49H = "UNDEFINED".
4E72
DEFB 01H 01
Word index 01H = "ERROR".
4E73
DEFB A9H A9
Word index 29H = "CODE". Bit 7 is set, marking the end of this error message entry.

Error Code 40H —

4E74
DEFB 80H 80
Null word index (00H). This placeholder is skipped by the display loop (JR Z at 4D51H). Bit 7 is set, marking the end of this error message entry.

4E74H - Word Component Table (ASCII Strings with High-Bit Termination)

This is the Word Component Table containing 95 words (indices 00H-5EH) used to compose error messages. Each word is stored as a sequence of standard 7-bit ASCII characters, with the high bit (bit 7) set on the last character of each word to serve as a terminator. The display routine at 4D5EH strips bit 7 with AND 7FH before printing each character via ROM routine 0033H, then tests the original byte with RLCA to detect the end-of-word marker. For example, the word "ERROR" is stored as 45H 52H 52H 4FH D2H — the final byte D2H = 52H OR 80H, which is the ASCII code for R (52H) with bit 7 set to mark it as the last character. The disassembler incorrectly interpreted these data bytes as Z80 instructions.

Word 00H (Sentinel) — A single null byte (80H = 00H + 80H) that serves as both the sentinel entry in the word table and the last byte of error table entry 64. Word index 00H is never printed; it is caught by the JR Z at 4D51H.

4E74
DEFB 80H 80
Sentinel: byte 80H = 00H with bit 7 set. This 1-byte "word" is the null terminator for word index 00H. The character value after stripping bit 7 is 00H (non-printable). The high bit (bit 7 = 1) marks this as both the first and last byte of this word.

Word 01H (1) — "ERROR"

4E75
DEFM 'ERRO' 45 52 52 4F
ASCII characters: 45H=E, 52H=R, 52H=R, 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4E79
DEFB D2H D2
Final character: byte D2H = ASCII R (52H) with bit 7 set. The raw byte D2H = 52H OR 80H. Bit 7 = 1 marks this as the last character of word "ERROR". The display routine strips bit 7 with AND 7FH to recover the printable character R before calling ROM 0033H.

Word 02H (2) — "READ"

4E7A
DEFM 'REA' 52 45 41
ASCII characters: 52H=R, 45H=E, 41H=A. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4E7D
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "READ". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 03H (3) — "WRITE"

4E7E
DEFM 'WRIT' 57 52 49 54
ASCII characters: 57H=W, 52H=R, 49H=I, 54H=T. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4E82
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "WRITE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 04H (4) — "DURING"

4E83
DEFM 'DURIN' 44 55 52 49 4E
ASCII characters: 44H=D, 55H=U, 52H=R, 49H=I, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4E88
DEFB C7H C7
Final character: byte C7H = ASCII G (47H) with bit 7 set. The raw byte C7H = 47H OR 80H. Bit 7 = 1 marks this as the last character of word "DURING". The display routine strips bit 7 with AND 7FH to recover the printable character G before calling ROM 0033H.

Word 05H (5) — "FILE"

4E89
DEFM 'FIL' 46 49 4C
ASCII characters: 46H=F, 49H=I, 4CH=L. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4E8C
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "FILE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 06H (6) — "ILLEGAL"

4E8D
DEFM 'ILLEGA' 49 4C 4C 45 47 41
ASCII characters: 49H=I, 4CH=L, 4CH=L, 45H=E, 47H=G, 41H=A. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4E93
DEFB CCH CC
Final character: byte CCH = ASCII L (4CH) with bit 7 set. The raw byte CCH = 4CH OR 80H. Bit 7 = 1 marks this as the last character of word "ILLEGAL". The display routine strips bit 7 with AND 7FH to recover the printable character L before calling ROM 0033H.

Word 07H (7) — "DIRECTORY"

4E94
DEFM 'DIRECTOR' 44 49 52 45 43 54 4F 52
ASCII characters: 44H=D, 49H=I, 52H=R, 45H=E, 43H=C, 54H=T, 4FH=O, 52H=R. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4E9C
DEFB D9H D9
Final character: byte D9H = ASCII Y (59H) with bit 7 set. The raw byte D9H = 59H OR 80H. Bit 7 = 1 marks this as the last character of word "DIRECTORY". The display routine strips bit 7 with AND 7FH to recover the printable character Y before calling ROM 0033H.

Word 08H (8) — "RECORD"

4E9D
DEFM 'RECOR' 52 45 43 4F 52
ASCII characters: 52H=R, 45H=E, 43H=C, 4FH=O, 52H=R. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EA2
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "RECORD". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 09H (9) — "NAME"

4EA3
DEFM 'NAM' 4E 41 4D
ASCII characters: 4EH=N, 41H=A, 4DH=M. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EA6
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "NAME". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 0AH (10) — "SPACE"

4EA7
DEFM 'SPAC' 53 50 41 43
ASCII characters: 53H=S, 50H=P, 41H=A, 43H=C. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EAB
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "SPACE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 0BH (11) — "DATA"

4EAC
DEFM 'DAT' 44 41 54
ASCII characters: 44H=D, 41H=A, 54H=T. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EAF
DEFB C1H C1
Final character: byte C1H = ASCII A (41H) with bit 7 set. The raw byte C1H = 41H OR 80H. Bit 7 = 1 marks this as the last character of word "DATA". The display routine strips bit 7 with AND 7FH to recover the printable character A before calling ROM 0033H.

Word 0CH (12) — "PARITY"

4EB0
DEFM 'PARIT' 50 41 52 49 54
ASCII characters: 50H=P, 41H=A, 52H=R, 49H=I, 54H=T. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EB5
DEFB D9H D9
Final character: byte D9H = ASCII Y (59H) with bit 7 set. The raw byte D9H = 59H OR 80H. Bit 7 = 1 marks this as the last character of word "PARITY". The display routine strips bit 7 with AND 7FH to recover the printable character Y before calling ROM 0033H.

Word 0DH (13) — "LOST"

4EB6
DEFM 'LOS' 4C 4F 53
ASCII characters: 4CH=L, 4FH=O, 53H=S. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EB9
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "LOST". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 0EH (14) — "SEEK"

4EBA
DEFM 'SEE' 53 45 45
ASCII characters: 53H=S, 45H=E, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EBD
DEFB CBH CB
Final character: byte CBH = ASCII K (4BH) with bit 7 set. The raw byte CBH = 4BH OR 80H. Bit 7 = 1 marks this as the last character of word "SEEK". The display routine strips bit 7 with AND 7FH to recover the printable character K before calling ROM 0033H.

Word 0FH (15) — "GAT"

4EBE
DEFM 'GA' 47 41
ASCII characters: 47H=G, 41H=A. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EC0
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "GAT". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 10H (16) — "HIT"

4EC1
DEFM 'HI' 48 49
ASCII characters: 48H=H, 49H=I. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EC3
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "HIT". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 11H (17) — "TRIED TO"

4EC4
DEFM 'TRIED T' 54 52 49 45 44 20 54
ASCII characters: 54H=T, 52H=R, 49H=I, 45H=E, 44H=D, 20H= , 54H=T. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4ECB
DEFB CFH CF
Final character: byte CFH = ASCII O (4FH) with bit 7 set. The raw byte CFH = 4FH OR 80H. Bit 7 = 1 marks this as the last character of word "TRIED TO". The display routine strips bit 7 with AND 7FH to recover the printable character O before calling ROM 0033H.

Word 12H (18) — "NOT"

4ECC
DEFM 'NO' 4E 4F
ASCII characters: 4EH=N, 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4ECE
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "NOT". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 13H (19) — "NO"

4ECF
DEFM 'N' 4E
ASCII characters: 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4ED0
DEFB CFH CF
Final character: byte CFH = ASCII O (4FH) with bit 7 set. The raw byte CFH = 4FH OR 80H. Bit 7 = 1 marks this as the last character of word "NO". The display routine strips bit 7 with AND 7FH to recover the printable character O before calling ROM 0033H.

Word 14H (20) — "FULL"

4ED1
DEFM 'FUL' 46 55 4C
ASCII characters: 46H=F, 55H=U, 4CH=L. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4ED4
DEFB CCH CC
Final character: byte CCH = ASCII L (4CH) with bit 7 set. The raw byte CCH = 4CH OR 80H. Bit 7 = 1 marks this as the last character of word "FULL". The display routine strips bit 7 with AND 7FH to recover the printable character L before calling ROM 0033H.

Word 15H (21) — "DEVICE"

4ED5
DEFM 'DEVIC' 44 45 56 49 43
ASCII characters: 44H=D, 45H=E, 56H=V, 49H=I, 43H=C. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EDA
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "DEVICE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 16H (22) — "AVAILABLE"

4EDB
DEFM 'AVAILABL' 41 56 41 49 4C 41 42 4C
ASCII characters: 41H=A, 56H=V, 41H=A, 49H=I, 4CH=L, 41H=A, 42H=B, 4CH=L. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EE3
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "AVAILABLE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 17H (23) — "DISK"

4EE4
DEFM 'DIS' 44 49 53
ASCII characters: 44H=D, 49H=I, 53H=S. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EE7
DEFB CBH CB
Final character: byte CBH = ASCII K (4BH) with bit 7 set. The raw byte CBH = 4BH OR 80H. Bit 7 = 1 marks this as the last character of word "DISK". The display routine strips bit 7 with AND 7FH to recover the printable character K before calling ROM 0033H.

Word 18H (24) — "DRIVE"

4EE8
DEFM 'DRIV' 44 52 49 56
ASCII characters: 44H=D, 52H=R, 49H=I, 56H=V. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EEC
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "DRIVE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 19H (25) — "ON"

4EED
DEFM 'O' 4F
ASCII characters: 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EEE
DEFB CEH CE
Final character: byte CEH = ASCII N (4EH) with bit 7 set. The raw byte CEH = 4EH OR 80H. Bit 7 = 1 marks this as the last character of word "ON". The display routine strips bit 7 with AND 7FH to recover the printable character N before calling ROM 0033H.

Word 1AH (26) — "IN"

4EEF
DEFM 'I' 49
ASCII characters: 49H=I. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EF0
DEFB CEH CE
Final character: byte CEH = ASCII N (4EH) with bit 7 set. The raw byte CEH = 4EH OR 80H. Bit 7 = 1 marks this as the last character of word "IN". The display routine strips bit 7 with AND 7FH to recover the printable character N before calling ROM 0033H.

Word 1BH (27) — "OR"

4EF1
DEFM 'O' 4F
ASCII characters: 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EF2
DEFB D2H D2
Final character: byte D2H = ASCII R (52H) with bit 7 set. The raw byte D2H = 52H OR 80H. Bit 7 = 1 marks this as the last character of word "OR". The display routine strips bit 7 with AND 7FH to recover the printable character R before calling ROM 0033H.

Word 1CH (28) — "OF"

4EF3
DEFM 'O' 4F
ASCII characters: 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EF4
DEFB C6H C6
Final character: byte C6H = ASCII F (46H) with bit 7 set. The raw byte C6H = 46H OR 80H. Bit 7 = 1 marks this as the last character of word "OF". The display routine strips bit 7 with AND 7FH to recover the printable character F before calling ROM 0033H.

Word 1DH (29) — ". "

4EF5
DEFM '.' 2E
ASCII characters: 2EH=.. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EF6
DEFB A0H A0
Final character: byte A0H = ASCII (20H) with bit 7 set. The raw byte A0H = 20H OR 80H. Bit 7 = 1 marks this as the last character of word ". ". The display routine strips bit 7 with AND 7FH to recover the printable character before calling ROM 0033H.

Word 1EH (30) — "#"

4EF7
DEFB A3H A3
Single-character word: byte A3H = ASCII # (23H) with bit 7 set. The raw byte A3H = 23H OR 80H. Bit 7 = 1 marks this as the last (and only) character.

Word 1FH (31) — "OUT"

4EF8
DEFM 'OU' 4F 55
ASCII characters: 4FH=O, 55H=U. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EFA
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "OUT". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 20H (32) — "END"

4EFB
DEFM 'EN' 45 4E
ASCII characters: 45H=E, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4EFD
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "END". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 21H (33) — "DOS"

4EFE
DEFM 'DO' 44 4F
ASCII characters: 44H=D, 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F00
DEFB D3H D3
Final character: byte D3H = ASCII S (53H) with bit 7 set. The raw byte D3H = 53H OR 80H. Bit 7 = 1 marks this as the last character of word "DOS". The display routine strips bit 7 with AND 7FH to recover the printable character S before calling ROM 0033H.

Word 22H (34) — "BAD"

4F01
DEFM 'BA' 42 41
ASCII characters: 42H=B, 41H=A. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F03
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "BAD". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 23H (35) — "FCB"

4F04
DEFM 'FC' 46 43
ASCII characters: 46H=F, 43H=C. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F06
DEFB C2H C2
Final character: byte C2H = ASCII B (42H) with bit 7 set. The raw byte C2H = 42H OR 80H. Bit 7 = 1 marks this as the last character of word "FCB". The display routine strips bit 7 with AND 7FH to recover the printable character B before calling ROM 0033H.

Word 24H (36) — "TOO"

4F07
DEFM 'TO' 54 4F
ASCII characters: 54H=T, 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F09
DEFB CFH CF
Final character: byte CFH = ASCII O (4FH) with bit 7 set. The raw byte CFH = 4FH OR 80H. Bit 7 = 1 marks this as the last character of word "TOO". The display routine strips bit 7 with AND 7FH to recover the printable character O before calling ROM 0033H.

Word 25H (37) — "VIA"

4F0A
DEFM 'VI' 56 49
ASCII characters: 56H=V, 49H=I. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F0C
DEFB C1H C1
Final character: byte C1H = ASCII A (41H) with bit 7 set. The raw byte C1H = 41H OR 80H. Bit 7 = 1 marks this as the last character of word "VIA". The display routine strips bit 7 with AND 7FH to recover the printable character A before calling ROM 0033H.

Word 26H (38) — "OPEN"

4F0D
DEFM 'OPE' 4F 50 45
ASCII characters: 4FH=O, 50H=P, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F10
DEFB CEH CE
Final character: byte CEH = ASCII N (4EH) with bit 7 set. The raw byte CEH = 4EH OR 80H. Bit 7 = 1 marks this as the last character of word "OPEN". The display routine strips bit 7 with AND 7FH to recover the printable character N before calling ROM 0033H.

Word 27H (39) — "LOAD"

4F11
DEFM 'LOA' 4C 4F 41
ASCII characters: 4CH=L, 4FH=O, 41H=A. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F14
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "LOAD". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 28H (40) — "ONLY"

4F15
DEFM 'ONL' 4F 4E 4C
ASCII characters: 4FH=O, 4EH=N, 4CH=L. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F18
DEFB D9H D9
Final character: byte D9H = ASCII Y (59H) with bit 7 set. The raw byte D9H = 59H OR 80H. Bit 7 = 1 marks this as the last character of word "ONLY". The display routine strips bit 7 with AND 7FH to recover the printable character Y before calling ROM 0033H.

Word 29H (41) — "CODE"

4F19
DEFM 'COD' 43 4F 44
ASCII characters: 43H=C, 4FH=O, 44H=D. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F1C
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "CODE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 2AH (42) — "BOOT"

4F1D
DEFM 'BOO' 42 4F 4F
ASCII characters: 42H=B, 4FH=O, 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F20
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "BOOT". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 2BH (43) — "TYPE"

4F21
DEFM 'TYP' 54 59 50
ASCII characters: 54H=T, 59H=Y, 50H=P. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F24
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "TYPE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 2CH (44) — "MINI"

4F25
DEFM 'MIN' 4D 49 4E
ASCII characters: 4DH=M, 49H=I, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F28
DEFB C9H C9
Final character: byte C9H = ASCII I (49H) with bit 7 set. The raw byte C9H = 49H OR 80H. Bit 7 = 1 marks this as the last character of word "MINI". The display routine strips bit 7 with AND 7FH to recover the printable character I before calling ROM 0033H.

Word 2DH (45) — "LONG"

4F29
DEFM 'LON' 4C 4F 4E
ASCII characters: 4CH=L, 4FH=O, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F2C
DEFB C7H C7
Final character: byte C7H = ASCII G (47H) with bit 7 set. The raw byte C7H = 47H OR 80H. Bit 7 = 1 marks this as the last character of word "LONG". The display routine strips bit 7 with AND 7FH to recover the printable character G before calling ROM 0033H.

Word 2EH (46) — "PAST"

4F2D
DEFM 'PAS' 50 41 53
ASCII characters: 50H=P, 41H=A, 53H=S. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F30
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "PAST". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 2FH (47) — "HIGH"

4F31
DEFM 'HIG' 48 49 47
ASCII characters: 48H=H, 49H=I, 47H=G. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F34
DEFB C8H C8
Final character: byte C8H = ASCII H (48H) with bit 7 set. The raw byte C8H = 48H OR 80H. Bit 7 = 1 marks this as the last character of word "HIGH". The display routine strips bit 7 with AND 7FH to recover the printable character H before calling ROM 0033H.

Word 30H (48) — "HEADER"

4F35
DEFM 'HEADE' 48 45 41 44 45
ASCII characters: 48H=H, 45H=E, 41H=A, 44H=D, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F3A
DEFB D2H D2
Final character: byte D2H = ASCII R (52H) with bit 7 set. The raw byte D2H = 52H OR 80H. Bit 7 = 1 marks this as the last character of word "HEADER". The display routine strips bit 7 with AND 7FH to recover the printable character R before calling ROM 0033H.

Word 31H (49) — "FOUND"

4F3B
DEFM 'FOUN' 46 4F 55 4E
ASCII characters: 46H=F, 4FH=O, 55H=U, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F3F
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "FOUND". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 32H (50) — "FAULT"

4F40
DEFM 'FAUL' 46 41 55 4C
ASCII characters: 46H=F, 41H=A, 55H=U, 4CH=L. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F44
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "FAULT". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 33H (51) — "RANGE"

4F45
DEFM 'RANG' 52 41 4E 47
ASCII characters: 52H=R, 41H=A, 4EH=N, 47H=G. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F49
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "RANGE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 34H (52) — "TRACK"

4F4A
DEFM 'TRAC' 54 52 41 43
ASCII characters: 54H=T, 52H=R, 41H=A, 43H=C. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F4E
DEFB CBH CB
Final character: byte CBH = ASCII K (4BH) with bit 7 set. The raw byte CBH = 4BH OR 80H. Bit 7 = 1 marks this as the last character of word "TRACK". The display routine strips bit 7 with AND 7FH to recover the printable character K before calling ROM 0033H.

Word 35H (53) — "COUNT"

4F4F
DEFM 'COUN' 43 4F 55 4E
ASCII characters: 43H=C, 4FH=O, 55H=U, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F53
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "COUNT". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 36H (54) — "CAN'T"

4F54
DEFM 'CAN'' 43 41 4E 27
ASCII characters: 43H=C, 41H=A, 4EH=N, 27H='. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F58
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "CAN'T". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 37H (55) — "UNDER"

4F59
DEFM 'UNDE' 55 4E 44 45
ASCII characters: 55H=U, 4EH=N, 44H=D, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F5D
DEFB D2H D2
Final character: byte D2H = ASCII R (52H) with bit 7 set. The raw byte D2H = 52H OR 80H. Bit 7 = 1 marks this as the last character of word "UNDER". The display routine strips bit 7 with AND 7FH to recover the printable character R before calling ROM 0033H.

Word 38H (56) — "WRONG"

4F5E
DEFM 'WRON' 57 52 4F 4E
ASCII characters: 57H=W, 52H=R, 4FH=O, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F62
DEFB C7H C7
Final character: byte C7H = ASCII G (47H) with bit 7 set. The raw byte C7H = 47H OR 80H. Bit 7 = 1 marks this as the last character of word "WRONG". The display routine strips bit 7 with AND 7FH to recover the printable character G before calling ROM 0033H.

Word 39H (57) — "FATAL"

4F63
DEFM 'FATA' 46 41 54 41
ASCII characters: 46H=F, 41H=A, 54H=T, 41H=A. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F67
DEFB CCH CC
Final character: byte CCH = ASCII L (4CH) with bit 7 set. The raw byte CCH = 4CH OR 80H. Bit 7 = 1 marks this as the last character of word "FATAL". The display routine strips bit 7 with AND 7FH to recover the printable character L before calling ROM 0033H.

Word 3AH (58) — "ASE=N"

4F68
DEFM 'ASE=' 41 53 45 3D
ASCII characters: 41H=A, 53H=S, 45H=E, 3DH==. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F6C
DEFB CEH CE
Final character: byte CEH = ASCII N (4EH) with bit 7 set. The raw byte CEH = 4EH OR 80H. Bit 7 = 1 marks this as the last character of word "ASE=N". The display routine strips bit 7 with AND 7FH to recover the printable character N before calling ROM 0033H.

Word 3BH (59) — "EXISTS"

4F6D
DEFM 'EXIST' 45 58 49 53 54
ASCII characters: 45H=E, 58H=X, 49H=I, 53H=S, 54H=T. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F72
DEFB D3H D3
Final character: byte D3H = ASCII S (53H) with bit 7 set. The raw byte D3H = 53H OR 80H. Bit 7 = 1 marks this as the last character of word "EXISTS". The display routine strips bit 7 with AND 7FH to recover the printable character S before calling ROM 0033H.

Word 3CH (60) — "SYSTEM"

4F73
DEFM 'SYSTE' 53 59 53 54 45
ASCII characters: 53H=S, 59H=Y, 53H=S, 54H=T, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F78
DEFB CDH CD
Final character: byte CDH = ASCII M (4DH) with bit 7 set. The raw byte CDH = 4DH OR 80H. Bit 7 = 1 marks this as the last character of word "SYSTEM". The display routine strips bit 7 with AND 7FH to recover the printable character M before calling ROM 0033H.

Word 3DH (61) — "DENIED"

4F79
DEFM 'DENIE' 44 45 4E 49 45
ASCII characters: 44H=D, 45H=E, 4EH=N, 49H=I, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F7E
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "DENIED". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 3EH (62) — "ACCESS"

4F7F
DEFM 'ACCES' 41 43 43 45 53
ASCII characters: 41H=A, 43H=C, 43H=C, 45H=E, 53H=S. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F84
DEFB D3H D3
Final character: byte D3H = ASCII S (53H) with bit 7 set. The raw byte D3H = 53H OR 80H. Bit 7 = 1 marks this as the last character of word "ACCESS". The display routine strips bit 7 with AND 7FH to recover the printable character S before calling ROM 0033H.

Word 3FH (63) — "EXTEND"

4F85
DEFM 'EXTEN' 45 58 54 45 4E
ASCII characters: 45H=E, 58H=X, 54H=T, 45H=E, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F8A
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "EXTEND". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 40H (64) — "MEMORY"

4F8B
DEFM 'MEMOR' 4D 45 4D 4F 52
ASCII characters: 4DH=M, 45H=E, 4DH=M, 4FH=O, 52H=R. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F90
DEFB D9H D9
Final character: byte D9H = ASCII Y (59H) with bit 7 set. The raw byte D9H = 59H OR 80H. Bit 7 = 1 marks this as the last character of word "MEMORY". The display routine strips bit 7 with AND 7FH to recover the printable character Y before calling ROM 0033H.

Word 41H (65) — "FORMAT"

4F91
DEFM 'FORMA' 46 4F 52 4D 41
ASCII characters: 46H=F, 4FH=O, 52H=R, 4DH=M, 41H=A. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F96
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "FORMAT". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 42H (66) — "PROGRAM"

4F97
DEFM 'PROGRA' 50 52 4F 47 52 41
ASCII characters: 50H=P, 52H=R, 4FH=O, 47H=G, 52H=R, 41H=A. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4F9D
DEFB CDH CD
Final character: byte CDH = ASCII M (4DH) with bit 7 set. The raw byte CDH = 4DH OR 80H. Bit 7 = 1 marks this as the last character of word "PROGRAM". The display routine strips bit 7 with AND 7FH to recover the printable character M before calling ROM 0033H.

Word 43H (67) — "LOGICAL"

4F9E
DEFM 'LOGICA' 4C 4F 47 49 43 41
ASCII characters: 4CH=L, 4FH=O, 47H=G, 49H=I, 43H=C, 41H=A. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4FA4
DEFB CCH CC
Final character: byte CCH = ASCII L (4CH) with bit 7 set. The raw byte CCH = 4CH OR 80H. Bit 7 = 1 marks this as the last character of word "LOGICAL". The display routine strips bit 7 with AND 7FH to recover the printable character L before calling ROM 0033H.

Word 44H (68) — "DISKETTE"

4FA5
DEFM 'DISKETT' 44 49 53 4B 45 54 54
ASCII characters: 44H=D, 49H=I, 53H=S, 4BH=K, 45H=E, 54H=T, 54H=T. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4FAC
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "DISKETTE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 45H (69) — "DOS-CALL"

4FAD
DEFM 'DOS-CAL' 44 4F 53 2D 43 41 4C
ASCII characters: 44H=D, 4FH=O, 53H=S, 2DH=-, 43H=C, 41H=A, 4CH=L. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4FB4
DEFB CCH CC
Final character: byte CCH = ASCII L (4CH) with bit 7 set. The raw byte CCH = 4CH OR 80H. Bit 7 = 1 marks this as the last character of word "DOS-CALL". The display routine strips bit 7 with AND 7FH to recover the printable character L before calling ROM 0033H.

Word 46H (70) — "PROTECTED"

4FB5
DEFM 'PROTECTE' 50 52 4F 54 45 43 54 45
ASCII characters: 50H=P, 52H=R, 4FH=O, 54H=T, 45H=E, 43H=C, 54H=T, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4FBD
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "PROTECTED". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 47H (71) — "FUNCTION"

4FBE
DEFM 'FUNCTIO' 46 55 4E 43 54 49 4F
ASCII characters: 46H=F, 55H=U, 4EH=N, 43H=C, 54H=T, 49H=I, 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4FC5
DEFB CEH CE
Final character: byte CEH = ASCII N (4EH) with bit 7 set. The raw byte CEH = 4EH OR 80H. Bit 7 = 1 marks this as the last character of word "FUNCTION". The display routine strips bit 7 with AND 7FH to recover the printable character N before calling ROM 0033H.

Word 48H (72) — "CHAINING"

4FC6
DEFM 'CHAININ' 43 48 41 49 4E 49 4E
ASCII characters: 43H=C, 48H=H, 41H=A, 49H=I, 4EH=N, 49H=I, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4FCD
DEFB C7H C7
Final character: byte C7H = ASCII G (47H) with bit 7 set. The raw byte C7H = 47H OR 80H. Bit 7 = 1 marks this as the last character of word "CHAINING". The display routine strips bit 7 with AND 7FH to recover the printable character G before calling ROM 0033H.

Word 49H (73) — "UNDEFINED"

4FCE
DEFM 'UNDEFINE' 55 4E 44 45 46 49 4E 45
ASCII characters: 55H=U, 4EH=N, 44H=D, 45H=E, 46H=F, 49H=I, 4EH=N, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4FD6
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "UNDEFINED". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 4AH (74) — "INITIALIZATION"

4FD7
DEFM 'INITIALIZATIO' 49 4E 49 54 49 41 4C 49 5A 41 54 49 4F
ASCII characters: 49H=I, 4EH=N, 49H=I, 54H=T, 49H=I, 41H=A, 4CH=L, 49H=I, 5AH=Z, 41H=A, 54H=T, 49H=I, 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4FE4
DEFB CEH CE
Final character: byte CEH = ASCII N (4EH) with bit 7 set. The raw byte CEH = 4EH OR 80H. Bit 7 = 1 marks this as the last character of word "INITIALIZATION". The display routine strips bit 7 with AND 7FH to recover the printable character N before calling ROM 0033H.

Word 4BH (75) — "ENCOUNTERED"

4FE5
DEFM 'ENCOUNTERE' 45 4E 43 4F 55 4E 54 45 52 45
ASCII characters: 45H=E, 4EH=N, 43H=C, 4FH=O, 55H=U, 4EH=N, 54H=T, 45H=E, 52H=R, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4FEF
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "ENCOUNTERED". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 4CH (76) — "LOCKED/DELETED"

4FF0
DEFM 'LOCKED/DELETE' 4C 4F 43 4B 45 44 2F 44 45 4C 45 54 45
ASCII characters: 4CH=L, 4FH=O, 43H=C, 4BH=K, 45H=E, 44H=D, 2FH=/, 44H=D, 45H=E, 4CH=L, 45H=E, 54H=T, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
4FFD
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "LOCKED/DELETED". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 4DH (77) — "PARAMETER(S)"

4FFE
DEFM 'PARAMETER(S' 50 41 52 41 4D 45 54 45 52 28 53
ASCII characters: 50H=P, 41H=A, 52H=R, 41H=A, 4DH=M, 45H=E, 54H=T, 45H=E, 52H=R, 28H=(, 53H=S. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5009
DEFB A9H A9
Final character: byte A9H = ASCII ) (29H) with bit 7 set. The raw byte A9H = 29H OR 80H. Bit 7 = 1 marks this as the last character of word "PARAMETER(S)". The display routine strips bit 7 with AND 7FH to recover the printable character ) before calling ROM 0033H.

Word 4EH (78) — "FILESPEC"

500A
DEFM 'FILESPE' 46 49 4C 45 53 50 45
ASCII characters: 46H=F, 49H=I, 4CH=L, 45H=E, 53H=S, 50H=P, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5011
DEFB C3H C3
Final character: byte C3H = ASCII C (43H) with bit 7 set. The raw byte C3H = 43H OR 80H. Bit 7 = 1 marks this as the last character of word "FILESPEC". The display routine strips bit 7 with AND 7FH to recover the printable character C before calling ROM 0033H.

Word 4FH (79) — "ALREADY"

5012
DEFM 'ALREAD' 41 4C 52 45 41 44
ASCII characters: 41H=A, 4CH=L, 52H=R, 45H=E, 41H=A, 44H=D. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5018
DEFB D9H D9
Final character: byte D9H = ASCII Y (59H) with bit 7 set. The raw byte D9H = 59H OR 80H. Bit 7 = 1 marks this as the last character of word "ALREADY". The display routine strips bit 7 with AND 7FH to recover the printable character Y before calling ROM 0033H.

Word 50H (80) — "KEYWORD"

5019
DEFM 'KEYWOR' 4B 45 59 57 4F 52
ASCII characters: 4BH=K, 45H=E, 59H=Y, 57H=W, 4FH=O, 52H=R. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
501F
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "KEYWORD". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 51H (81) — "SEPARATOR"

5020
DEFM 'SEPARATO' 53 45 50 41 52 41 54 4F
ASCII characters: 53H=S, 45H=E, 50H=P, 41H=A, 52H=R, 41H=A, 54H=T, 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5028
DEFB D2H D2
Final character: byte D2H = ASCII R (52H) with bit 7 set. The raw byte D2H = 52H OR 80H. Bit 7 = 1 marks this as the last character of word "SEPARATOR". The display routine strips bit 7 with AND 7FH to recover the printable character R before calling ROM 0033H.

Word 52H (82) — "TERMINATOR"

5029
DEFM 'TERMINATO' 54 45 52 4D 49 4E 41 54 4F
ASCII characters: 54H=T, 45H=E, 52H=R, 4DH=M, 49H=I, 4EH=N, 41H=A, 54H=T, 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5032
DEFB D2H D2
Final character: byte D2H = ASCII R (52H) with bit 7 set. The raw byte D2H = 52H OR 80H. Bit 7 = 1 marks this as the last character of word "TERMINATOR". The display routine strips bit 7 with AND 7FH to recover the printable character R before calling ROM 0033H.

Word 53H (83) — "REQUIRE"

5033
DEFM 'REQUIR' 52 45 51 55 49 52
ASCII characters: 52H=R, 45H=E, 51H=Q, 55H=U, 49H=I, 52H=R. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5039
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "REQUIRE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 54H (84) — "TERMINATION"

503A
DEFM 'TERMINATIO' 54 45 52 4D 49 4E 41 54 49 4F
ASCII characters: 54H=T, 45H=E, 52H=R, 4DH=M, 49H=I, 4EH=N, 41H=A, 54H=T, 49H=I, 4FH=O. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5044
DEFB CEH CE
Final character: byte CEH = ASCII N (4EH) with bit 7 set. The raw byte CEH = 4EH OR 80H. Bit 7 = 1 marks this as the last character of word "TERMINATION". The display routine strips bit 7 with AND 7FH to recover the printable character N before calling ROM 0033H.

Word 55H (85) — "COMMAND"

5045
DEFM 'COMMAN' 43 4F 4D 4D 41 4E
ASCII characters: 43H=C, 4FH=O, 4DH=M, 4DH=M, 41H=A, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
504B
DEFB C4H C4
Final character: byte C4H = ASCII D (44H) with bit 7 set. The raw byte C4H = 44H OR 80H. Bit 7 = 1 marks this as the last character of word "COMMAND". The display routine strips bit 7 with AND 7FH to recover the printable character D before calling ROM 0033H.

Word 56H (86) — "OPERATOR/PROGRAM/PARAMETER"

504C
DEFM 'OPERATOR/PROGRAM/PARAMETE' 4F 50 45 52 41 54 4F 52 2F 50 52 4F 47 52 41 4D 2F 50 41 52 41 4D 45 54 45
ASCII characters: 4FH=O, 50H=P, 45H=E, 52H=R, 41H=A, 54H=T, 4FH=O, 52H=R, 2FH=/, 50H=P, 52H=R, 4FH=O, 47H=G, 52H=R, 41H=A, 4DH=M, 2FH=/, 50H=P, 41H=A, 52H=R, 41H=A, 4DH=M, 45H=E, 54H=T, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5065
DEFB D2H D2
Final character: byte D2H = ASCII R (52H) with bit 7 set. The raw byte D2H = 52H OR 80H. Bit 7 = 1 marks this as the last character of word "OPERATOR/PROGRAM/PARAMETER". The display routine strips bit 7 with AND 7FH to recover the printable character R before calling ROM 0033H.

Word 57H (87) — "MISSING"

5066
DEFM 'MISSIN' 4D 49 53 53 49 4E
ASCII characters: 4DH=M, 49H=I, 53H=S, 53H=S, 49H=I, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
506C
DEFB C7H C7
Final character: byte C7H = ASCII G (47H) with bit 7 set. The raw byte C7H = 47H OR 80H. Bit 7 = 1 marks this as the last character of word "MISSING". The display routine strips bit 7 with AND 7FH to recover the printable character G before calling ROM 0033H.

Word 58H (88) — "COMPARE"

506D
DEFM 'COMPAR' 43 4F 4D 50 41 52
ASCII characters: 43H=C, 4FH=O, 4DH=M, 50H=P, 41H=A, 52H=R. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5073
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "COMPARE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 59H (89) — "MISMATCH"

5074
DEFM 'MISMATC' 4D 49 53 4D 41 54 43
ASCII characters: 4DH=M, 49H=I, 53H=S, 4DH=M, 41H=A, 54H=T, 43H=C. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
507B
DEFB C8H C8
Final character: byte C8H = ASCII H (48H) with bit 7 set. The raw byte C8H = 48H OR 80H. Bit 7 = 1 marks this as the last character of word "MISMATCH". The display routine strips bit 7 with AND 7FH to recover the printable character H before calling ROM 0033H.

Word 5AH (90) — "INSUFFICIENT"

507C
DEFM 'INSUFFICIEN' 49 4E 53 55 46 46 49 43 49 45 4E
ASCII characters: 49H=I, 4EH=N, 53H=S, 55H=U, 46H=F, 46H=F, 49H=I, 43H=C, 49H=I, 45H=E, 4EH=N. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5087
DEFB D4H D4
Final character: byte D4H = ASCII T (54H) with bit 7 set. The raw byte D4H = 54H OR 80H. Bit 7 = 1 marks this as the last character of word "INSUFFICIENT". The display routine strips bit 7 with AND 7FH to recover the printable character T before calling ROM 0033H.

Word 5BH (91) — "INCOMPATIBLE"

5088
DEFM 'INCOMPATIBL' 49 4E 43 4F 4D 50 41 54 49 42 4C
ASCII characters: 49H=I, 4EH=N, 43H=C, 4FH=O, 4DH=M, 50H=P, 41H=A, 54H=T, 49H=I, 42H=B, 4CH=L. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5093
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "INCOMPATIBLE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

Word 5CH (92) — "DRIVES"

5094
DEFM 'DRIVE' 44 52 49 56 45
ASCII characters: 44H=D, 52H=R, 49H=I, 56H=V, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
5099
DEFB D3H D3
Final character: byte D3H = ASCII S (53H) with bit 7 set. The raw byte D3H = 53H OR 80H. Bit 7 = 1 marks this as the last character of word "DRIVES". The display routine strips bit 7 with AND 7FH to recover the printable character S before calling ROM 0033H.

Word 5DH (93) — "DISKETTES"

509A
DEFM 'DISKETTE' 44 49 53 4B 45 54 54 45
ASCII characters: 44H=D, 49H=I, 53H=S, 4BH=K, 45H=E, 54H=T, 54H=T, 45H=E. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
50A2
DEFB D3H D3
Final character: byte D3H = ASCII S (53H) with bit 7 set. The raw byte D3H = 53H OR 80H. Bit 7 = 1 marks this as the last character of word "DISKETTES". The display routine strips bit 7 with AND 7FH to recover the printable character S before calling ROM 0033H.

Word 5EH (94) — "ATTRIBUTE"

50A3
DEFM 'ATTRIBUT' 41 54 54 52 49 42 55 54
ASCII characters: 41H=A, 54H=T, 54H=T, 52H=R, 49H=I, 42H=B, 55H=U, 54H=T. Each byte has bit 7 clear (= 0), indicating these are not the last character of the word.
50AB
DEFB C5H C5
Final character: byte C5H = ASCII E (45H) with bit 7 set. The raw byte C5H = 45H OR 80H. Bit 7 = 1 marks this as the last character of word "ATTRIBUTE". The display routine strips bit 7 with AND 7FH to recover the printable character E before calling ROM 0033H.

50ACH - Unused Space (NOP Padding)

This region from 50ACH through 51E7H consists entirely of 00H bytes (316 bytes of NOP padding). This is unused space within the SYS4 module, reserved for potential expansion of the error message tables or additional error codes. The SYS4 module occupies a fixed 1,256-byte (4E8H) allocation from 4D00H through 51E7H. Of this, the executable error handler code occupies 4D00H-4D81H (130 bytes), the error message index table occupies 4D84H-4E74H (241 bytes), the word component table occupies 4E74H-50ABH (568 bytes), and this unused padding fills the remaining 316 bytes.

50AC-51E7
DEFS 316,00H 00
316 bytes of 00H padding (NOP instructions if executed, but this area is never reached by program flow). This fills the remainder of the SYS4 module allocation to maintain fixed module boundaries within the NEWDOS/80 overlay structure.