TRS-80 DOS - NEWDOS/80 v2.0 for the Model I - DISASSEM/CMD Disassembled

DISASSEM/CMD

Other Navigation

Program Overview

APPARAT DISASSEMBLER 3.0 is a Z80 disassembler utility for the TRS-80 Model I running NEWDOS/80 v2.0. This program converts machine code (either from memory or disk files) into human-readable Z80 assembly language listings. It was developed by Apparat, Inc., the creators of NEWDOS/80.

Features

• Disassembles Z80 machine code from main memory or disk files
• Supports virtual address mapping (allows code to be disassembled as if loaded at a different address)
• Handles all Z80 instruction prefixes (CB, DD, ED, FD)
• Generates formatted output with addresses, hex bytes, mnemonics, and operands
• Supports printer output with form-feed prompts
• Identifies program entry points

Memory Layout

Address Range	Size	Description
55E4H - 5613H	48 bytes	Variables and work area
5614H - 681BH	4,616 bytes	Program code (entry point at 5614H)
681CH - 6927H	268 bytes	Z80 mnemonic lookup tables
6928H - 6B1BH	500 bytes	User prompts and message strings
6B1CH - 6E18H	765 bytes	Additional code and output routines
6E19H - 6E7BH	99 bytes	Uninitialized buffer area
6F60H - 6FA0H+	Variable	Stack and runtime buffers

Program Flow

1. Initialization (5614H): Set up stack, display title, initialize variables
2. Source Selection: Prompt user for memory or disk input
3. Address Configuration: Get virtual base, real base, byte count, and offset values
4. Disassembly Loop: Fetch bytes, decode opcodes, format output
5. Output Generation: Display/print formatted assembly listing

Technical Notes

The disassembler uses a sophisticated table-driven approach for opcode decoding. Z80 instructions are organized by their prefix bytes:

• Unprefixed: Main instruction set (00-FF)
• CB prefix: Bit manipulation instructions
• DD prefix: IX register operations
• ED prefix: Extended instructions
• FD prefix: IY register operations
• DDCB/FDCB: Indexed bit operations

DOS Interface

The program interfaces with NEWDOS/80 through several system calls:

• 4411H: HIGH$ memory pointer - used to determine available memory
• File I/O routines for loading object files from disk
• Console and printer output routines

Work Area (55E4H - 5613H)

The program maintains its state in a 48-byte work area at the beginning of the code. These variables are initialized to zero at load time and configured during program startup.

Address	Size	Name	Description
55E4H	1	SOURCE_TYPE	Source selection flag: 'M' for memory, 'D' for disk
55E5H-55E6H	2	VIRTUAL_ADDR	Current virtual address being disassembled
55E7H-55E8H	2	REAL_ADDR	Current real address in source data
55E9H-55EAH	2	WORK_ADDR	Working address pointer
55EBH-55ECH	2	END_ADDR	End address for disassembly range
55EDH-55EEH	2	RESERVED_1	Reserved/unused
55EFH	1	FLAGS	Operation flags and mode settings
55F0H	1	INIT_FLAG	Initialization status flag
55F1H	1	BIT_FLAGS	Bit flags for tracking processed addresses
55F2H-55F3H	2	HIGH_MEM	High memory limit (from DOS 4411H)
55F4H-55F5H	2	BUFFER_PTR	Current buffer pointer
55F6H-55F7H	2	IY_SAVE	IY register save area
55F8H	1	TEMP_BYTE	Temporary byte storage
55F9H-55FAH	2	TEMP_WORD_1	Temporary word storage
55FBH-55FCH	2	TEMP_WORD_2	Temporary word storage
55FDH-55FEH	2	RESERVED_2	Reserved/unused
55FFH-5600H	2	OFFSET_VAL	Address offset value
5601H	1	OUTPUT_FLAG	Output mode flag
5602H	1	STATUS_FLAG	Status/state flag
5603H	1	RESERVED_3	Reserved/unused
5604H	1	CONFIG_1	Configuration byte 1 (preset to 3CH)
5605H	1	CONFIG_2	Configuration byte 2
5606H-5608H	3	CONFIG_3	Configuration bytes (preset to 40H each)
5609H-560AH	2	WORK_PTR	Working pointer
560BH-560CH	2	BYTE_COUNT	Byte count for disassembly (FFFFH = until end)
560DH	1	OPCODE_LEN	Current opcode length counter
560EH	1	RESERVED_4	Reserved/unused
560FH	1	PREFIX_FLAG	Instruction prefix flag (CB/DD/ED/FD)
5610H	1	INDEX_REG	Index register indicator (IX/IY)
5611H	1	DISPLACEMENT	Index displacement byte
5612H	1	RESERVED_5	Reserved (contains 20H 80H as data)
5613H	1	OUTPUT_MODE	Output mode (80H = screen)

Self Modifying Code

• 5AAAH: Output buffer pointer (LD HL,nnnn)
• 599DH: Transfer address storage
• 5F2EH: Label buffer pointer
• 6187H: Stack pointer save for restart
• 618BH: Stack pointer save for state restoration

Variable Usage Patterns

Analysis of the code reveals the following variable access patterns:

• 55EFH (FLAGS): Most frequently accessed - read 12+ times, written 4 times. Controls program operation mode.
• 55E5H-55E7H (addresses): Heavily used for tracking disassembly position.
• 560BH (BYTE_COUNT): Initialized to FFFFH for "disassemble all" mode, or set to specific count.
• 560DH-5611H: Used during opcode decoding for prefix and index handling.

Subroutine Index

The following table lists the major subroutines identified in APPARAT DISASSEMBLER 3.0, organized by function.

Initialization and Main Flow

Address	Name	Description
5614H	ENTRY_POINT	Program entry - initializes stack, displays title, begins main flow
5748H	SETUP_OUTPUT	Configure output mode and parameters
5765H	INIT_CHECK	Check initialization status
579AH	MAIN_SETUP	Main setup routine, configure flags
57B7H	DISK_MODE	Handle disk file input mode

Input and Parsing

Address	Name	Description
5B08H	GET_RESPONSE	Get single character response from user (M/D selection)
5B22H	GET_HEX_ADDR	Prompt for and parse hexadecimal address input
5B29H	GET_HEX_OPT	Get optional hexadecimal value (allows empty input)
5B7DH	PARSE_FILESPEC	Parse file specification for disk input
58BAH	INPUT_HANDLER	General input handling routine (8 calls)

Disassembly Engine

Address	Name	Description
5CFAH	DISASM_MAIN	Main disassembly dispatch
5CFDH	DISASM_LOOP	Main disassembly loop
5CC5H	FETCH_BYTE	Fetch next byte from source (8 calls)
5EA9H	DECODE_OPCODE	Decode opcode and determine instruction type (8 calls)
5E63H	HANDLE_PREFIX	Handle instruction prefix bytes (CB/DD/ED/FD)
6592H	PROCESS_INSTR	Process decoded instruction (8 calls)

Output Formatting

Address	Name	Description
674EH	OUTPUT_LINE	Primary output routine - formats and displays line (19 calls)
673BH	OUTPUT_STRING	Output null-terminated string (10 calls)
67CEH	OUTPUT_CHAR	Output single character (10 calls)
6789H	OUTPUT_HEX	Output value in hexadecimal (6 calls)
66A0H	FORMAT_ADDR	Format address for display (5 calls)
66C1H	FORMAT_LINE	Format complete output line
67F5H	NEWLINE	Output newline/carriage return

String and Display

Address	Name	Description
5D17H	PRINT_STRING	Print string pointed to by DE (7 calls)
5D1AH	PRINT_STRING_CONT	String print continuation entry (6 calls)
5D2DH	CLEAR_SCREEN	Clear screen/initialize display
5D47H	PRINT_PROMPT	Print prompt and get input (5 calls)

Mnemonic Lookup

