TRS-80 DOS - VTOS 4.0.2 for the Model I - SYS0/SYS Disassembled

SYS0/SYS

Other Navigation

VTOS 4.0.2 SYS0/SYS Disassembly - The Resident System (Model I)

SYS0/SYS is the part of VTOS that stays in memory. BOOT/SYS reads it from the diskette (granule 1 of cylinder 0 onward, its directory record being the first of sector 4 of the directory cylinder), copies its 123 load blocks to their addresses and jumps to its transfer address, 4E00H. The file starts with a record of type 05H (the name SYS0), a record of type 1FH holding the copyright notice of Randolph Cook (1980), and four records of type 07H naming the patches it carries: SYS0B, SYS0C, SYS0D and SYS0E2. Its last record gives the transfer address.

The load blocks go to four places. Three go straight into video memory: the banner at the top of the screen (stored negated, decoded by the reset), the words VTOS SERIAL # and the large letters VTOS in graphics characters. The resident system fills 400CH-405CH (the restart vectors, the device control blocks of the keyboard, display and printer, the keyboard image, the clock and the interrupt vectors) and 4300H-4DFFH (the system cells, the job log, the keyboard driver, the entry points, the interrupt routine and the task dispatcher, the disk driver and the drive code tables, the file routines, the request handler and the loader). 4E00H-50FFH holds the reset, which runs once: after it the system overlays SYS1/SYS-SYS10/SYS are loaded at 4E00H as they are needed, and the last parts of the reset have been copied out to 405DH and 41E5H first.

The four patches are part of the file's load blocks, so the page shows them as they are loaded. SYS0B (4863H-4868H and 45EAH-45F0H) and SYS0C (48A7H-48A9H and 44FAH-44FFH) concern the record number of a file and the writing back of a changed buffer before a record is read. SYS0D changes the reset: the D key (or the down arrow) held during the boot starts DEBUG, the @ key or ENTER stops the AUTO command (4FC0H-4FCCH, 50D0H-50D5H), the day of the week is worked out for 1980-1987 (4EA6H-4EBDH, 4EC3H-4ECEH, 4F2EH), the key repeat routine is moved to 41E5H (4E36H-4E47H, 50E0H-50FAH) and the keyboard image starts as all keys down (4036H-403CH). SYS0E2 (4BC3H-4BFFH) limits the case reversal of SHIFT 0 to the letters A-Z and handles CLEAR and the code 1AH.

Request Codes and the System Overlays

The File Control Block

Device Control Blocks

The Disk Driver

Tasks and the Clock

Points to Note

3C00H - Encoded Banner Lines (Video Memory)

The first load block of SYS0/SYS goes straight into video memory: screen lines 0 and 1 (the top two lines), 3C00H-3C7FH. Each byte is stored as its two's complement (00H less the character), so the screen shows graphics characters while the file loads; the reset at 4E06H-4E12H negates each byte back (NEG) and the lines read VTOS - VIRTUAL TECHNOLOGY'S OPERATING SYSTEM - VER 4.0.2 and COPYRIGHT (C) 1980 RANDOLPH COOK, ALL RIGHTS RESERVED. The bytes stay encoded on the diskette, so the notice cannot be read in the file with a text search.

3CD1H - VTOS SERIAL # Label (Video Memory)

A load block of 13 bytes into screen line 3 (3CC0H-3CFFH; line 0 is the top line), at columns 17-29. The reset puts the serial number, bytes C0H-C7H of the system information sector, right after it at 3CDEH-3CE5H (4F7CH-4F85H).

3D40H - VTOS Banner Graphics (Video Memory)

A load block of 320 bytes into screen lines 5-9 (3D40H-3E7FH; line 0 is the top line). The bytes are TRS-80 graphics characters (80H-BFH: bit 7 set, bits 5-0 the six blocks of a 2 by 3 cell) and spaces (20H); together they draw the letters VTOS five lines high, with the text TM after the S on line 5. They are shown as they are loaded: nothing in SYS0/SYS changes them.

400CH - Restart Vectors

The Model I ROM sends RST 28H, RST 30H and RST 38H through three jumps in RAM: RST 28H jumps to 400CH, RST 30H to 400FH and RST 38H (the maskable interrupt in interrupt mode 1) to 4012H. The ROM's power up copy puts RET or EI and RET there; SYS0/SYS loads its own three jumps over them.

4015H - Device Control Block of the Keyboard (KI)

