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

SYS21/SYS

Other Navigation

SYS21 implements the CMD"O" array sort command for NEWDOS/80 v2.0 Disk BASIC on the TRS-80 Model III. This overlay provides a general-purpose in-memory sort that operates directly on BASIC array data, supporting both direct sorting (where array elements are physically rearranged) and indirect sorting (where only an integer index array is rearranged, leaving the source arrays untouched).

The sort supports up to 9 arrays as sort keys, with each key independently configurable for ascending or descending order. String arrays support optional substring field specification (x,y) to compare only a portion of each element. Numeric arrays support integer (2-byte sign-magnitude), single-precision (4-byte), and double-precision (8-byte) comparisons. The algorithm is a bubble sort variant that makes repeated passes through the data, comparing adjacent elements and swapping when out of order, until no more swaps are needed.

The overlay is loaded at 4D00H and entered via SVC 57H (RST 28H with function code 57H). On entry, Register A contains the SVC function code and Register B holds the caller's context byte. The first two instructions (INC SP / INC SP) discard the return address pushed by the RST 28H dispatcher, since SYS21 exits through the DOS error exit or by returning to BASIC directly.

Program Structure

The overlay is organized into the following functional sections:

Command Parser and Variable Table Builder

4D00H–4DB9H: Validates the SVC function code, parses the CMD"O" argument list, extracts array variable descriptors (type, address, element count, substring parameters), and builds the 9-entry array descriptor table at 4300H–43D0H. Handles both direct and indirect sort mode detection via the * prefix on the first array argument.

Array Descriptor Table Initialization

4DBAH–4DE1H: Clears the SVC result byte at 4288H and the BASIC/CMD communication byte at 576EH, then initializes all 9 array descriptor table entries at 4300H with sequential element counters and default values.

Sort Element Count and Array Validation

4DE2H–4ED4H: Parses the element count parameter n, evaluates each array variable expression, locates the array in the BASIC variable table, computes element addresses and REN offsets, validates that all arrays have sufficient elements, and stores substring field parameters for string arrays.

Indirect Sort Index Initialization

4ED5H–4F00H: For indirect sorts (Format 2), validates that the indirect array is an integer type, then fills it with sequential REN values (0, 1, 2, ..., n-1) corresponding to the elements in the sort arrays.

Sort Workspace Setup and Main Sort Loop

4F01H–5077H: Allocates workspace memory via the division routine at 5D56H, relocates the comparison and swap routines to the workspace area, and executes the bubble sort outer/inner loops. Each pass compares adjacent elements across all sort key levels, swapping when out of order. The outer loop repeats until a complete pass produces no swaps.

Comparison Engine

4F7CH–5039H: Dispatches to the appropriate comparison routine based on variable type: integer (sign-magnitude XOR 80H for unsigned comparison), string (with optional substring field extraction and length-aware byte-by-byte comparison), or floating-point (byte-by-byte from most significant to least significant).

Swap Dispatch and Element Swap Routines

503BH–51D4H: When a comparison determines elements are out of order, the swap routines exchange the elements in all participating arrays. For direct sorts, the actual array data is moved. For indirect sorts, only the integer index values are exchanged.

Utility Subroutines

50D7H–50EEH: Helper routines for element address calculation, block copy with boundary checking, and the array-walking dispatch loop that applies an operation to all active array descriptors.

NOP Padding

51E2H–51E7H: Unused area filled with 00H bytes to pad the overlay to its full allocated size.

Array Descriptor Table (4300H–43D0H)

The sort uses a 9-entry descriptor table at 4300H, with each entry occupying 17H (23) bytes. The table is indexed via the IX register, which is advanced by 17H to step from one entry to the next. Only entries with a non-zero type byte at IX+01H are active.