Address	Name	Description
655CH	LOOKUP_MNEMONIC	Look up instruction mnemonic from opcode (4 calls)
669BH	GET_REG_NAME	Get register name string (4 calls)
668BH	GET_OPERAND	Format operand for display (3 calls)

Utility Routines

Address	Name	Description
5AA8H	HEX_TO_BIN	Convert hex ASCII to binary (4 calls)
5ABEH	BIN_TO_HEX	Convert binary to hex ASCII (3 calls)
5A6EH	COMPARE_HL_DE	Compare HL and DE registers (3 calls)
5F02H	ADD_OFFSET	Add offset to address (3 calls)
5F4DH	CHECK_RANGE	Check if address in valid range (3 calls)
67CBH	OUTPUT_SPACE	Output space character (5 calls)

Error Handling

Address	Name	Description
5F47H	MEM_ERROR	Memory error handler (insufficient memory)
6A52H	BAD_REPLY_MSG	"BAD REPLY" error message location

Call Frequency Analysis

The most frequently called routines indicate the program's core functionality:

1. 674EH (19 calls): Primary output - called for every line of disassembly
2. 673BH, 67CEH (10 calls each): String and character output - fundamental display operations
3. 5CC5H, 5EA9H, 6592H, 58BAH (8 calls each): Core disassembly engine routines
4. 5D17H (7 calls): String printing for prompts and messages

Subroutine Map

The following diagram shows the approximate memory layout of major subroutines:

5614H ─────────────┬─── Entry Point & Initialization
                   │
5748H-57B6H ───────┼─── Setup routines
                   │
58BAH-5B07H ───────┼─── Input handling & parsing
                   │
5B08H-5C87H ───────┼─── User input routines
                   │
5CC5H-5CFDH ───────┼─── Disassembly engine core
                   │
5D17H-5E52H ───────┼─── String/display routines
                   │
5EA9H-5F92H ───────┼─── Opcode decoding
                   │
6065H-618AH ───────┼─── Extended processing
                   │
6592H-6639H ───────┼─── Instruction processing
                   │
66A0H-6788H ───────┼─── Output formatting
                   │
6789H-681BH ───────┼─── Output helpers
                   │
681CH-6927H ───────┼─── Mnemonic tables (DATA)
                   │
6928H-6B1BH ───────┴─── Message strings (DATA)

55E4H - Variable and Work Area

This region (55E4H-5613H) contains runtime variables and configuration bytes used throughout the disassembler. These locations are initialized to 00H at load time and populated during program execution. The variables track source mode (memory vs disk), virtual/real addresses, byte counts, output state, and various operational flags.

5614H - Program Entry Point and Initialization

This is the main entry point of APPARAT DISASSEMBLER 3.0. The initialization sequence sets up the stack, clears the screen, displays the program title, initializes all working variables, calculates buffer space from available memory, and prompts the user to select memory or disk mode for disassembly.

5677H - Memory Mode Initialization

This section handles initialization when the user selects memory mode ('M'). It sets up the mode flags, prompts for virtual and real base addresses, optionally prompts for byte count, and then proceeds to display the ORG directive and begin disassembly.

56B9H - Main Disassembly Loop Entry Point Check

This is the main loop that processes each instruction. It first checks for entry point markers to display, then fetches and disassembles the next instruction, handles output formatting, and checks for user keyboard input to pause, print, or exit. Control returns here after each instruction is processed.

56F8H - Byte Count Check and Instruction Fetch

This section checks if there are more bytes to disassemble (based on byte count limit), handles the differences between memory and disk modes, and calls the main disassembly routine to process the next instruction.

5748H - Page Setup and Line Counter Reset

This routine resets the line counter for a new page and optionally clears the screen. It is called at initialization and after each page break.

5755H - Keyboard Check and Command Processing

This routine checks for keyboard input during disassembly. It handles commands: X to exit, P to toggle printer, and any other key to pause/continue. Control then returns to the main loop.

5765H - Printer Page Break Handler

This routine handles page breaks when printer output is active. It checks if the printer is enabled and if so, waits for user input to continue, allowing paper alignment between pages.

576BH - Printer Control and Virtual Restart

This routine handles printer toggling and the virtual restart feature. When P is pressed, it prompts for printer commands. When V is pressed, it allows changing the virtual restart location to continue disassembly from a different address.

579AH - Output Header Display

This routine displays the ORG directive and optional column headers at the start of disassembly output. It checks mode flags to determine what header information to show.

57B7H - Disk Mode Initialization

This section handles initialization when the user selects disk mode ('D'). It prompts for the filespec, opens the file through NEWDOS/80 DOS calls, reads file header information to determine load addresses, and sets up for disk-based disassembly.

5801H - Disk Mode /CMD File Header Parsing

This section continues disk mode initialization by parsing the /CMD file header. TRS-80 /CMD files have a specific format with load blocks, each containing a type byte, length, load address, and data. This routine parses the header to determine where the code should be loaded and sets up the virtual addresses accordingly.

5843H - Calculate Next File Position

Calculates the next file position after the current block and updates the file position counter.

5852H - Block Data Read Loop

Main loop for reading data bytes from the /CMD file block. Reads bytes sequentially and stores them in the working buffer, checking for sector boundaries.

588EH - Read and Store Data Byte

Reads the next byte from the file and stores it in the working buffer, checking for end-of-block conditions.

58BAH - Get Next Byte From File

Reads the next sequential byte from the disk file. Handles sector boundaries by reading new sectors as needed. Returns byte in A register.

58D5H - Initialize Label Buffer

Initializes the label tracking buffer for a new code block. The label buffer tracks addresses that are referenced as jump/call targets so they can be marked with labels in the output.

590EH - Handle Non-Data Block Types

Handles /CMD file block types other than 01 (object code). Type 02 is the transfer address (entry point), other types are skipped. This is critical for properly parsing TRS-80 executable files.

591FH - Process Transfer Address (Entry Point)

Handles the type 02 transfer address block. This contains the program entry point - the address where execution begins when the program is run. The disassembler displays this and optionally records it for label generation.

5945H - Display Entry Point Message

Displays the "0000 = PROGRAM ENTRY POINT" message with the actual address filled in. Then branches based on output mode.

5963H - Generate EQU Statements for Labels

Scans the label buffer and outputs EQU statements for each recorded address. This creates symbolic labels for all jump/call targets found during disassembly.

5999H - Finalize Output and Write END Statement

Outputs the END statement with the transfer address and closes the output file.

59C9H - Printer Mode File Handling

Handles file output when in printer mode. Closes the input file and processes additional options.

5A0DH - Toggle Mode and Continue

Toggles mode flags and either continues with more processing or returns to disk file reading.

5A2FH - Output File Setup

Sets up an output file by prompting for a filename, copying it to the FCB area, and opening the file for writing.

5A49H - Get 16-Bit Address From File

Reads two bytes from the file and combines them into a 16-bit address in HL. Adds the user-specified offset to support relocated code.

5A5BH - Output Entry Point Line

Outputs a formatted line showing an entry point, including the ORG prefix, address columns, and a carriage return.

5A6EH - Output ORG Line Prefix

Outputs the ORG line number prefix. Increments a 5-digit BCD counter and outputs the formatted line number followed by the ORG template.

5A91H - Output 8 Characters With Tab

Outputs up to 8 characters from the buffer, skipping trailing spaces, followed by a tab character for column alignment.

5A9DH - Output Characters Until Space

Outputs characters from the buffer until a space is encountered or the count (B) is exhausted.

5AA8H - Output Buffer Character Storage

This routine stores a single character from Register A into the output buffer. The buffer pointer at 5AAAH is self-modifying code - the LD HL,0000H instruction has its address operand updated to point to the current buffer position. When the low byte of the pointer wraps to 00H (buffer page full), the buffer is flushed to disk by calling the sector write routine at 5AD0H.

5ABEH - Output Line with ORG Prefix

This routine outputs a complete source line to the buffer. It first stores a carriage return (0DH) at the current position, calls the ORG prefix output routine at 5A6EH, then copies characters from the line buffer pointed to by HL until a carriage return is encountered.