The ROM's character I/O routine (03C2H) works through 8 byte device control blocks: +00H the type (bit 0 input, bit 1 output, bit 2 control), +01H-+02H the driver address, +03H-+05H the driver's own bytes, +06H-+07H the two letter name. SYS0/SYS adds two types of its own (44C4H): 10H, a block routed to the block whose address is in +01H-+02H, and 08H in bit 3, a device that takes nothing and gives nothing (NIL). A type of 11H or more is the first byte of an open file's control block (48E1H).

402DH - The Two Exits to the Command Level

Every program leaves through one of these two entries. 402DH (request 93H) is the normal exit: SYS1/SYS displays VTOS READY and waits for a command. 4030H (request A3H) is the abort exit; SYS1/SYS handles it the same way (its 4E00H-4E08H take both codes to 4E38H). Both load SYS1/SYS through RST 28H.

4036H - Keyboard Image

Seven bytes, one for each row of the keyboard matrix 3801H-3840H, holding the keys found down at the last scan; the driver at 439CH compares each row with its byte. The patch SYS0D carried as FFH in all seven (its record in the file): every key counts as already down when the system starts, so a key held during the boot does not start repeating once VTOS READY is shown.

404BH - Interrupt Latch Copy, Enable Mask and Interrupt Vectors

The interrupt service routine at 4518H reads the interrupt latch 37E0H, keeps it at 404BH, masks it with 404CH and calls, for each bit that is set, the routine whose address is in the vector table 404DH-405CH (bit 0 first).

405DH - Memory SYS0/SYS Uses Below 4300H

Three areas outside the file: the end of the reset, which runs at 405DH after being copied there, the key repeat routine copied to 41E5H, and the sector buffer at 4200H.

4300H - Keyboard Hook and System Cells

4300H-4302H is a hook the keyboard driver calls before every scan (439CH): RET in the file. 4306H-4317H are cells SYS0/SYS and the overlays share: the date kept across a reset, the current drive, the control block and return address of the last file request, the overlay in memory, the system flags, the request hook and the BREAK key vector.

4318H - Command Line Buffer and Two Control Blocks

4318H-4357H is the command line buffer of SYS1/SYS (64 bytes, its 4E20H-4E2BH and 4E4FH-4E54H). During the boot the reset copies the AUTO command into its first 32 bytes, and 4338H-4357H serves as the control block of CONFIG/SYS, whose name is loaded there. 4358H-4377H is the control block SYS6/SYS and SYS7/SYS use for the file of DO commands.

4378H - Write a Line to the Job Log (JL)

Reached through 447EH (a text alone) and 447BH (after the text has been displayed). When the JL device has a type other than 08H (NIL), the current time and two spaces go to it, then the text at Register Pair HL. The JL device is the device control block at 43C0H.

439CH - Keyboard Driver

The driver of the KI device (its address is put at 4016H by the reset, 4E48H-4E4DH). The ROM's input call reaches it through 03C2H with Index Register IX = 4015H, the KI block. Rows 0-6 of the keyboard matrix (3801H-3840H) are compared with the image at 4036H-403CH. A row that changed goes to 4BBCH; with no change the repeat routine at 41E5H decides whether the held key repeats. The SHIFT row (3880H) is read only when a key is decoded.

43C0H - Device Control Blocks of JL, SI and LO

Three more blocks of 8 bytes in the format of 4015H. JL (job log) is NIL (type 08H); SI (source input) is routed (type 10H) to the KI block at 4015H, LO (listing output) to the DO block at 401DH. The five blocks 43D8H-43FFH after them are free (the reset clears them, 4E66H-4E6CH). SYS10/SYS walks 4015H-402CH and then 43C0H-43FFH by name (its 4E79H-4E9AH).

4400H - Entry Points of the System

Programs reach the system through fixed addresses from 4400H up. Some load Register A with a request code and execute RST 28H, which loads the system overlay the code names and runs it; the others jump to a routine in SYS0/SYS. A request code with bit 7 set names an overlay in bits 3-0 (3 SYS1/SYS, 4 SYS2/SYS, 5 SYS3/SYS, 6 SYS4/SYS, 7 SYS5/SYS, 8 SYS6/SYS, 9 SYS7/SYS, AH SYS8/SYS, BH SYS9/SYS, CH SYS10/SYS: the directory entry code is the nibble below 8 and the nibble plus 18H from 8 up, 4C6FH-4C77H) and a function of that overlay in bits 6-4. The bytes between the entries are not in the file.