Offset	Size	Name	Description
IX+00H	1	Entry Counter	Sequential entry number (1–9) assigned during initialization. Also used as the array slot identifier during parsing. Entry 1 is the first (or indirect) array; entry 2+ are sort key arrays.
IX+01H	1	Variable Type	BASIC variable type code from ROM (40AFH): 02H=integer, 03H=string, 04H=single-precision, 08H=double-precision. Zero means the entry is unused/inactive.
IX+02H	1	Substring Start	For string arrays: the 1-based starting character position for substring comparison (the x in (x,y)). Zero means compare from the beginning.
IX+03H	1	Substring Length	For string arrays: the number of characters to compare (the y in (x,y)). Zero means compare all characters. FFH is the initialization sentinel.
IX+04H	1	Sort Direction	Bit 7: set = descending sort order, clear = ascending sort order. Set by the - prefix on the array variable name via the 65B4H routine.
IX+05H- IX+06H	2	Array Base Address	Starting address of the first participating element within the BASIC array data area. Computed from the array's location in the variable table plus the starting REN offset.
IX+07H- IX+08H	2	Array Element Address	Address of the array descriptor entry in the BASIC variable table. Used to compute element sizes and total element counts.
IX+09H- IX+0AH	2	Current Element 1 Pointer	Working pointer to the first element of the current comparison pair during the sort. Updated during each sort pass.
IX+0BH- IX+0CH	2	Swap Source Address	Used during element swaps to track the source block address.
IX+0DH- IX+0EH	2	Element Size	Size of each array element in bytes. For integer=2, string=3 (descriptor), single=4, double=8. Retrieved from the BASIC array header.
IX+0FH- IX+10H	2	Element Offset	Byte offset of the starting element within the array data, relative to the array base. Used to compute absolute element addresses.
IX+11H- IX+12H	2	Current Element 2 Pointer	Working pointer to the second element of the current comparison pair during the sort.
IX+13H- IX+14H	2	Swap Temp Pointer	Address used during element swap operations for temporary storage or the destination of a block move.
IX+15H- IX+16H	2	Swap Destination Address	Destination address for element data during swap operations.

Address	Description
4288H	External Write SVC result byte. Cleared to 00H at 4DBBH.
4300H	Table Array descriptor table base (9 entries × 23 bytes = 207 bytes, 4300H–43CEH, plus 2 sentinel bytes).
4D8DH	Self-Modifying Operand of JR NZ at 4D8DH. Written at 4D0FH with Register B (caller context). Controls the variable table compaction branch.
4F27H	Variable Element count n (the number of elements participating in the sort). Written at 4DEBH, 4EA4H.
4F39H	Self-Modifying Operand of LD HL at 4F38H. Holds the current pass swap counter. Written at 4F23H.
4F40H	Self-Modifying Operand of LD DE at 4F3FH. Holds the second pass swap counter. Written at 4F29H.
5088H	Variable Workspace base address. Written at 4F09H.
5102H	Variable Indirect sort flag. 00H=direct sort, 01H=indirect sort. Written at 4E04H.
5124H	Self-Modifying Second-direction pass counter. Written at 4F3BH, 506AH.
5145H	Self-Modifying First-direction pass counter. Written at 4F53H, 5047H.
507EH	Self-Modifying Partition boundary for pivot tracking. Written at 4F19H, 5081H, 508AH.
50FFH	Self-Modifying Operand of CALL at 50FEH. Written at 50EEH. Holds the address of the per-array operation routine (comparison, swap, or address setup).
576EH	External Write BASIC/CMD SVC result byte. Cleared to 00H at 4DBEH.
6427H	External Write Reset vector. Written at 4D15H with 4D67H (the variable table compaction entry point).

Entry points, subroutines, and dispatch targets within SYS21/SYS.

Address	Description
4D00H	SVC Entry Point Entry from SVC 57H dispatcher. Validates function code 37H (CMD"O") or 57H (CMD"O" with indirect), discards return address, parses argument list.
4D67H	Variable Table Compaction Reset vector target. Walks the BASIC variable table (40F9H–40FBH) and string descriptor stack (40FDH), compacting entries by removing gaps left by array data movement.
4DBAH	CMD"O" Main Entry Initializes SVC result bytes, builds the 9-entry array descriptor table at 4300H, then parses the element count and array arguments.
4DEFH	Array Argument Loop Parses each comma-separated array variable in the CMD"O" argument list, evaluates the expression, locates the array, fills the descriptor table entry, and advances IX to the next entry.
4F01H	Sort Setup Allocates workspace, relocates sort routines, initializes pass counters.
4F32H	Sort Outer Loop Begins each pass of the bubble sort. Resets swap counters and enters the inner comparison loop.
4F63H	Sort Inner Loop Walks IX through all active array descriptors, comparing element pairs and dispatching to swap routines when elements are out of order.
4F7CH	Comparison Dispatcher Reads the variable type from IX+01H and dispatches to integer, string, or floating-point comparison.
50D7H	Element Address Helper Computes element addresses with boundary checking.
50EEH	Array Walker Dispatch Iterates through all active descriptors in the table, calling the routine whose address is stored at 50FFH for each one.
510CH	Element Address Setup Stores element pointer values into IX+11H/12H and IX+13H/14H for a given descriptor entry, then jumps to 65FFH for additional computation.
511DH	REN-to-Address Converter Converts a Relative Element Number to an absolute memory address using the element size from IX+0FH/10H and the base address from IX+05H/06H.
5153H	Forward Swap Swaps element data in the forward (ascending) direction for all active arrays.
5174H	Reverse Swap Swaps element data in the reverse (descending) direction for all active arrays.
5184H	Indirect Index Update For indirect sorts, updates the integer index array entries to reflect the swap.
51D5H	Pass Advance Advances element pointers (IX+07H/08H) to the next pair for the next comparison iteration.