5AD0H - Write Sector to Output File

This routine writes a sector (256 bytes) to the output file using the DOS @WRITE function. The FCB at 5532H is used for the file operation. If a write error occurs, execution jumps to the error handler at 5CE6H.

5ADAH - Get Virtual Restart Location

Prompts the user for the "VIRTUAL RESTART LOCATION" using the message at 6A30H, then parses the hex input and stores the result in the work variable at 55E9H.

5AE4H - Prompt for Yes/No (Default Yes)

Displays the prompt at DE and waits for a Yes/No response. ENTER defaults to Yes. Returns with Z flag set and A=0 if No, NZ flag set and A=1 if Yes.

5AEBH - Prompt for Yes/No (Default No)

Displays the prompt at DE and waits for a Yes/No response. ENTER defaults to No. Returns with Z flag set and A=0 if No, NZ flag set and A=1 if Yes.

5AF2H - Prompt for Y/N Response

Displays the prompt at DE and waits for an explicit Y or N response. Returns with C=1 and NZ if Yes, C=0 and Z if No. Used for critical yes/no questions where a default is not appropriate.

5B08H - Prompt for M/D (Memory or Disk)

Displays the prompt at DE and waits for M (Memory) or D (Disk) response. Returns with C=1 and NZ if Memory, C=0 and Z if Disk. ENTER defaults to Memory.

5B22H - Get Hex Input with Prompt (No Default)

Displays the prompt at DE and waits for hex input. Does not accept ENTER alone as a valid response - some input is required.

5B29H - Get Hex Input with Prompt (Allow Default)

Displays the prompt at DE and parses a 16-bit hexadecimal value from user input. Returns the parsed value in HL. If ENTER is pressed alone, returns with HL=0000H and Z flag set.

5B52H - Get Decimal Input with Prompt

Displays the prompt string pointed to by DE and parses a 16-bit decimal value from user input. Returns the parsed value in HL. Does not accept ENTER alone - input is required. Uses a multiply-by-10 algorithm: HL = HL*4 + HL, then HL = HL*2 + digit.

5B7DH - Command Line Option Parser Entry

Entry point for the command line option parser. Prompts for options using the input buffer at 6C69H, then matches user input against the option lookup table at 5C8EH. When a match is found, the associated handler routine is called. Empty input (just ENTER) signals end of options and jumps to finalization at 5C1DH.

5BAAH - Execute Option Handler

Called when an option name matches in the lookup table. Extracts the 16-bit handler address from the table entry and executes it via JP (HL). The handler address follows the option name and flag byte in the table.

5BB3H - Set Printer Mode Flag Handler

Option handler that sets a bit in the printer state flag byte at 55F0H. The bit mask to set is passed in Register C (from the option table). Used for printer-related options like PTR.

5BB8H - Set Mode Flag Handler

Option handler that sets a bit in the mode flags word at 55EFH. The bit mask to set is passed in Register C. Used for most options like NCR, NIP, RTD, STD, RE, RI, etc.

5BC4H - Column Format Handler (FGN= Option)

Option handler for the FGN= (format/column) option. Processes a column identifier character and builds the output format template at 60E2H based on the column template at 60D7H. The template controls which columns appear in the disassembly output.

5BF6H - Parse Three-Letter Label Code

Parses a three-letter alphabetic code from user input and converts it to a unique numeric value using base-26 arithmetic. Used for custom label prefixes. The computed value is stored at 5FC1H. Each letter position is multiplied by 26 and added to create a unique index.

5C1DH - Option Processing Finalization

Called when option input is complete (user pressed ENTER on empty line). This routine resolves conflicting options by applying priority rules: output file mode disables memory mode, memory mode disables printer mode, entry labels enable certain features, etc. May prompt for additional parameters if extended options are enabled.

5C88H - Option Continuation Check

Verifies that the option name has been fully consumed and no extra characters remain. If B=0, returns normally. If B>0 but more input exists unexpectedly, jumps to "BAD REPLY" error.

5C8EH - Option Lookup Table (DATA)

This is a DATA table, not executable code. Each entry contains: option name (ASCII), terminator byte with bit 7 set containing the flag mask, and a 2-byte handler address. The table ends with a 00H byte. Options include: NCR (No CR), NIP (No Input Pause), RTD, STD, RE, RI, PTR (Printer), BFSP, FGN (Format Generator).

5CC5H - Display Prompt and Get Input Line

Main input routine that displays a null-terminated prompt string pointed to by DE, then reads a line of user input into the buffer at 5564H. Returns with: DE = pointer to input buffer (5564H), B = character count entered, HL = pointer past last character, Z flag set if input was empty (just ENTER). This is the core input routine called by all the prompt functions.

5CD2H - Get Key with Uppercase Conversion (Blocking)

Waits for a keypress using ROM routine 0049H (blocking wait), then converts lowercase letters a-z to uppercase A-Z. Returns the key in Register A. Preserves DE across the call.

5CE0H - Get Key with Uppercase Conversion (Non-Blocking)

Scans the keyboard using ROM routine 002BH (non-blocking scan), then converts any lowercase to uppercase. Returns Z flag set if no key pressed, otherwise key in Register A.

5CE6H - DOS Error Handler

Handles DOS errors by displaying the error message, then prompting user whether to restart or exit. Called when file operations fail. Uses DOS routine 4409H to display the system error message.

5CF7H - Display Error and Prompt Restart

Entry point for displaying a different error message (at 6B0CH) then prompting for restart/exit.

5D0CH - Display String with Extra Line Spacing

Displays a string followed by multiple carriage returns for line spacing. First ensures cursor is at start of a fresh line, then displays the string, then outputs 3 more CRs.

5D17H - Display Null-Terminated String with CR

Displays a null-terminated string pointed to by DE, then outputs a single carriage return. This is the standard string display routine used throughout the program.

5D24H - Display Null-Terminated String

Outputs characters from the string pointed to by DE until a null terminator (00H) is encountered. Does not add a trailing carriage return. Advances DE past the null terminator on return.

5D2DH - Clear Screen

Clears the screen by outputting the TRS-80 clear screen control code (1CH) followed by the home cursor code (1FH).

5D35H - Output Clear Screen Code

Outputs the TRS-80 clear screen control code (1CH).

5D3AH - Display B Characters from DE with CR

Outputs B characters from the buffer at DE, then outputs a carriage return.

5D3FH - Display B Characters from DE

Outputs exactly B characters from the buffer pointed to by DE. Does not check for null terminators.

5D47H - Output Single Character

The main character output routine. Outputs the character in Register A to the screen, with special handling for control characters and line width management. Tracks cursor position in the variable at 5605H. Handles CR, backspace, and screen width wrapping. This routine is called by all display functions.

5DA6H - Input Line Reader

This routine reads a line of input from the keyboard into the 64-byte input buffer at 5564H. It uses the ROM line input routine at 0040H, then converts all characters to uppercase and checks for the BREAK key. On entry, no specific registers are required. On exit: HL points to 5564H (the input buffer), the Z flag is set if the first character is a carriage return (empty line), and all characters in the buffer have been converted to uppercase.

5DC6H - Initialize Screen Mode (Narrow)

This routine initializes the display for narrow screen mode (32 columns). It sets A=00H to indicate narrow mode, then calls the common screen mode setup routine at 5DDAH. It also checks if output initialization has been done and performs first-time setup if needed. On exit: the screen mode variables at 5605H-5608H are configured for narrow display.

5DD8H - Initialize Screen Mode (Wide)

This routine is the entry point for wide screen mode initialization (64 columns). It loads A=18H to indicate wide mode and falls through to the common screen mode setup routine.

5DDAH - Screen Mode Setup (Common)