4480H - Control Block of the Program to Run

A 32 byte control block SYS1/SYS uses for the program a command names (its 4E6EH: Register Pair DE = 4480H for the file specification; 4E8BH: JP 4433H to load and run it). The file loads only its first 13 bytes, a file specification.

44A0H - Control Block of the System Overlays

The control block the request handler loads the overlays with (4C77H-4C9DH). It is left open: the handler puts the directory entry code at +07H, sets +01H to 00H and the record number to 0000H, and copies the first extent of the overlay's directory record to +0EH-+0FH; the loader reads it sector by sector into the buffer at 4200H.

44B0H - Requests Reached Through Other Entries

Short request stubs that other entries jump to: the error message (4409H), DEBUG (400FH, 440DH) and three requests used by SYS6/SYS and SYS7/SYS.

44C1H - Character I/O for Routed, NIL and File Devices

The ROM's character I/O routine (03C2H) jumps to 4033H and so to 44C4H when the type byte of the block at Index Register IX lacks the bit of the request in Register B (01H input, 02H output, 04H control); Register C holds the character. A type of 10H is followed to the block at +01H-+02H; a type of 11H and up is an open file; a type with bit 3 set is NIL; any other type calls the driver at +01H-+02H as the ROM would.

44DDH - Display or Print a Text

44DDH displays the text at Register Pair HL on the DO device, 44F2H prints it on the PR device, 44E0H sends it to the device at Register Pair DE. The text ends at 03H (not sent) or 0DH (sent). Register Pair HL is returned unchanged.

4500H - Task Slots

Twelve slots of two bytes, slot n at 4500H + 2n. Each holds the address of a task control block, whose first two bytes are the address of the task's routine; the routine runs with Index Register IX pointing at its control block. At every clock interrupt (40 a second) the dispatcher at 4578H runs slots 8-11 and then one of slots 0-7 in turn, so a task in slots 0-7 runs 5 times a second. An empty slot holds 45BBH, a control block whose routine is a RET.

4518H - Interrupt Service Routine

Reached from 0038H through 4012H at every interrupt of the expansion interface. The latch at 37E0H is read twice and ORed (a bit set in either read counts), kept at 404BH and masked with 404CH; for each bit left, from bit 0 up, the routine whose address is in the vector table 404DH-405CH is called with all registers saved. Then the BREAK key is tested: SHIFT and BREAK select the current drive again; BREAK alone goes to the address at 4316H when 4315H holds C3H.

4578H - Task Dispatcher

The vector of latch bit 7, the real time clock, called 40 times a second from 454BH. Slots 8, 9, 10 and 11 are run every time; then the tick counter 4040H is counted up and the slot given by its bits 2-0 is run. A task routine is entered with Index Register IX at its control block and 45BEH-45BFH holding the address of its slot.

45C7H - The Clock Task

The reset installs this control block in slot 7 (4F92H-4F97H), so its routine runs 5 times a second; every fifth time it adds one second to the time of day at 4041H-4043H, carrying into minutes, hours and, at midnight, the day at 4045H.

4600H - The Floppy Disk Driver

Every drive code table that exists starts with JP 4600H, so every disk call reaches this driver through 478DH (JP (IY)). Index Register IY = the drive code table, Register B = the function, Register Pair DE = the cylinder (Register D) and sector (Register E), Register Pair HL = the buffer. Functions below 08H move the head: 01H select, 05H step in, 06H seek, 07H wait while the controller is busy, the others (00H, 02H-04H) restore to cylinder 0. Functions 08H and up (bit 3 set) transfer a sector: 08H, 09H and 0BH read, 0AH reads without storing, 0CH and 0DH write, 0EH writes with the data mark FAH, 0FH and up write a track. The driver returns the Z FLAG on success, or the NZ FLAG with an error code in Register A (01H-07H reading, 09H-0FH writing).

4700H - Drive Code Tables

Ten bytes for each of the drives 0-7. +00H-+02H a jump to the driver (C9H for a drive that does not exist: the call returns at once with error 20H, 4783H-4786H); +03H bits 1-0 the stepping rate, bit 2 the shorter wait for a drive that is not ready; +04H the select byte for 37E1H; +05H the cylinder the head is on; +06H the last cylinder; +07H bits 4-0 the highest sector number of a track; +08H bits 4-0 the sectors of a granule less one, bits 7-5 the granules of a cylinder less one; +09H the directory cylinder. The reset copies drives 1-7 from the system information sector (4F87H-4F90H) and drive 0 from Index Register IY after a boot through a driver (4E6EH-4E7BH).