Cross-References to External Routines

Address	Source	Description
1997H	ROM	BASIC syntax error handler (?SN ERROR)
1E46H	ROM	BASIC numeric expression evaluator (integer result in DE)
1E4AH	ROM	"Illegal Function Call" error handler
260DH	ROM	BASIC string expression evaluator
2B1CH	ROM	Numeric expression evaluator (byte result in A)
5BB4H	BASIC/CMD	Variable type parser (returns type code)
5BB6H	BASIC/CMD	Variable type parser (alternate entry)
5BFAH	BASIC/CMD	Line type check (classifies current BASIC text position)
5C0DH	BASIC/CMD	Line entry length calculator
5C18H	BASIC/CMD	Line link follower (advance to next variable table entry)
5C21H	BASIC/CMD	Parenthesis counter
5D56H	BASIC/CMD	16-bit division (HL = HL / DE, remainder in DE)
5D78H	BASIC/CMD	Line+Variable evaluator
5DEFH	BASIC/CMD	Error translator (DOS error code in A)
65B4H	BASIC/CMD	Set bit 7 of IX+04H (mark descending sort)
65B9H	BASIC/CMD	PDRIVE comparator (validate array base addresses)
65EBH	BASIC/CMD	Conditional store to 4F02H
65F4H	BASIC/CMD	Conditional return + position check
65FFH	BASIC/CMD	Conditional add loop
6497H	BASIC/CMD	Set reset vector
6608H	BASIC/CMD	FCB header + block copy

4D00H – SVC Entry Point and Function Code Validation

Entry point from the SVC 57H dispatcher. The first two instructions discard the return address that the RST 28H SVC mechanism pushed onto the stack, since SYS21 exits through BASIC's error handlers or the DOS exit rather than returning to the SVC dispatcher. Register A holds the SVC function code and Register B holds the caller's context byte passed through the SVC dispatch chain.

4D19H – CMD"O" Argument Pre-Scanner

Before the main argument parsing begins, this section pre-scans the CMD"O" argument list to process any variable names and line references that precede the array variables. HL points to the current position in the BASIC program text. The pre-scanner handles the CMD"O",n,... portion where n is the element count and the comma-separated list may contain line references (via 5D78H) and NEXT tokens (93H).

4D2BH – Array Variable Locator

This section locates an array variable in the BASIC variable table. It calls the variable type parser at 5BB6H to identify the variable, then searches through the BASIC variable table (from 40FBH, the array end / variable top) and the string descriptor stack (from 40FDH) to find the matching array entry. The search walks backward through the linked variable entries, checking each one against the target variable name and type.

4D4CH – Simple Variable Search Path

This section handles the case where the parsed variable is a simple (non-array) type. It searches the simple variable area between 40F9H (string space start) and 40FBH (array end), walking through entries and comparing each one against the target variable.

4D62H – Variable Table Compaction Entry

This section is reached when the pre-scanner has exhausted all arguments (end-of-statement detected). It pushes the cleanup return address (586EH) and the compaction routine entry (4D67H) onto the stack, then falls through to the compaction code. The address 586EH is a routine in BASIC/CMD that serves as the post-sort cleanup handler, likely the single-digit parser or a nearby return point.

4D67H – Variable Table Compaction Routine

This routine compacts the BASIC variable table by walking through all entries and removing any gaps created during the sort operation. It processes the array variable area (40F9H–40FBH) and the string descriptor stack (40FDH), moving entries downward to close gaps and updating the area boundary pointers. This routine is also installed as the reset vector at 6427H so that it is automatically invoked if an error or BREAK interrupts the sort.

4D94H – Update Variable Pointers and Process String Descriptors