This is the common screen mode configuration routine called by both the narrow (5DC6H) and wide (5DD8H) entry points. On entry: A contains the mode value (00H=narrow, 18H=wide). The routine outputs a carriage return if needed, then configures the line width variables at 5605H-5608H based on the selected mode. The mode value is stored at 5E68H for later reference.

5DFEH - Enable Printer Output

This short routine enables printer output by setting bit 6 of the output state flags at 5602H. When bit 6 is set, all character output will be sent to the printer in addition to the screen. On exit: bit 6 of 5602H is set, enabling printer output.

5E07H - Fill Remaining Line with Carriage Returns

This routine fills the remaining space on the current output line by repeatedly outputting carriage returns until the line is complete. It is used for formatting output, ensuring proper line endings. The routine loops until the screen mode check at 5E10H indicates the line is full or wide mode is active. On entry: no specific registers required. On exit: the current line has been filled with carriage returns as needed.

5E10H - Check Line Position Status

This routine checks whether the current output line is complete or if wide mode is active. It is used by line-filling routines to determine when to stop outputting. On entry: no specific registers required. On exit: Z flag is set if wide mode (5E68H=18H) or if current line position (5603H) equals screen width (5604H); NZ otherwise. HL is preserved.

5E20H - Reset Line Position for New Output

This routine resets the line position counters for starting a new page or section of output. In narrow mode, it may output leading blank lines for formatting. It resets the line counter (5603H) and cursor column (5605H) to their initial values. On entry: no specific registers required. On exit: line position variables are reset for new output.

5E34H - Output Section Separator Lines

This routine outputs 3 blank lines as a section separator. It is called during first-time initialization (from 5DD1H) and for page formatting. On entry: no specific registers required. On exit: 3 blank lines have been output, BC is preserved.

5E48H - Output Multiple Carriage Returns

This routine outputs C carriage returns, checking line position between each one. It is used for multi-line spacing. On entry: C contains the number of carriage returns to output. On exit: C carriage returns have been output (or fewer if line position check returns Z), C is decremented to 0.

5E53H - Output B Blank Lines

This routine outputs B blank lines, where each blank line consists of a space character (20H) followed by a carriage return (0DH). It is used for page formatting and section separation. On entry: B contains the number of blank lines to output. On exit: B blank lines have been output, B is decremented to 0.

5E63H - Low-Level Character Output

This is the core low-level character output routine that sends characters to both the screen and printer (if enabled). It handles special characters (CR, LF, control codes) and manages column position for printer output. On entry: A contains the character to output. On exit: the character has been sent to screen and/or printer as appropriate, all registers preserved.

5E69H - Character Output Filter

This is a mid-routine entry point that filters characters before sending to the screen. Printable characters (20H and above), plus LF (0AH) and CR (0DH) are sent to the screen. Control characters below 20H (except 0AH and 0DH) are blocked from screen output. On entry: A contains the character to check and output. On exit: character has been sent to screen if printable, then printer check follows.

5E81H - Printer Output Handler

This section handles printer output, including special CR handling to manage column position. When outputting a CR, it checks if padding spaces are needed to reach the full line width. On entry: A contains the character to send to printer. On exit: character has been sent to printer via ROM routine at 0033H.

5E97H - Character Output Cleanup

This section restores all registers after character output operations and returns to the caller. It is the common exit point for the character output routine.

5E9CH - Initialize Input Buffer with Spaces

This routine fills the 64-byte input buffer at 5564H with space characters (20H), preparing it for new input. On entry: no specific registers required. On exit: HL points to 5564H (buffer start), the entire 64-byte buffer is filled with spaces.

5EA9H - Compare HL with DE (Signed)

This utility routine performs a comparison between the 16-bit values in HL and DE. It subtracts DE from HL and sets flags based on the result. On entry: HL and DE contain the 16-bit values to compare. On exit: Z flag is set if HL = DE, carry flag reflects the subtraction result. HL is modified (contains HL - DE), A contains the high byte of the result.

5EB2H - Add Entry to Label Buffer

This routine adds a new entry to the label buffer for automatic label generation during disassembly. It first checks if the program is in a mode that uses label buffers, then searches for the correct insertion point and creates the new entry. The label buffer stores jump/call target addresses for generating symbolic labels in the output. On entry: DE contains the address to add to the label buffer. On exit: entry added to buffer if not already present and memory available, all registers preserved.

5ED5H - Store Source Address in Label Entry

This section stores the current disassembly address (from 55EBH) and instruction type (from 55F8H) into the label buffer entry. This records where the jump/call instruction was found.

5EE5H - Update Existing Label Entry

This routine is called when a label address already exists in the buffer (Z flag set from 5F4DH search). It scans through existing reference entries to find an insertion point for a new reference, then adds a 3-byte reference entry (source address + instruction type). On entry: HL points to the start of an existing label entry, DE contains the current disassembly address (55EBH). On exit: new reference added to the entry chain, registers restored.

5F02H - Allocate Space in Label Buffer

This routine allocates space in the label buffer by shifting existing entries to make room for new data. It uses block memory moves to shift data and updates the buffer pointer at 55F4H. On entry: A contains the number of bytes to allocate, HL points to the insertion position, DE is on the stack. On exit: space is allocated, HL points to the insertion position, pointers updated. Jumps to error handler if insufficient memory.

5F30H - Update Label Buffer Pointers

This routine updates all label buffer pointers that were affected by the memory shift. It traverses the label buffer and adjusts pointer values by the allocation amount. The base pointer at 5F2EH is self-modified during execution. On entry: HL contains the buffer base (from self-modified instruction), BC contains the adjustment amount. On exit: all affected pointers have been updated.

5F47H - Out of Memory Error Handler

This routine handles the out-of-memory condition when the label buffer cannot allocate more space. It displays an error message and jumps to the error handler for program restart.

5F4DH - Label Buffer Search

This routine searches the label buffer for a specific address. The label buffer is organized as a sorted list of entries, each containing a target address and references to that address. The search uses a linked-list traversal through buffer pages. On entry: DE contains the address to search for. On exit: Z flag is set if address was found (HL points to the matching entry), NZ if not found (HL points to where it should be inserted), BC contains reference count information.

5F78H - Continue Within Page Search

This section continues searching within the current buffer page when more entries exist. It handles the inner loop that scans through entries within a single page.

5F8EH - Search Result Handler

This section handles the search result, determining whether to return a match (Z flag), continue searching (NZ flag and continue loop), or indicate not found (NZ flag and exit). On exit: Z flag set if exact match found, NZ if not found. HL points to the entry (if found) or insertion point (if not found). BC contains reference information.

5F93H - Reset Page Line Counter and Initialize Label Buffer

This routine resets the page line counter to 64 (40H) and initializes the label buffer structure. It calculates the number of valid entries in the buffer and sets up the page linking structure. The label buffer is organized as a series of 4-byte entries with page headers at xxA0H boundaries. On entry: none. On exit: page counter at 5612H reset to 40H, label buffer structure initialized with entry counts.

5FA0H - Count Valid Entries in Label Buffer

This routine counts the number of valid entries in the label buffer by scanning through the structure and checking flag bits. Valid entries have bit 6 set in their flags byte. On entry: HL points to buffer header, DE = 0 (entry count), B = 4 (shift counter). On exit: DE contains the count of valid entries, A contains a compressed count value.

5FAFH - Process Page Entry Count

This section processes the entry count for the current page by compressing DE into a smaller value through bit shifting. It performs 4 right shifts on DE, accumulating the carry bits into A.

5FC0H - Initialize Label Buffer Page Structure

This routine initializes the label buffer page structure by writing the page header (link pointer and flags) and then scanning through to count and process entries. It sets up each 4-byte slot with proper linking.

5FECH - Check Mode and Begin Output

This routine checks the current operating mode flags and begins the main disassembly output process. It determines whether to use memory mode or file mode, initializes the screen display, outputs the column header template, and compares the template with the current output format buffer. On entry: disassembly parameters have been configured in variables 55E4H-5613H. On exit: screen initialized and column headers displayed, IX points to label buffer at 6FA0H.