4750H - Calls to the Disk Driver

One entry for each driver function used by the system. Each saves Register Pair BC, puts the function in Register B and goes to 477AH, which records the drive in Register C at 4308H, points Index Register IY at its drive code table and calls through the table's first three bytes. Register Pair DE (cylinder and sector) and Register Pair HL (buffer) pass straight to the driver. Index Register IY and Register Pair BC are returned unchanged.

47B0H - Position to a Record (4442H)

Each file request starts with CALL 49EBH, which checks that Register Pair DE points at an open file control block, points Index Register IX at it, saves Register Pairs BC, DE, HL and Index Register IX and arranges for them to be restored on the way out. A file's position is the next record number at +0AH-+0BH (a sector of the file) and the byte offset at +05H; bit 5 of +01H set means the sector at +0AH-+0BH must be read before the next byte, bit 5 clear means the buffer holds the sector before it. Register Pair BC = the record number; in record mode (bit 7 of +01H, a record length other than 256) it is multiplied by the record length to give the sector and offset.

47F5H - Move On One Record (4460H)

The entry 4460H leads here. The routine calls 4851H, the end of the record number routine, which takes its own return address off the stack and puts the record number in its place (4870H-4873H): back here Register Pair BC holds 47FBH and Register Pair HL 4A0CH, and the RET that ends the request finds the record number where its return address should be. No file on this diskette uses 4460H.

47FEH - Back One Record (4445H)

The offset at +05H is moved back by the record length. When it stays in the same sector the position is set; when it goes below 0, the routine sets the next record number to one less and marks the sector to be read.

481AH - Back to the Buffer's Sector (4454H)

The next record number less one is the sector the buffer was read from; it becomes the next record number, marked to be read again, and the offset stays.

4826H - Rewind (443FH)

The position goes to sector 0, offset 0.

482DH - Position to the End of File (4448H)

The ending record number at +0CH-+0DH and the end of file offset at +08H give the end: when the offset is 00H the end is the start of the sector +0CH-+0DH, otherwise it is that offset in the sector before.

483FH - Move the Head to the Position (4451H)

When the position is before the end of file, its cylinder and sector are worked out and the drive seeks there, so a later read starts sooner.

484EH - Record Number of the Position (445AH)

Register Pair BC returns the number of the record at the current position (Register A the bits above 16, with the Z FLAG when they are 0). In record mode the byte position (sector x 256 + offset) is divided by the record length in two steps; the second step is the patch SYS0B at 4863H and 45EAH. 4851H is also called from 47F8H.

4875H - Number of Records of the File (445DH)

The same calculation as 4851H with the end of file in place of the position: the ending record number and the end of file offset.

4883H - Write the Ending Record Number to the Directory (444EH)

Any changed buffer is written first; then the file's directory record is read, the ending record number stored in its bytes 14H-15H, and the directory sector written back. 4889H is also called after each sector write when bit 3 of +01H is set (49E3H).

48A4H - Read a Record (4436H)

In record mode the record length's worth of bytes is taken one at a time (48F1H) into the area at Register Pair HL; with 256 byte records the next sector is read into the file's buffer.

48C0H - Write a Record (4439H, 443CH)

In record mode the record length's worth of bytes goes one at a time (4910H) from the area at Register Pair HL; with 256 byte records the file's buffer is written as the next sector. 443CH (48DBH) writes the same way with every sector read back to check it: the flag is the operand at 49C7H.

48E1H - Character I/O Through a File

The dispatcher at 44D1H jumps here when a device control block is routed to a file: Index Register IX is the file's control block, Register B the request (01H input, 02H output, 04H control), Register C the character. 48F1H takes the next byte of a file (also called by 48B5H), 4910H puts a byte into it (also called by 48D2H).

4949H - Read the Next Sector

4949H checks the end of file first; 494DH starts at the access check. The sector at the next record number is found (4A3CH, which asks SYS8/SYS for space when the file has none there) and read into the buffer, and the next record number goes up by one. A sector with a system data mark (error 06H) is taken as read.

4988H - Write Back a Changed Buffer

When bits 7 and 4 of +01H are both set (the file is used in records or bytes, and the buffer holds changed bytes), the buffer is written to the sector it was read from (4996H). SYS3/SYS calls 4988H before it closes a file (its 4E16H). 4993H (entry 4457H) writes the buffer in any case.