After compacting the array/variable area, this section updates the 40FBH pointer to reflect the new (smaller) variable area size, then performs the same compaction on the string descriptor stack between 40FBH and 40FDH.

4DBAH – CMD"O" Array Descriptor Table Initialization

This is the main CMD"O" entry point reached when SVC function code 37H is detected at 4D04H. It clears the SVC result byte at 4288H and the BASIC/CMD communication byte at 576EH, then initializes the 9-entry array descriptor table at 4300H. Each entry is 17H (23) bytes: a 2-byte sequential counter (1–9), a 01H marker byte, an FFH sentinel byte, and 13H (19) bytes of zeroes. The table occupies 4300H–43CEH with two final sentinel bytes at 43CFH–43D0H.

4DE2H – Element Count Parser

This section parses the first argument of the CMD"O" command: the element count n, which specifies how many elements from each array participate in the sort. The comma before n is consumed by RST 08H, and n is evaluated as a numeric expression via ROM 1E46H, returning the result in Register Pair DE. The count is stored at 4F27H. IX is then initialized to point to the first array descriptor table entry at 4300H.

4DEFH – Array Argument Processing Loop

This is the main loop that processes each comma-separated array variable argument in the CMD"O" statement. For each argument, it validates the entry counter, checks for the * prefix (indirect sort), checks for the - prefix (descending order), evaluates the array expression, locates the array in the variable table, computes element addresses and sizes, validates bounds, and optionally parses the substring field specification (x,y) for string arrays. The loop advances IX by 17H (23 bytes) for each argument and continues until end-of-statement.

4E11H – Array Expression Evaluation and Variable Table Lookup

This section evaluates the array variable expression, locates the array in the BASIC variable table, and extracts key information (type, element address, array base address) into the current descriptor table entry at IX. The ROM string expression evaluator at 260DH is called to evaluate the array variable, returning the array's address in DE and its type in 40AFH. The code then searches the variable table to find the matching array entry and computes the element layout.

4E3BH – Array Header Parsing and Element Address Computation

The matching array has been found in the variable table at address HL. This section now parses the array header to extract the dimension count, total element count, and element sizes. The BASIC array header format (starting at the matched entry) is: [name bytes][type byte][dim_count_low][dim_count_high][dim1_size_low][dim1_size_high]... for each dimension. The code walks through the dimension entries to compute the total number of elements and the starting element offset based on the subscript specified in the CMD"O" argument.

4E57H – Element Size Calculation and Bounds Validation

This section divides the byte offset (in HL) by the element size to compute the number of elements before the starting element (the REN offset), then validates that the array has enough elements for the sort. It also handles the special case where n was specified as 0, meaning "use all remaining elements from this array."

4E96H – Element Count Auto-Calculation and Final Bounds Check

This section handles the special case where the element count n was specified as 0 in the CMD"O" statement. When n is 0, the number of elements to sort is automatically set to the number of remaining elements in the first specified array (from the starting subscript to the end). It then performs the final bounds validation: the remaining elements in the array must be greater than or equal to n.

4EADH – Substring Field Parser and Argument Loop Advance

After validating the element count, this section checks whether the current array is a string type (03H) and, if so, looks for an optional substring field specification (x,y) following the array variable. The substring start position x and length y are parsed via ROM 2B1CH and stored into IX+02H and IX+03H. Finally, IX is advanced by 17H to the next descriptor table entry, and the loop returns to 4DEFH if more arguments remain.

4ED5H – Indirect Sort Index Array Initialization

This section handles the setup specific to indirect sorts (Format 2). After all array arguments have been parsed, if the indirect sort flag at 5102H is set, the code validates that the first array (entry 1) is an integer type, then validates that the second array (entry 2) has a non-zero type (at least one sort key array was specified). Finally, it fills the index array with sequential REN values (0, 1, 2, ..., n-1) so that the sort can rearrange the indices rather than the data.

4F01H – Sort Workspace Allocation

This section allocates workspace memory for the sort operation. It divides the available memory (0500H bytes = 1280 bytes) by the element size to determine how many elements can be processed, stores the workspace base address, and then uses the Array Walker Dispatch routine at 50EEH to set up element address pointers for all active array descriptors. The routine at 510CH stores element pointers into each descriptor's IX+0DH/0EH and IX+11H/12H fields.

4F1CH – Sort Outer Loop Entry