603EH - User Interaction Handler

This routine handles user interaction during label output, allowing the user to pause, continue, or exit. It compares the current output position with the input buffer start, displays output if needed, then waits for user keypress. Pressing 'X' exits, 'P' enters printer pause mode. On entry: DE preserved on stack contains current label address. On exit: DE restored, input buffer cleared with spaces.

6066H - Process Label Entry with End Check

This routine processes a label buffer entry, first calling the user interaction handler, then checking if the end of the label buffer has been reached. If at end, it displays "NO MORE LABELS" and exits. Otherwise, it continues to process the label entry. On entry: IX points to current position in label buffer at 6FA0H area. On exit: either exits program (if end of labels) or continues processing.

6078H - Skip Empty Columns in Label Entry

This routine scans through the label entry to skip columns that are marked as empty (space characters) in the output format buffer. It uses IY to index into the format buffer at 60E2H and advances IX through the label buffer entries. On entry: IX points to current label entry, bit 7 of (IX+0) is not set. On exit: IX advanced past empty columns, processing continues at 60ADH or 6098H.

6098H - Output Label Address and Check Buffer Position

This routine outputs the current label address using the hex conversion routine, then checks if the output buffer position has exceeded the available space. If so, it triggers user interaction. On entry: IX points to current label entry. On exit: HL advanced by 2, processing continues at 60ADH or loops back.

60ADH - Main Label Buffer Traversal Loop

This is the main loop that traverses through the label buffer, extracting target addresses and checking entry flags. It reads each label entry's address and determines whether to process it or continue to the next entry. On entry: IX points to current position in label buffer. On exit: loops through entries calling 6066H for valid entries, or continues scanning.

60D7H - Column Template Data Table

This is a DATA section containing an 11-byte column template buffer. The template contains single-character codes representing different output columns: S=Source, T=Target, U=Unknown, V=Virtual, W=Work, X=eXit, P=Print, L=Label, R=Reference. The disassembler uses this to format output into aligned columns.

60E2H - Output Format Buffer

This is a DATA section containing an 11-byte output format buffer, initialized to spaces. During operation, this buffer is updated to track which columns are active for the current disassembly pass. Each byte position corresponds to the same position in the column template at 60D7H.

60EDH - Entry Point Bitmap Marker

This byte appears to be part of the initialization sequence, storing the entry point bitmap flag value.

60EEH - Initialize Disassembly Engine

This routine initializes the main disassembly engine by setting up the entry point bitmap, clearing work buffers, outputting the virtual base address, and initializing various state variables. It prepares for the main disassembly loop. On entry: A may contain FFH from restart path (618AH). On exit: state variables initialized, stack pointer saved, ready to begin disassembly.

6122H - Save State and Begin Disassembly Pass

This routine saves the current stack pointer and initializes the address pointers for a disassembly pass. It copies the virtual and real base addresses to working variables and saves key state on the stack for potential restart. On entry: state variables at 55E5H-560FH configured. On exit: SP saved at 6187H, addresses copied to working locations, state saved on stack.

614CH - Check Processing State and Build ASCII Display

This routine checks if processing should continue after decoding an instruction, then builds the ASCII representation of the disassembled bytes for display. It reads bytes from the real address and converts them to printable characters (replacing control characters with dots). On entry: 61A2H has returned from decoding, 560FH contains processing state. On exit: ASCII display built at 55D3H, or jumps to restart path.

6172H - Check Entry Point Label and Finalize Output

This routine checks if entry point labels are enabled and formats the output line accordingly. If bit 7 is set in the entry point bitmap, it checks for trailing '8' characters and replaces them with spaces. On entry: ASCII display complete, 55F1H contains entry point bitmap. On exit: output line finalized, returns via self-modified SP at 6187H.

618AH - Restore State for Restart

This routine restores the saved state from the stack when a restart is required during disassembly. It pops the saved values (label buffer pointer, byte count, real address, virtual address) and restores them to their respective variables, then jumps back to 60EEH to reinitialize. On entry: 560FH was non-zero indicating restart needed. On exit: state restored, jumps to 60EEH with A=FFH.

61A2H - Main Opcode Decoder