49E9H - Start of Every File Request

CALL 49EBH (or 49E9H) at the start of a file routine: Register Pair DE = the file's control block. 49EBH tests bit 7 of its first byte (open); 49E9H skips the test (the open and SYS10/SYS use it before the file is open). The address after the CALL goes to 430CH, Register Pair DE to 430AH. When the file is open, Index Register IX is set to the control block, Register Pairs BC, DE, HL and Index Register IX are saved, 4A0CH is put on the stack to restore them, and the routine goes on after its CALL with Register A = 00H; its RET then goes through 4A0CH. When the file is not open, the routine's caller gets error 26H.

4A12H - Compare the Position with the End of File (444BH)

Register Pair HL = the next record number, Register C = the offset. Before the end: Register A = 00H and the Z FLAG. At the end exactly: error 1CH (END OF FILE ENCOUNTERED). Past it: error 1DH (RECORD NUMBER OUT OF RANGE). The offsets are compared less one, so an end of file offset of 00H counts as 256.

4A3CH - Cylinder and Sector of the Next Record Number

The next record number is divided by the sectors of a granule: the quotient is the granule of the file, the remainder the sector inside it (kept at 4B0CH). The extents at +0EH-+1FH are searched for that granule: the first extent is cylinder and granule byte (+0EH-+0FH), each of the other four is the count of the file's granules before it (two bytes), cylinder and granule byte; a cylinder of FFH means no extent. An extent found third or later is moved to the second place. When no extent holds the granule, SYS8/SYS is asked for space (request 9AH). The result: Register D = cylinder, Register E = sector, Register C = the drive, the Z FLAG.

4B10H - Read and Write a Directory Sector

Register B = a directory entry code (bits 4-0 the sector less 2, bits 7-5 the record in it), Register C = the drive. 4B10H reads the sector into 4200H and returns Register Pair HL at the record (error 11H, DIRECTORY READ ERROR); 4B1FH writes 4200H back with the data mark FAH and reads it back (error 12H, DIRECTORY WRITE ERROR, or 0FH). SYS2/SYS, SYS3/SYS, SYS4/SYS, SYS6/SYS, SYS8/SYS and SYS10/SYS call them.

4B6CH - Arithmetic

4B6CH: Register A = Register A x Register E (8 bits). 4B7BH: Register A = Register E / Register A, Register E = the remainder. 4B8FH: Register A and Register Pair HL = Register Pair HL x Register A (24 bits: Register A the low byte, Register Pair HL the high bytes). 4BA9H: Register Pair HL = Register Pair HL / Register A, Register A = the remainder.

4BBCH - Keyboard Driver: a Key Changed

Entered from 43AAH when a row of the keyboard differs from its image: Register A = the bits that changed, Register E = the row now, Register D = the row number, Register Pair HL = the row's image byte, Register Pair BC = the row's address, Index Register IX = the KI block (4015H). The ROM decodes the key (03FAH); the code then gets the system's own changes (4BC3H-4BFFH, the patch SYS0E2): CLEAR held adds 80H (the second character set), SHIFT and CLEAR give 1FH, CLEAR alone gives nothing, SHIFT and 0 turn the reversal of upper and lower case on or off (letters A-Z only), and the code 1AH counts only with the Z key down. The key is kept at +03H of the KI block and its first repeat set 30 ticks ahead.

4C28H - Requests With Bit 7 Clear

A request code below 80H (from 4C33H) goes on to the address at 4310H, with the stack as the code that executed RST 28H left it. The ROM's keyboard routine executes RST 28H with Register A = 01H for BREAK (its 0456H); a non breakable AUTO command (4FB9H-4FBBH) or SYS6/SYS (its 525BH, 5268H) puts C8H (RET Z) at 4C2DH, and then BREAK becomes 00H, no key.

4C31H - The Request Handler (RST 28H)

Reached from 400CH. A request code with bit 7 clear goes to 4C28H. Otherwise the return address of RST 28H is dropped, the overlay the code names is loaded when it is not in memory (4C53H), the BREAK vector 4315H is set to C9H while it runs, and the overlay is called at its entry with Register A = the request code; its result comes back to the caller of the code that executed RST 28H.

4C53H - Load the Overlay of a Request Code