This is the entry point for the sort's outer loop. The sort uses a bidirectional bubble sort (cocktail shaker sort) that alternates between forward and reverse passes. The outer loop initializes the swap counter to 1 (indicating "no swaps yet" in a flag sense), then enters the pass setup. The sort terminates when a complete forward+reverse pass pair produces no swaps.

4F32H – Sort Pass Setup

This section sets up a new sort pass by calling the Array Walker Dispatch to advance element pointers (via routine 51D5H), then loads the pass counters for the bidirectional comparison. The sort operates as a cocktail shaker sort: the first pass sweeps forward comparing adjacent elements, and the second pass sweeps in reverse. The counters at 5145H and 5124H track how many comparisons remain in each direction.

4F63H – Sort Inner Loop (Comparison Dispatch)

This is the inner loop of the sort. It walks through all active array descriptors using IX, loading the element pointers from each descriptor and dispatching to the appropriate comparison routine based on the variable type. After comparing all sort key levels for the current element pair, the loop either advances to the next pair or triggers a swap.

4F6DH – Element Pair Comparison Entry

For each active descriptor entry, this section loads the two element pointers from IX+09H/0AH and IX+0DH/0EH into DE and HL respectively, reads the variable type from IX+01H, checks the sort direction flag at IX+04H bit 7, and then dispatches to the type-specific comparison routine. The comparison result (Z, CARRY, or NZ with no CARRY) determines whether the elements are equal, in order, or out of order.

4F88H – Integer Comparison (Sign-Magnitude XOR 80H)

This section compares two 16-bit signed integers. BASIC stores integers in sign-magnitude format where bit 15 is the sign bit. To compare signed integers correctly using unsigned subtraction, both values have their sign bits (bit 7 of the high byte) flipped using XOR 80H. This converts the sign-magnitude representation to an offset binary representation where the natural unsigned ordering matches the signed ordering: -32768 maps to 0000H, 0 maps to 8000H, and +32767 maps to FFFFH.

4F9DH – String Comparison Dispatcher

This section handles string and floating-point comparisons. After the integer check at 4F86H, Register A holds 01H for strings or 02H+ for floating-point. The string comparison is complex: it reads the string descriptors (length byte + 2-byte data pointer), resolves the substring field parameters from IX+02H/03H, and then performs a byte-by-byte comparison with length-awareness. The floating-point comparison falls through to a simple multi-byte backward comparison at 4FF7H.

4FD9H – Substring Character-by-Character Comparison

After the substring offset advance, both pointers (HL and DE) are positioned at the starting character for comparison. The substring length from IX+03H limits how many characters are compared. B holds element 1's remaining character count, C holds element 2's remaining count. The comparison walks forward through both strings, comparing byte by byte.

4FF7H – Floating-Point Comparison (Multi-Byte Backward)

This section handles single-precision (4-byte) and double-precision (8-byte) floating-point comparisons. Floating-point values in BASIC ROM are stored in a format where the most significant byte determines the magnitude, so the comparison works by scanning from the last (most significant) byte backward to the first (least significant) byte. The first byte that differs determines the ordering. Special handling is required for the sign byte (bit 7 of the last byte) and for zero values.

501CH – Floating-Point Sign and Mantissa Comparison

Both floating-point values are non-zero. This section compares the sign bits first. If the signs differ, the result is immediately determined. If both signs are the same, the values are compared byte-by-byte from most significant to least significant. For negative numbers, the comparison is reversed (a larger absolute value is more negative, so it sorts earlier in ascending order).

5039H – Comparison Result Dispatcher

This is the central comparison result dispatcher reached from all comparison types (integer, string, and floating-point). The flags encode the comparison result: Z = elements are equal (advance to next sort level), CARRY = element 1 < element 2 (already in order for ascending sort), NZ + no CARRY = element 1 > element 2 (out of order, need swap for ascending sort). For multi-level sorts, Z causes the loop to advance IX to the next descriptor entry and compare the next sort key.

5054H – Multi-Level Sort: Advance to Next Key Level

When the current sort key level comparison results in equality (Z flag), the sort must check the next key level to break the tie. This section advances IX by 17H to the next descriptor table entry and checks if there is another active sort key. If there is, it loops back to the comparison dispatcher at 4F6DH. If there are no more levels, the elements are fully equal and no swap is performed.

5060H – Reverse Direction Swap Dispatch