This is the main opcode decoder entry point. It first checks for entry point label mode, then fetches the next opcode byte and routes it to the appropriate decoder based on its value range. Opcodes are divided into ranges: 00H-3FH (miscellaneous), 40H-7FH (LD r,r' and HALT), 80H-BFH (arithmetic/logic), and C0H-FFH (control/extended). On entry: HL points to output position in work buffer at 55C5H, 55F1H contains entry point bitmap. On exit: instruction decoded and output, processing continues or restarts.

61BDH - Decode LD r,r' Instructions (40H-7FH)

This section decodes the LD r,r' register-to-register load instructions (opcodes 40H-7FH), with special handling for HALT (76H). The source and destination registers are extracted from the opcode bits. On entry: A contains opcode in range 40H-7FH (excluding 76H which is handled separately). On exit: LD instruction decoded and output.

61D4H - Decode Arithmetic/Logic Instructions (80H-BFH)

This section decodes the arithmetic and logic instructions (ADD, ADC, SUB, SBC, AND, XOR, OR, CP) that operate on register A with another register. The operation type is determined by bits 3-5 of the opcode. On entry: A contains opcode in range 80H-BFH. On exit: arithmetic/logic instruction decoded and output.

61EAH - Decode Miscellaneous Opcodes (00H-3FH)

This section decodes the miscellaneous opcodes in the 00H-3FH range using bit testing to determine the specific instruction type. This range includes NOP, LD instructions, INC, DEC, JR, DJNZ, and various other instructions. The opcode bits are tested individually to route to the correct handler. On entry: A contains opcode in range 00H-3FH. On exit: instruction decoded via appropriate sub-handler.

6225H - Decode JR Instructions (20H-3FH with bit 5 set)

This section decodes the JR (Jump Relative) family of instructions: JR e (18H), JR NZ,e (20H), JR Z,e (28H), JR NC,e (30H), and JR C,e (38H). It outputs the mnemonic, then calls the displacement calculator routine used by DJNZ. On entry: A contains opcode with bit 5 set (in 20H-3FH range). On exit: JR instruction decoded with target address calculated.

6233H - Decode EX AF,AF' and Related (08H-18H with bit 3 set)

This section handles opcodes with bit 3 set in the low nibble, including EX AF,AF' (08H) and instructions that need the lookup table at 6C92H. On entry: A contains opcode with bit 3 set. On exit: instruction decoded and output.

6242H - Decode INC/DEC Register (04H, 0CH, etc.)

This section decodes INC r and DEC r instructions for 8-bit registers (opcodes with bit 2 set in the 00H-3FH range). On entry: A contains opcode with bit 2 set. On exit: INC or DEC instruction decoded with register operand.

624BH - Decode LD (BC/DE),A and Related (02H, 0AH, etc.)

This section decodes various instructions with bit 1 set, including LD (BC),A, LD (DE),A, LD A,(BC), LD A,(DE), and related memory access instructions. The specific instruction is determined by further bit testing. On entry: A contains opcode with bit 1 set. On exit: instruction decoded and output.

6263H - Continue LD (DE),A / LD A,(DE) Decoding

This section continues decoding for instructions involving the DE register pair with indirect addressing.

626DH - Entry Point Label Mode Handler

This routine handles the special entry point label generation mode. When the entry point bitmap (55F1H) is non-zero, this path is taken instead of normal disassembly. It outputs a special label format and adjusts the mnemonic pointer. On entry: 55F1H is non-zero. On exit: entry point label output, returns to normal disassembly mode.

6279H - LD r,n Immediate Load Decoder

Handles opcodes 06H, 0EH, 16H, 1EH, 26H, 2EH, 36H, 3EH (LD B/C/D/E/H/L/(HL)/A,n). Extracts the destination register from bits 3-5 of the opcode, outputs the mnemonic "LD", then the register name, followed by a comma and the immediate byte value in hex. The immediate value is fetched and formatted as a 2-digit hex operand.

6287H - LD (nn),A Direct Store Accumulator

Handles opcode 32H (LD (nn),A). Outputs the mnemonic "LD", followed by the 16-bit address in parentheses (fetched as next two bytes), then comma, then "A". This stores the accumulator to the specified memory address. The address is added to the label buffer for cross-referencing.

6296H - LD A,(nn) Direct Load Accumulator

Handles opcode 3AH (LD A,(nn)). Outputs the mnemonic "LD", then "A", followed by comma, then the 16-bit address in parentheses. This loads the accumulator from the specified memory address. The address is added to the label buffer for cross-referencing.

62A5H - LD (nn),HL Direct Store HL

Handles opcode 22H (LD (nn),HL). Outputs the mnemonic "LD", followed by the 16-bit address in parentheses, comma, then "HL". This stores the HL register pair to the specified memory address. The address is added to the label buffer.

62B7H - LD HL,(nn) Direct Load HL

Handles opcode 2AH (LD HL,(nn)). Outputs the mnemonic "LD", then "HL", followed by comma, then the 16-bit address in parentheses. This loads the HL register pair from the specified memory address. The address is added to the label buffer.

62C9H - LD SP,HL Load Stack Pointer

Handles opcode F9H (LD SP,HL). Outputs the mnemonic "LD", followed by "SP", comma, then "HL". This instruction copies the value in HL to the stack pointer register.

62DEH - LD rr,nn 16-bit Immediate Load

Handles opcodes 01H, 11H, 21H, 31H (LD BC/DE/HL/SP,nn). Extracts the destination register pair from bits 4-5 of the opcode, outputs "LD", the register pair name, comma, then the 16-bit immediate value. The register pair decoder at 6744H handles BC/DE/HL/SP decoding. The immediate word is fetched low byte first, then high byte, and formatted as a 4-digit hex address.

62F3H - Control Flow Opcode Decoder (C0H-FFH Range)

This section handles opcodes in the C0H-FFH range, which includes RET, POP, JP, CALL, PUSH, RST, and prefix bytes (CB, DD, ED, FD). Entry: A holds the opcode byte. Exit: Mnemonic and operands stored in output buffer, control returns to main decoder.

6386H - Build Label Reference in Output Buffer

This routine formats a label reference by outputting 'L' followed by the 4-digit hex address. Used when an instruction references a memory location that should be represented as a label rather than a raw address. Entry: DE holds the target address. Exit: Label formatted in output buffer.

6391H - Fetch Next Byte and Convert to Hex String

This routine fetches the next byte from the instruction stream and converts it to a 2-character hex string in the output buffer. Used for immediate 8-bit operands. Entry: Instruction pointer set up. Exit: A holds the fetched byte, 2-character hex representation in output buffer at HL.

639AH - Fetch 16-bit Address and Format as Label or Hex

This routine fetches a 16-bit address (low byte first, then high byte) from the instruction stream and formats it for output. If the address is in the valid range for labeling, formats as "Lxxxx". Otherwise formats as raw hex "xxxxH". Entry: Instruction pointer set up. Exit: DE holds the 16-bit address, formatted representation in output buffer.

63B4H - LD BC,nn Immediate Load Decoder

Handles opcode 01H - Load Register Pair BC with 16-bit immediate value. Fetches the next two bytes from the source code stream and outputs them as the immediate operand. Entry: Register A contains opcode 01H. Exit: Mnemonic "LD BC," output with 16-bit immediate value formatted as hex.

63BAH - Handle RET Conditional Instructions (C0H-C7H, C8H-CFH, D0H-D7H, D8H-DFH, E0H-E7H, E8H-EFH, F0H-F7H, F8H-FFH)

This section processes RET conditional instructions and RST restart instructions. Entry: Register A contains the current opcode (already stored at 560DH). The opcode has bit 0 set (indicating it's in the C1H-FFH range with odd first nibble). Exit: Instruction has been formatted and output, control returns to main disassembly loop.

63D6H - Handle RET PO or RET P (Opcodes E0H, F0H)

This section handles RET instructions with parity/sign condition codes. Entry: Register A contains opcode E0H (RET PO) or F0H (RET P). Exit: Instruction formatted and output.

63ECH - Handle RET Z, RET C, RET PE, RET M (Opcodes C8H, D8H, E8H, F8H)

This section processes RET instructions with the alternate set of condition codes (Z, C, PE, M). Entry: Register A contains the current opcode with bit 3 set. Exit: Instruction output complete.

6400H - Handle RET PE or RET M (Opcodes E8H, F8H)

This section handles RET instructions with parity even (PE) or minus (M) condition codes. Entry: Register A contains opcode E8H or F8H. Exit: Instruction formatted and output.

6414H - CB Prefix Handler - Bit Manipulation and Rotate/Shift Instructions

This section handles all CB-prefixed Z80 instructions (bit operations, rotates, shifts). Entry: A contains the CB-prefixed opcode byte. The routine decodes the opcode bits to determine the specific operation and operand register.

6476H - Rotate and Shift Instructions (CB 00H-3FH)

Handles CB-prefixed rotate and shift instructions: RLC, RRC, RL, RR, SLA, SRA, SLL (undocumented), SRL. Entry: Register E contains operation type (0-7), Register C contains target register code (0-7).

6487H - ED/DD/FD Prefix Handler - Load Mnemonic String Pointer

This code handles opcodes with the ED, DD, or FD prefix bytes (values A0H-BFH after subtracting A0H). The routine adjusts the opcode value and loads a pointer to the appropriate mnemonic string for output. Register A contains the adjusted opcode value (00H-1FH after adjustment), and Register DE is loaded with the address of the mnemonic string table at 68E6H.

648DH - CB Prefix Handler - Bit Operation Decoder

This section handles CB-prefixed opcodes (bit manipulation instructions). Entry point from 6475H when bit 7 of the opcode (stored in 560DH) is clear, indicating a CB prefix opcode in the range 40H-7FH. The code tests various bits to decode the specific operation and operands.

649DH - BIT Instruction Handler - Even Opcodes with Bits 1,0 Clear

Handles BIT instructions where bits 1 and 0 are both clear (opcodes 40H, 44H, 48H, 4CH, etc.). These are BIT n,r instructions where the destination register is decoded from bits 3-5 of the opcode.

64B0H - BIT Instruction Handler - Odd Opcodes with Bit 0 Set

Handles BIT instructions where bit 0 is set but bit 1 is clear (opcodes 41H, 45H, 49H, 4DH, etc.). These instructions output the bit number first, then a comma, then the register.

64C6H - BIT Instruction Handler - Bit 1 Set Path

Handles BIT instructions where bit 1 is set (opcodes with bit pattern xx1x in the low nibble). Tests bit 0 and bit 3 to determine the output format, then outputs either "IN" or "IM" mnemonic prefix.

64E0H - Invalid Opcode Handler - Restart Processing

This is an error handler for invalid or unrecognized opcode sequences. When the decoder encounters an opcode it cannot process, execution jumps here to restart the disassembly from a safe state.

64E3H - BIT Instruction with Bit 0 Set - OUT/OUTI/OUTD Handler

Handles BIT-prefixed instructions where bit 0 is set. Tests bit 3 to determine whether to output an OUT-family instruction with immediate operand or register operand.

64F5H - OUTI/OUTD Instruction Handler

Handles OUTI and OUTD instructions (opcodes with bit 3 set in the CB-prefix range). Outputs the operand first, then a comma, then the mnemonic.

6502H - RES/SET Instruction Handler - Register Table Lookup

Handles RES and SET instructions (CB-prefixed opcodes with bit 2 set). Uses a lookup table at 692AH to identify special register names (I, R, IXH, IXL, IYH, IYL) and outputs the appropriate mnemonic.

651AH - Standard Register Handler - Check for Special Opcodes

This section handles standard register codes that were not found in the special register table. It checks for specific opcode values (47H, 57H, 4FH, 5FH) that correspond to LD I,A / LD R,A / LD A,I / LD A,R instructions, then handles indexed register operations.

6559H - Finalize Instruction Output

This is the main instruction finalization routine called from many decoder paths. It performs final operand processing, handles ASCII display generation, checks for entry points, and returns control to the main disassembly loop. Entry: various opcode decoders. Exit: returns to main loop at 678DH.

6592H - Fetch Next Byte from Source (Memory or Disk)

This critical routine fetches the next byte from the source being disassembled, whether from memory or from disk. It decrements the byte counter at 560BH, manages the label buffer pointer at 55F6H when reading from disk, and returns the fetched byte in Register A. Entry: called when next instruction byte is needed. Exit: A contains the fetched byte, HL preserved via stack.

663AH - Process Operand with Optional Bit Flag

This routine processes an operand and optionally sets bit 0 based on bit 4 of the current opcode. It checks the opcode at 560DH and conditionally ORs the input value in Register A with 01H if bit 4 is set. Entry: A contains operand type code. Exit: calls 6789H and 664FH, then jumps to 678DH.

664FH - Fetch 16-bit Address and Add to Label Buffer

This routine fetches two bytes from the source to form a 16-bit address, stores the fetch count in 55F8H, and adds the address to the label buffer. Entry: A contains fetch count. Exit: DE contains the 16-bit address, label added to buffer.

665CH - Output Comma Separator

This simple routine stores a value to 55F8H and then processes a 16-bit address for output. It's used to output a comma separator between instruction operands. Entry: called when comma separator needed. Exit: processes address and adds to label buffer.

6672H - Process Operand and Output with 8-bit Immediate

This routine processes an operand by calling 6789H, then fetches and outputs an 8-bit immediate value. Entry: called for instructions with 8-bit immediate operands. Exit: outputs operand and immediate value.

667BH - Fetch 8-bit Immediate and Output

This routine fetches an 8-bit immediate value from the source, stores it in 55F8H, forms a 16-bit value with the high byte as 00H, adds it to the label buffer, and outputs it. Entry: called for 8-bit immediate operands. Exit: E contains the immediate value.

6693H - Complete Hex Output with 'H' Suffix

This routine completes hex value output by calling the buffer management routine and then jumping to output the 'H' suffix. Entry: previous hex processing complete. Exit: jumps to 6799H to add 'H' suffix.

6696H - Convert 16-bit Value to Hex Digits

This routine converts a 16-bit value in Register DE to hexadecimal ASCII digits and stores them in the output buffer. It processes both high byte (D) and low byte (E). Entry: DE contains the 16-bit value to convert. Exit: buffer contains hex ASCII digits.

669BH - Convert Address to Hex and Output

This routine converts a 16-bit address in Register DE to hexadecimal ASCII and outputs it. It first converts the high byte (D), then the low byte (E). Entry: DE contains the address to output. Exit: address output as hex ASCII.

66A0H - Convert Byte to Hex ASCII Digits

This is the core hex conversion routine. It converts a single byte in Register A to two hexadecimal ASCII characters and stores them in the buffer at HL. Entry: A contains byte to convert, HL points to output buffer. Exit: HL advanced by 2, BC preserved via stack.

66B6H - Generate Label for Address

This routine checks the mode flags at 55EFH and generates a label for the address in Register DE if label generation is enabled. It searches the label buffer and returns either a generated label or continues with hex output. Entry: DE contains address. Exit: may generate label or return for hex output.

66D0H - Generate Label String from Buffer Entry

This routine generates the actual label string (like "L0001", "L0002", etc.) from a label buffer entry. It uses the entry position to calculate the label number and outputs the label characters. Entry: BC points to label buffer entry, DE on stack. Exit: HL points to output buffer with label string.

66FBH - Label Divisor Table (DATA)

This data table contains 16-bit divisor values used to convert label buffer entry positions into decimal label numbers. The values are in descending order (10000, 1000, etc.) followed by an FFH end marker.

66FFH - Decode Condition Code from Opcode

This routine decodes the condition code (NZ, Z, NC, C, PO, PE, P, M) from bits of the current opcode and outputs the appropriate string. Entry: A contains opcode or bit pattern. Exit: condition code string output to buffer.

6710H - Decode P/M/PE/PO Condition Codes

This section handles condition codes when bit 5 of the opcode is set, covering P (Plus), M (Minus), PE (Parity Even), and PO (Parity Odd). Entry: A contains opcode with bit 5 set. Exit: appropriate condition code output.

671FH - Decode P/M Sign Conditions

This section handles the P (Plus/Positive) and M (Minus/Negative) sign-based condition codes. Entry: A contains opcode with bits 5 and 4 both set. Exit: 'P' or 'M' output.

6727H - Get Low 2 Bits of Opcode

This utility routine extracts bits 0-1 from the current opcode stored at 560DH. Entry: none. Exit: A contains bits 0-1 of opcode (value 0-3).

6730H - Get Low Nibble After Right Rotate

This routine rotates Register A right by 4 bits and then masks to get the low nibble. Entry: A contains value to rotate. Exit: A contains low 4 bits after rotation.

6735H - Get Low Nibble of Opcode

This routine loads the opcode and extracts its low 4 bits (nibble). Entry: none. Exit: A contains bits 0-3 of opcode (value 0-15).

673BH - Decode Destination Register (Bits 3-5)

This routine extracts bits 3-5 from the current opcode to decode the destination register in LD and arithmetic instructions. Entry: none. Exit: A contains register code 0-7.

6743H - Decode Source Register (Bits 0-2)

This routine extracts bits 0-2 from the current opcode to decode the source register in LD and arithmetic instructions. Entry: none. Exit: A contains register code 0-7.

6749H - Rotate Right 4 Bits

This utility routine rotates Register A right by 4 bit positions, effectively swapping the high and low nibbles. Entry: A contains value to rotate. Exit: A rotated right by 4 bits.

674EH - Output Source Register Name

This routine outputs the source register name by calling the register decoder and outputting a comma separator. Entry: none. Exit: comma stored in buffer at (HL), HL incremented.

6752H - Output "A," Prefix

This routine outputs the accumulator register name "A" followed by a comma, used for ADD A,r and similar instructions. Entry: HL points to output buffer. Exit: "A," stored in buffer.

6757H - Output Bit Number and Finalize

This routine processes bit number output for BIT/RES/SET instructions, then calls helper routines to complete the instruction. Entry: opcode contains bit number. Exit: instruction finalized.

6760H - Output Comma and Register A

This routine outputs a comma separator followed by the 'A' register name. Entry: HL points to output buffer. Exit: ",A" stored in buffer.

6765H - Output 'Z' Character

Outputs the letter 'Z' to the buffer, used for Z/NZ condition codes and Z80 register names. Entry: HL points to output buffer. Exit: 'Z' stored.

6769H - Output 'C' Character

Outputs the letter 'C' to the buffer, used for C/NC condition codes and C register name. Entry: HL points to output buffer. Exit: 'C' stored.

676DH - Output 'N' Character

Outputs the letter 'N' to the buffer, used as a prefix for negated conditions (NZ, NC). Entry: HL points to output buffer. Exit: 'N' stored.

6771H - Output 'M' Character

Outputs the letter 'M' to the buffer, used for M (Minus/Negative) condition code and M register references. Entry: HL points to output buffer. Exit: 'M' stored.

6775H - Output 'P' Character

Outputs the letter 'P' to the buffer, used for P (Plus/Positive) condition code and as a prefix for PE/PO parity conditions. Entry: HL points to output buffer. Exit: 'P' stored.

6779H - Output 'E' Character

Outputs the letter 'E' to the buffer, used for the E register name and as a suffix for PE (Parity Even) condition. Entry: HL points to output buffer. Exit: 'E' stored.

677DH - Output 'O' Character

Outputs the letter 'O' to the buffer, used as a suffix for PO (Parity Odd) condition. Entry: HL points to output buffer. Exit: 'O' stored.

6781H - Output Minus Sign

Outputs a minus sign '-' to the buffer, used for negative displacements in indexed addressing. Entry: HL points to output buffer. Exit: '-' stored.

6785H - Output Plus Sign

Outputs a plus sign '+' to the buffer, used for positive displacements in indexed addressing. Entry: HL points to output buffer. Exit: '+' stored.

6789H - Output Opening Parenthesis

Outputs an opening parenthesis '(' to the buffer, used for indirect addressing modes like (HL), (IX+d), etc. Entry: HL points to output buffer. Exit: '(' stored.

678DH - Output Closing Parenthesis

Outputs a closing parenthesis ')' to the buffer, completing indirect addressing notation. Entry: HL points to output buffer. Exit: ')' stored.

6791H - Output 'A' Character

Outputs the letter 'A' to the buffer, used for the accumulator register name. Entry: HL points to output buffer. Exit: 'A' stored.

6794H - Return After Outputting 'A'

Completes the output of 'A' character by returning from the subroutine. Entry: HL incremented by 6791H. Exit: returns to caller.

6795H - Output '0' Character

Outputs the digit '0' to the buffer, used for high-value addresses or special formatting. Entry: HL points to output buffer. Exit: '0' stored.

6799H - Output 'H' Suffix

Outputs the 'H' suffix character used to denote hexadecimal numbers in assembly language. Entry: HL points to output buffer. Exit: 'H' stored.

679DH - Output Character from Register B

Outputs a single character from Register B to the buffer at HL. This is used for variable character output. Entry: B contains ASCII character, HL points to buffer. Exit: character stored.

67A0H - Output Destination Register from Opcode

Decodes the destination register from bits 3-5 of the opcode and outputs it to the buffer using a table lookup. Entry: HL points to output buffer. Exit: register name output.

67B2H - Load Mnemonic String Pointer for Register Pair

Loads the address of a mnemonic string for register pair operations. Entry: none. Exit: DE contains string address, jumps to output routine.

67B7H - Load Mnemonic String for Final Output

Loads the address of another mnemonic string for instruction finalization. Entry: none. Exit: DE contains string address.

67BCH - Load String at 687EH

Loads the address of a string at 687EH for output. Entry: none. Exit: DE contains string address.

67C1H - Load String at 6876H

Loads the address of a string at 6876H for output. Entry: none. Exit: DE contains string address.

67C6H - Load String at 687AH

Loads the address of a string at 687AH for output. Entry: none. Exit: DE contains string address.

67CBH - Load Default Mnemonic String

Loads the address of the default mnemonic string at 6852H and prepares for output. Entry: none. Exit: DE contains string address, jumps to output.

67D1H - Output Register Name from Table

Outputs a register name from the standard register table at 681CH. Entry: A contains register code. Exit: register name output to buffer.

67D9H - Output Register Pair Indirect (BC or DE)

Outputs indirect addressing notation for BC or DE register pairs, e.g., (BC) or (DE). Entry: opcode bit 4 determines which pair. Exit: indirect notation output.

67E8H - Output Register Pair at Index 1

Outputs a register pair name using table index 1. Entry: HL points to buffer. Exit: register pair name output.

67ECH - Output Register Pair at Index 2

Outputs a register pair name using table index 2. Entry: HL points to buffer. Exit: register pair name output.

67F0H - Get Register Pair Code from Low 2 Bits

Extracts bits 0-1 from the opcode to determine register pair and outputs it. Entry: none. Exit: register pair name output.

67F5H - Get Register Pair and Check for AF

Gets the register pair code from bits 0-1 of the opcode and checks if it equals 02H (AF pair). If so, clears processing state. Entry: none. Exit: A contains pair code.

6803H - Output Register Pair Name from Table

Outputs a register pair name (BC, DE, HL, SP, AF, IX, IY) using table lookup. Entry: A contains pair code (0-3 or higher). Exit: pair name output to buffer.

680BH - Shift Index Left Once Before Lookup

Shifts the table index in Register C left by one bit before the main shift, used for 4-byte table entries. Entry: C contains index. Exit: C shifted left 1 bit.

680DH - Table Lookup and Copy to Output Buffer

This is the main table lookup routine. It calculates the offset into the table using the shifted index, copies the entry bytes to the output buffer, and returns. Entry: A=entry size, C=index, DE=table base, HL=output buffer. Exit: entry copied to buffer.

681CH - DATA: Standard Register Name Table

This data table contains single-character register names for the Z80's 8-bit registers in standard opcode bit order: B, C, D, E, H, L, (HL indicator), A. Each entry is 1 byte. The table is indexed 0-7 corresponding to the 3-bit register encoding in Z80 opcodes.

6824H - DATA: Register Pair Name Table

This data table contains 2-character register pair names for the Z80's 16-bit register pairs. Each entry is 2 bytes (2 ASCII characters). Indexed 0-3+ for: BC, DE, HL, SP, AF, IX, IY.

682AH - DATA: Register Pair Name Table (Continued)

Continuation of the register pair name table. This section contains additional 2-character register pair names: SP (Stack Pointer), IX (Index Register X), IY (Index Register Y), AF (Accumulator/Flags). Each entry is 2 bytes.

6832H - DATA: Extended Register Name Table (4 bytes per entry)

This table contains 4-character register name strings used for special addressing modes and extended instruction formats. Each entry is 4 bytes and includes padding spaces where needed. Used by the table lookup routine at 680BH with entry size of 04H.

6852H - DATA: Main Z80 Mnemonic Table

This is the primary mnemonic lookup table containing strings for all Z80 instruction mnemonics. Each entry is 4 bytes padded with spaces. This table is referenced by opcode decoders throughout the disassembler to output the correct instruction mnemonic. The table is indexed by instruction type and used by the output routine at 67CEH.

68E6H - DATA: ED/DD/FD Prefix Mnemonics

Extended mnemonic table for ED, DD, and FD prefix instructions (block operations, extended I/O, and special operations). These 4-byte entries are used when processing opcodes with prefix bytes A0H-BFH (after subtracting A0H). Referenced by routine at 6487H.

692AH - DATA: Special Register Code Lookup Table

This 5-byte table is used by the RES/SET instruction handler at 6502H to identify special register codes for I, R, IXH, IXL, IYH, IYL registers. The table is searched backwards.

695BH - DATA: Assembler Directive and Format Strings

This section contains assembler directive strings and output formatting templates used when generating the disassembly output. These include pseudo-ops like EQU, ORG, END, and formatting strings with special characters (09H = TAB, 0DH = CR).

698FH - DATA: User Prompt Strings Section

This section (698FH-6D1FH) contains all the user-facing prompt strings, error messages, help text, and interactive prompts used by the disassembler. The section includes strings for the main menu, option descriptions, error messages, and command syntax help. This section has been documented separately by the user and is not included in this part.

6D20H - DATA: Additional User Prompt Strings

This section contains error messages and user prompts displayed when configuring output options for the disassembler. These strings are displayed during interactive setup to guide the user through pagination and margin settings.

6DE0H - Initialize Label Buffer Pointer

This short routine initializes the label buffer by setting up the IX register to point to the label buffer start. Entry: DE contains a value. Exit: IX points to 6FA0H (label buffer header), HL loaded with 6FA0H.

6DE7H - DATA: Padding/Unused Space

This section contains padding bytes (00H/NOP) between the end of executable code and the start of the uninitialized buffer area. This space may have been reserved for future expansion or to align the buffer on a specific boundary.

6E00H - Uninitialized Buffer Area

This large section (6E00H-6E7BH, 124 bytes) represents uninitialized buffer space that will be used at runtime for temporary storage, label buffer overflow, or dynamic data structures. The area is filled with 00H bytes in the /CMD file but will be overwritten during program execution. This marks the end of the APPARAT DISASSEMBLER 3.0 program image.