Register A = the request code, Register B = the member wanted (used by records of type 08H, the members of SYS6/SYS). When bits 3-0 name the overlay in memory (430EH) and the code is not 88H, nothing is read and the entry is 4E00H. Otherwise the overlay's directory record is read (directory entry code: bits 3-0, plus 18H from 8 up), its first extent copied to the system control block 44A0H and the file loaded from drive 0. A load error displays SYSTEM ERROR nn and goes to the abort exit. On return 4C49H holds the entry.

4CCBH - Load and Run a Program (4433H)

The program file at Register Pair DE is loaded through 4430H. A load error goes to the error message at 4409H. Otherwise the program is started at its transfer address: through the DEBUG monitor when bit 7 of 430FH is set, unless bit 1 is set too.

4CE4H - Load a Program File (4430H)

The file named by the control block at Register Pair DE is opened with the buffer at 4200H and whole sectors (request 94H, SYS2/SYS), then loaded by 4CF8H. Errors come back with bit 6 set; FILE NOT IN DIRECTORY (18H) is changed to PROGRAM NOT FOUND (1FH).

4CF8H - The Loader

Reads the file of the control block at Register Pair DE byte by byte (4D8EH, through the buffer at 4200H) and acts on each record by its type byte: 01H a load block (length, address, the bytes; each byte stored is read back), 02H the transfer address (the end), 04H the end of a member (its transfer address was saved from its header), 08H a member header (the member wanted is taken by its record and offset), 0AH and anything from 20H up an error (22H), any other type below 20H skipped by its length. Errors come back with bit 6 set.

4DABH - The Clock Display Task

SYS6/SYS installs this control block in slot 6 (its 5244H-524BH); its routine writes the time to the top line of the screen, at 3C35H, once a second (every fifth run of the slot).

4DDBH - The Trace Task

SYS6/SYS installs this control block in slot 11 (its 525AH-5261H), so it runs at every clock interrupt and writes the interrupted program counter in hex at 3C2EH, the top line of the screen. 4DE7H writes Register Pair DE and 4DECH Register A as hex at Register Pair HL; SYS4/SYS and SYS6/SYS call them too.

4E00H - The Reset: Transfer Address of SYS0/SYS

BOOT/SYS jumps here after loading SYS0/SYS (Index Register IY = 0000H, or a drive code table after a boot through a driver). The reset decodes the banner, finds the top of memory, installs the keyboard driver and the key repeat routine, sets up the devices, the interrupts and the clock, shows the date with its day of the week (or --NO DATE--), checks the system information sector of drive 0, takes the drive code tables, the serial number and the AUTO command from the diskette, loads CONFIG/SYS when the diskette asks for it, and ends in the code it copied to 405DH, which runs the AUTO command or goes to VTOS READY. 4E00H-50FFH is taken by the overlays afterwards, so this code runs only once. It carries the patch SYS0D (4E36H-4E47H, 4EA6H-4EBDH, 4EC3H-4ECEH, 4F2EH, 4FC0H-4FCCH, 50D0H-50D5H).

4FEEH - Last Part of the Reset (Runs at 405DH)

Copied to 405DH-407CH by 4FD5H-4FDFH and entered there by the RET at 4FE1H (or after CONFIG/SYS is loaded), since CONFIG/SYS and the overlays load over 4E00H-50FFH. The rows show the file addresses; each comment gives the address the instruction runs at. The only jump inside the part is relative (4FF3H), the others leave it.

500EH - Texts and Tables of the Reset

The texts the reset displays and the table of the days of the months used for the day of the week. Each text ends with 03H, which 44E2H stops at and 4F3CH counts.

5065H - Names of the Months

Twelve texts, each ended by 03H; 4F05H-4F08H displays the one the month gives at screen line 12, column 20. The spaces after each name keep the date after it in the same place.

50D0H - Patch SYS0D: Do Not Run the AUTO Command

Called from 4FCAH when the @ key or ENTER is held during the boot. Its own record in the file (the patch SYS0D) put it here.

50E0H - Key Repeat Routine (Runs at 41E5H)

Copied to 41E5H-41FFH by the reset (4E36H-4E3FH, the patch SYS0D) and entered there by JP M,41E5H at 43B1H when no row of the keyboard changed, with Index Register IX at the KI block (4015H). While a key is held (+03H, 4018H), it repeats it when the tick counter 4040H is at its repeat tick (+04H, 4019H) or up to 29 ticks past it, and sets the next repeat 3 ticks on. The rows show the file addresses; each comment gives the address the instruction runs at.