When the comparison shows element 1 < element 2 (CARRY set), the forward pass does not need a swap, but the reverse pass counter is updated. This section performs the reverse-direction swap and decrements the reverse pass counter.

5077H – Pass Complete: Reset Partition and Restart

When a pass direction's counter reaches zero, this section resets the partition boundary and starts a new pass cycle from the outer loop.

507DH – Partition Boundary Tracker

This routine decrements the partition boundary counter at 507EH. The partition boundary tracks the current position within the sort pass. When the counter reaches zero (which wraps from 0000H to FFFFH), the routine returns with Z flag cleared via the OR test, allowing the caller to detect the boundary. The self-modifying operand at 507EH was initialized at 4F19H with the workspace slot count.

5087H – Partition Boundary Reset

This routine resets the partition boundary to the workspace size value from 5088H and reinitializes the indirect index array pointers by calling the Array Walker Dispatch with the 5184H indirect index update routine.

5093H – Indirect Sort Index Resolver

This routine computes the actual element addresses for all sort key arrays based on the current index values in the indirect index array. For direct sorts (5102H = 00H), it returns immediately. For indirect sorts, it reads the current pair of index values from the index array, then walks through all sort key descriptor entries (starting at entry 2 / 4317H), computing the element address for each array as: base_address + (index_value × element_size). The computed addresses are written to the IX+09H/0AH and IX+0DH/0EH fields of each descriptor entry.

50D7H – Element Address Helper with Boundary Check

This helper routine checks IX+16H (the swap destination status flag). If IX+16H is zero, the routine simply adds BC to HL and returns — a basic address offset. If IX+16H is non-zero, it calls the 65F4H conditional return+position routine to perform a boundary-checked block copy using LDIR, updating the swap temp pointers at IX+13H/14H afterward.

50EEH – Array Walker Dispatch

This is a general-purpose dispatch routine that iterates through all active entries in the array descriptor table at 4300H. For each entry where IX+01H (the type code) is non-zero, it calls the routine whose address was stored at 50FFH. The routine address is passed in BC and stored via self-modifying code. The type code is loaded into C (with B=00H) before each call, making BC available to the called routine as the element size. The called routine can also access the current descriptor entry via IX.

510CH – Element Address Setup Routine

This routine is called by the Array Walker Dispatch (50EEH) to initialize element pointer fields in a descriptor entry. It stores element addresses into IX+0DH/0EH and IX+11H/12H, then jumps to 65FFH (the Conditional add loop in BASIC/CMD) for additional address computation. The disassembler has incorrectly decoded the DD-prefixed IX instructions in this section — the corrected mnemonics are shown below.

511DH – REN-to-Address Converter

This routine converts a Relative Element Number (REN) to an absolute memory address for the current descriptor entry. It computes: address = base_address + (REN × element_size) + element_offset. The routine uses self-modifying operands at 511EH/511FH and 5124H/5125H for the REN values, a multiply-by-repeated-addition loop, and stores the results into IX+09H/0AH (element 1 pointer) and IX+0DH/0EH (element 2 pointer). The disassembler has heavily garbled this section due to DD-prefixed IX instructions.

5153H – Forward Swap Routine

This routine performs a forward-direction element swap for one descriptor entry. It reads the element pointers from IX+0DH/0EH, calls the element address helper at 50DFH to perform a boundary-checked copy, then stores the updated pointers. The disassembler has garbled the IX store instructions in this section.

5174H – Reverse Swap Routine

This routine performs a reverse-direction element swap for one descriptor entry. It reads the element pointer from IX+09H/0AH, calls the element address helper at 50D7H, and stores the updated pointers.

5184H – Indirect Index Update / Block Swap Routine

This routine handles the bulk element swap for a descriptor entry. It computes the difference between the swap source (IX+0BH/0CH) and the current element pointer (IX+09H/0AH) to determine the block size, then copies the element data from the source to the destination using the 6608H FCB header + block copy routine in BASIC/CMD. It also handles the secondary block from IX+13H/14H to IX+11H/12H via LDIR. After the swap, it writes a status marker to IX+16H.

51D5H – Pass Advance Routine

This routine advances the element pointers for a descriptor entry to the next pair for the next comparison iteration. It copies IX+07H/08H (the array element address) to IX+0FH/10H (the element offset). The disassembler has garbled the DD-prefixed instructions.

51E2H – NOP Padding

Unused area filled with 00H bytes to pad the SYS21 overlay to its full allocated size of 4E8H bytes (4D00H–51E7H).