      +------------------------------------------------------------------------
      |
      |      DISK-DRIVE 1581: ROM-LISTING
      |
      +------------------------------------------------------------------------
      |
      | Comments done by Peter Steiner, used with permission.
      |
      |   $8000/32768      Checksumme
      |   $8004/32772      Befehlsstring vom Computer auswerten ($c146)
      |   $804C/32844      Abschluss eines Befehls ($c194)
      |   $8071/32881      INPUT-Puffer loeschen ($c1bd)
      |   $807C/32892      Fehler ausgeben mit T&S = 00 ($c1c8)
      |   $8085/32901      Sucht Drivenummer in der Befehlszeile ($c1d1)
      |   $8099/32921      Eingabezeile bis zum ':' auswerten ($c1e5)
      |   $80A2/32930      Eingabezeile pruefen bei Copy, Rename, New ($c1ee)
      |   $811C/33052      Eingabezeile bis zu einem bestimmten Zeichen auswerten ($c268)
      |   $8165/33125      Kommandozeilenende feststellen (CR (/LF) entfernen) ($c2b3)
      |   $81E5/33253      LED-Routinen ($c100)
      |   $81FD/33277      Laufwerksnummer holen und setzen ($c312)
      |   $820B/33291      Alle Parameter auf Laufwerksnummer pruefen und diese ggf. loeschen ($c320)
      |   $8224/33316      Laufwerksnummer testen und entfernen ($c33c)
      |   $8251/33361      Drivenummer setzen, LED einschalten ($c368)
      |   $8270/33392      Dateityp feststellen ('s,p,u,r,c') (z.B. '$*=s') ($c398)
      |   $8295/33429      Laufwerksnummer pruefen ($c3bd)
      |   $82A2/33442      Drive initialisieren, LED einschalten ($c3ca)
      |   $82B9/33465      alle angegebenen Dateien im Directory suchen ($c44f)
      |   $82E6/33510      Dateien einzeln suchen ($c48b)
      |   $8327/33575      Eintrag im Directory mit gesuchten Eintraegen vergleichen ($c4d8)
      |   $83D7/33751      Prueft, ob alle Dateien gefunden worden sind ($c617)
      |   $83FA/33786      1581: Zeichen hinter '*' vergleichen
      |   $8424/33828      naechsten Eintrag im Directory suchen : ($c5ac)
      |   $84AE/33966      Testet auf Diskettenwechsel und initialisiert ggf. ($c63d)
      |   $84EE/34030      Parameter aus dem INPUT-Puffer in Disk-Puffer kopieren ($c66e)
      |   $8526/34086      Laenge eines Parameters ermitteln ($c6a6)
      |   $854D/34125      Directory-Zeile im Zwischenpuffer erzeugen ($c6ce)
      |   $8688/34440      Scratch ($c823)
      |   $8746/34630      Partition formatieren
      |   $876E/34670      Copy ($c8f0)
      |   $8841/34881      aktuelles File oeffnen ($c9fa)
      |   $8876/34934      Byte aus aktueller Datei holen und auf Dateiende pruefen ($ca35)
      |   $8895/34965      REL-File zum Kopieren vorbereiten ($ca53)
      |   $88C5/35013      RENAME ($ca88)
      |   $8903/35075      aktuellen Filetyp ermitteln und
      |   $891E/35102      pruefen, ob alle Files vor dem '=' nicht existieren
      |   $892F/35119      Memory-Befehle ($caf8)
      |   $898F/35215      User-Befehle ($cb5c)
      |   $89E4/35300      '#', oeffnen eines Direktzugriffkanals ($cb84)
      |   $8A5D/35421      Block-Befehle ($cc1b)
      |   $8A9F/35487      Parameter der Block-Befehle holen ($cc7c)
      |   $8AD0/35536      ASCII-Werte aus dem Input-Puffer in HEX-Werte umwandeln
      |   $8B23/35619      Block-Free ($ccf5)
      |   $8B2F/35631      Block-Allocate ($cd03)
      |   $8B65/35685      Block-Read-Parameter pruefen und Block lesen ($cd36)
      |   $8B6B/35691      Byte aus Puffer holen ($cd3c)
      |   $8B71/35697      Block lesen und Pufferzeiger setzen ($cd42)
      |   $8B85/35717      Block-Read ($cd56)
      |   $8B8E/35726      Super-Read
      |   $8B9A/35738      u1 ($cd5f)
      |   $8BAE/35758      Block-Write ($cd73)
      |   $8BD1/35793      Super-Write
      |   $8BD7/35799      u2 ($cd97)
      |   $8BE3/35811      Block-Execute ($cda3)
      |   $8BFA/35834      Block-Pointer ($cdbd)
      |   $8C0F/35855      Kanal oeffnen ($cdd2)
      |   $8C2F/35887      Kanal oeffnen, Blockparameter holen und testen ($cdf2)
      |   $8C44/35908      Kanal oeffnen, Blockparameter holen und NICHT testen
      |   $8C5C/35932      Puffer allokieren
      |   $8C61/35937      Block-Befehle und Adressen ($cc5d)
      |   $8C89/35977      Position des Records berechnen ($ce0e)
      |   $8CC1/36033      Zahl der Bytes bis zum gesuchten Record berechnen ($ce2c)
      |   $8CE6/36070      24*8-Bit-Multiplikationsroutine ($ce4e)
      |   $8D06/36102      24/8-Bit-Divisionsroutine ($ce71)
      |   $8D38/36152      Rechenregister 1 loeschen ($ced9)
      |   $8D41/36161      Rechenregister 2 *2 bzw. *4 ($cee2)
      |   $8D4C/36172      Rechenregister addieren ($ceed)
      |   $8D59/36185      Feststellen, welcher Kanal schon am laengsten inaktiv ist
      |   $8D7D/36221      Puffer wechseln im Zwei-Puffer-Betrieb ($cf1e)
      |   $8E37/36407      Falls dem Kanal ein Puffer fehlt, einen neuen zuordnen ($cf7b)
      |   $8E4D/36429      Aktiven Puffer wechseln ($cf8c)
      |   $8E5C/36444      Byte ueber internen Schreibkanal in Puffer schreiben ($cf9b)
      |   $8E78/36472      Byte in aktuelle Datei schreiben ($cfb7)
      |   $8EB1/36529      Byte in Puffer schreiben, Pufferzeiger erhoehen ($cff1)
      |   $8EC5/36549      Initialize ($d005)
      |   $8EDC/36572      Blockheader des Verzeichnisheaders suchen
      |   $8F03/36611      Partition initialisieren ($d042)
      |   $8FD6/36822      Block einlesen und Folgeblock merken ($d09b)
      |   $8FEA/36842      Block (und ggf. Folgeblock) im 2-Puffer-Modus lesen ($d0af)
      |   $8FFE/36862      ???
      |   $9027/36903      Kanal zum Lesen holen und pruefen ($d0eb)
      |   $9042/36930      Kanal zum Schreiben holen und pruefen ($d107)
      |   $905F/36959      Aktuellen Filetyp holen ($d125)
      |   $9069/36969      Kanal- und Puffernummer holen ($d12f)
      |   $9071/36977      Byte aus aktuellem Puffer holen ($d137)
      |   $909B/37019      Byte aus aktueller Datei holen ($d156)
      |   $9112/37138      Schreiben eines Bytes in eine Datei im 2-Puffer Modus. ($d19d)
      |   $9138/37176      Erhoehen des aktuellen Pufferzeigers ($d1c6)
      |   $9145/37189      Autoboot bei Warmstart ein/aus
      |   $9157/37207      Kanal oeffnen und entsprechende Zahl Puffer zuordnen ($d1df)
      |   $919E/37278      Freigeben einer SA ausser der des Kommandokanals; Puffer freigeben ($d227)
      |   $91CE/37326      Puffer und dessen Kanalzuordnung freigeben ($d25a)
      |   $9204/37380      Suchen eines freien oder inaktiven Puffers ($d28e)
      |   $9228/37416      Suchen und belegen eines freien Puffers ($d2ba)
      |   $923E/37438      einen inaktiven Puffer eines Kanals freigeben ($d2da)
      |   $9252/37458      Puffer freigeben                <-- Einsprung
      |   $9262/37474      Kanaele der Sekundaeradressen 1-14 freigeben ($d307)
      |   $926E/37486      Die SA 0-14 des Laufwerks 0 freigeben
      |   $9291/37521      'Stehlen' eines inaktiven Puffers ($d339)
      |   $92DB/37595      Freien Kanal suchen ($d37f)
      |   $92F4/37620      Byte fuer beliebige SA holen ($d39b)
      |   $9303/37635      Byte aus beliebigem Kanal holen ($d3aa)
      |   $9370/37744      Fehlerkanal auslesen bzw M-R-Befehl ($d414)
      |   $93AA/37802      Lesen des naechsten Blocks ($d44d)
      |   $93BD/37821      Lesen/Schreiben des aktuellen Puffers ($d460)
      |   $93CF/37839      Datei auf internem Lesekanal oeffnen,
      |   $93E0/37856      Datei auf internem Schreibkanal oeffnen,
      |   $93E7/37863      Neuen Block an das Directory anhaengen ($d48d)
      |   $9422/37922      Pufferzeiger auf bestimmten Wert setzen ($d4c8)
      |   $9434/37940      interne Schreib-/Lesekanaele freigeben ($d4da)
      |   $9450/37968      Holt Byte aus aktuellem Puffer ($d4f6)
      |   $9460/37984      Prueft auf Diskettenwechsel
      |   $9471/38001      T&S auf Gueltigkeit pruefen       ($d506)
      |   $94A8/38056      Track und Sektor aus Jobpuffer holen und als aktuelle T&S merken ($d552)
      |   $94B5/38069      Auf gueltigen Block (T&S) pruefen ($d55f)
      |   $94CB/38091      Meldung fuer falsches Formatkennzeichen ausgeben ($d572)
      |   $94D3/38099      Job setzen und Controller aufrufen ($d57a)
      |   $94DE/38110      Schreib-/Lesejobs pruefen und Durchfuehrung abwarten ($d586)
      |   $94F8/38136      Job auf fehlerfreie Durchfuehrung pruefen ($d5a6)
      |   $9585/38277      T&S an DC uebergeben ($d6d0)
      |   $9598/38296      Aufruf des Controllers
      |   $95AB/38315      Neue Datei im Directory eintragen ($d6e4)
      |   $9678/38520      Datei mit SA 0-14 oeffnen ($d7b4)
      |   $9773/38771      File zum Schreiben oeffnen ($d8c6)
      |   $97A2/38818      Oeffnen eines Files mit Ueberschreiben ($d8f5)
      |   $97ED/38893      Zugriffsart feststellen und File zum Lesen oeffnen ($d940)
      |   $984D/38989      Oeffnen eines Files zum Lesen ($d9a0)
      |   $9890/39056      neues File anlegen und zum Schreiben oeffnen ($d9e3)
      |   $9896/39062      T&S eines Files holen und fuer 'LOAD "*",8' merken ($d9ef)
      |   $98AB/39083      File-Modus oder File-Typ aus Kommandozeile holen ($da09)
      |   $98CC/39116      APPEND: Fileende suchen und auf Schreiben umschalten ($da2a)
      |   $98F7/39159      Oeffnen des Directory als Basicprogramm ($da55)
      |   $995C/39260      CLOSE-Routine: aktuelle Sekundaeradresse schliessen ($dac0)
      |   $9986/39302      Alle Dateien schliessen ($daec)
      |   $999F/39327      Datei schliessen ($db02)
      |   $9A2A/39466      letzten Dateiblock abspeichern ($db62)
      |   $9A72/39538      Eintrag im Directory nach dem Schreiben updaten ($dba5)
      |   $9B0D/39693      Kanal zum Lesen suchen
      |   $9B9B/39835      Pufferzeiger initialisieren ($dcb6)
      |   $9BC3/39875      File zum Schreiben oeffnen ($dcda)
      |   $9CCA/40138      Byte in aktuellen Side-Sektor schreiben ($dd8d)
      |   $9CD3/40147      Dateistatus setzen/loeschen ($dd95)
      |   $9CE9/40169      Prueft den Jobcode des aktuellen Puffers auf 'Schreiben' ($ddab)
      |   $9CF5/40181      prueft, ob gesuchtes File durch eine SA angesprochen wird ($ddb7)
      |   $9D2E/40238      Puffer schreiben, wenn er veraendert wurde ($ddf1)
      |   $9D3A/40250      Folgeblock im aktuellen Block eintragen ($ddfd)
      |   $9D49/40265      T&S des Folgeblocks holen ($de0c)
      |   $9D56/40278      Blocklaenge des letzten Datenblocks setzen ($de19)
      |   $9D69/40297      Zeiger auf Anfang des aktiven Puffers setzen ($de2b)
      |   $9D79/40313      T&S der aktuellen Datei holen ($de3b)
      |   $9D8E/40334      Schreib-Lesejobs aufrufen ($de50)
      |   $9DCE/40398      T&S des Folgeblocks des aktiven Kanals holen
      |   $9DDE/40414      Pufferinhalte kopieren ($dea5)
      |   $9DFA/40442      Puffer mit $00 fuellen ($dec1)
      |   $9E0B/40459      Nummer des aktuellen Side-Sektors holen ($ded2)
      |   $9E15/40469      Side-Sektor-Pufferzeiger auf beliebigen Wert setzen ($dedc)
      |   $9E23/40483      Pufferzeiger des aktuellen Side-Sektors auf beliebigen
      |   $9E32/40498      Gruppe anwaehlen, ggf. Side-Sektor laden ($def8)
      |   $9E56/40534      Side-Sektor lesen/schreiben ($df1b)
      |   $9E75/40565      Pufferzeiger des Side-Sektors nach $64-$65 holen ($df45)
      |   $9E7D/40573      Anzahl der benoetigten Blocks einer REL-Datei berechnen ($df4c)
      |   $9E97/40599      Anzahl der benoetigten Blocks einer REL-Datei berechnen
      |   $9ED3/40659      Feststellen, ob Record existiert und ggf. richtige Gruppe anwaehlen ($df66)
      |   $9F11/40721      Nummer des aktiven Puffers holen ($df93)
      |   $9F1C/40732      Aktiven Puffer pruefen und holen ($df9e)
      |   $9F33/40755      Pruefen, ob ein Puffer des Kanals nicht belegt ist ($dfb7)
      |   $9F3E/40766      einem Kanal einen neuen Puffer zuordnen ($dfc2)
      |   $9F4C/40780      naechsten Record holen ($dfd0)
      |   $9FBF/40895      ggf. alten Puffer speichern, dann Folgeblock(s) einlesen  ($e03c)
      |   $9FFC/40956      Ein Byte in Record-Puffer schreiben ($e07c)
      |   $A033/41011      Empfangene Daten in Record schreiben ($e0ab)
      |   $A07B/41083      Rest eines Records mit $00 auffuellen ($e0f3)
      |   $A08D/41101      Flag fuer 'Puffer geaendert' setzen ($e105)
      |   $A09C/41116      Flag fuer 'Puffer geaendert' loeschen ($e115)
      |   $A0A6/41126      Byte aus Record-Puffer holen ($e120)
      |   $A0E1/41185      Naechsten Record lesen ($e153)
      |   $A0EC/41196      Abbruch bei Fehler ($e15e)
      |   $A0FD/41213      Letztes benutzte Zeichen im Record suchen ($e16e)
      |   $A15C/41308      Letzten Datenblock einer REL-Datei
      |   $A1A1/41377      Position-Befehl ($e207)
      |   $A20D/41485      gesuchten Record zur Ausgabe bereitstellen ($e275)
      |   $A235/41525      benoetigte Datenbloecke  ggf. einlesen ($e29c)
      |   $A298/41624      Puffer mit leeren Records fuellen ($e2e2)
      |   $A2BC/41660      Position des naechsten Records berechnen ($e304)
      |   $A2D6/41686      Bloecke zu REL-File hinzufuegen ($e31c)
      |   $A438/42040      Parameter des letzten Records der Datei merken
      |   $A459/42073      Neuen Side-Sektor zur relativen Datei hinzufuegen ($e31c)
      |   $A547/42311      Wenn Gruppe voll, dann neue Gruppe anlegen
      |   $A56E/42350      Prueft, ob Super-Side-Sektoren verwendet werden, oder nicht
      |   $A574/42356      Super-Side-Sektor laden
      |   $A5A9/42409      letzte existierende Gruppe ermitteln
      |   $A5C0/42432      Gruppe anwaehlen
      |   $A602/42498      Fehlermeldungen ($e4fc)
      |   $A7AE/42926      Error-Routine des Controllers ($e60a)
      |   $A7F1/42993      CmdError: Error-Routine des DOS ($e645)
      |   $A83E/43070      Byte in Ziffernstring umwandeln ($e69b)
      |   $A862/43106      Fehlermeldung bereitstellen ($e6bc)
      |   $A8AD/43181      Fehlertext in Puffer schreiben ($e706)
      |   $A926/43302      Autoboot-Routine
      |   $A938/43320      JCBMBOOT: Autoboot-Programm aufrufen
      |   $A94C/43340      JCBMBOOTRTN: Ruecksprung aus Autoboot-Programm
      |   $A956/43350      Utility-Loader (&) ($e7a3)
      |   $AA0F/43535      Sprungadressen der Error-Routinen merken
      |   $AA27/43559      Sektorversatz einstellen
      |   $AA2D/43565      Anzahl Leseversuche einstellen
      |   $AA33/43571      Cache-Verzoegerung einstellen
      |   $AA39/43577      ROM-Test
      |   $AA3C/43580      Burst-Befehl $1e: CHGUTL (bei der 1571: $8fe5)
      |   $AAA8/43688      Burst-Memory-Read/Write
      |   $AB09/43785      Parameter '0' und '1' auswerten (CHGUTL-Parameter)
      |   $AB1D/43805      ROM-Signatur pruefen (CRC-Test) (bei der 1571: $924e)
      |
      |    BUS-Routinen
      |    [Ein grosses Problem bei der Kommentierung der Bus-Routinen ist, dass die
      |     Leitungen zwischen dem Computer und den Laufwerken low-aktiv sind und
      |     im Computer sogar die Eingangs-Signale nicht wieder zurueckgekippt werden.
      |     Zwischen den verschiedenen ROM-Listings gehen daher die Meinungen
      |     auseiander, was nun unter einem High- und einem Low-Signal zu verstehen
      |     ist. Weil selbst ein im Computer abgeschicktes Hi wieder als Lo empfangen
      |     wird, wird dort deshalb haeufig der am Bus messbare Pegel benutzt. Dagegen
      |     bezeichnen die mir bekannten DOS-Listings ein 1-Bit im Register als Hi
      |     (bei dem die entsprechende Bus-Leitung dann aber Lo ist), weil dann der
      |     'aktive' Pegel mit Hi bezeichnet wird. Wenn also die Ausgaberegister Lo
      |     sind, sind die entsprechenden Treiber inaktiv und stoeren andere Geraete
      |     nicht bei der Datenuebertragung. Das bedeutet aber auch, dass das DATA OUT-
      |     auf Lo gesetzt werden muss, wenn ein 1-Datenbit uebertragen werden soll.
      |     Ich habe mich bei der Kommentierung der BUS-Routinen an das System der
      |     mir bekannten DOS-Listings gehalten und bezeichne ein Signal als Hi, wenn
      |     das entsprechende Register-Bit 1 ist.]
      |
      |   $ABCF/43983      ATN-bearbeiten ($e85b; bei der 1571: $80ce)
      |   $AC9D/44189      FSM: DRF (Device Request Fast) Signal senden (bei der 1571: $8199)
      |   $ACB6/44214      FSM auf Eingang schalten
      |   $ACCF/44239      FSM auf Ausgabe schalten
      |   $ACE8/44264      DATA OUT auf Lo (die Busleitung wird dadurch Hi)
      |   $ACF1/44273      DATA OUT auf Hi (die Busleitung wird dadurch Lo)
      |   $ACFA/44282      CLOCK OUT auf Hi (die Busleitung wird dadurch Lo)
      |   $AD03/44291      CLOCK OUT auf Lo (die Busleitung wird dadurch Hi)
      |   $AD0C/44300      Bus auslesen und entprellen
      |   $AD15/44309      ATN-Modus testen ($ea59; bei der 1571: $ea59)
      |   $AD2F/44335      Kurze Zeit warten (bei der 1571: $a47e)
      |   $AD3C/44348      NMI-Routine ($ff01)
      |   $AD5C/44380      Daten auf seriellen Bus ausgeben ($e909; bei der 1571: $823d)
      |   $AE42/44610      Byte vom seriellen Bus holen ($e9c9; bei der 1571: $82c7)
      |   $AEB8/44728      Daten vom seriellem Bus holen ($ea2e; bei der 1571: $8342)
      |   $AED9/44761      Ende bei Uebertragungsfehler
      |   $AEDF/44767      Busbetrieb beenden
      |   $AEEA/44778      JSPINOUT: FSM-Datenrichtung festlegen
      |   $AEF2/44786      Fehlerblinken nach Selbsttest ($ea6e)
      |   $AF24/44836      Reset-Routine ($eaa0)
      |   $AFCA/45002      Warmstart ($eb22)
      |   $AFE9/45033      Dos-Tabellen initialisieren ($eb3a)
      |   $B0B3/45235      Ganze Diskette als Partition setzen
      |   $B0CF/45263      Physikalisches 1581-Diskettenformat festlegen
      |   $B0F0/45296      JIDLE - Hauptleerschleife ($ebe7)
      |   $B15B/45403      Cache am Ende der Verzoegerungszeit auf Diskette schreiben
      |   $B17C/45436      Directory formatieren und in Ausgabepuffer schreiben ($ec9e)
      |   $B237/45623      Directoryzeile in Ausgabepuffer kopieren ($ed59)
      |   $B245/45637      Byte aus Directory holen und zur Ausgabe bereitstellen ($ed67)
      |   $B262/45666      Validate-Befehl ($ed84)
      |   $B2C7/45767      Blocks eines Files in BAM belegen ($ede5)
      |   $B2EF/45807      naechsten Block einer Partition holen
      |   $B323/45859      Partition-Parameter aus Verzeichniseintrag holen
      |   $B33C/45884      Partition in Bam belegen
      |   $B348/45896      NEW-Befehl ($ee0d)
      |   $B380/45952      ???
      |   $B390/45968      Verzeichnis-Header und BAM anlegen ($ee56)
      |   $B43D/46141      BAM-Puffer loeschen ($f005)
      |   $B44A/46154      neue BAM erzeugen ($eeb7)
      |   $B515/46357      Wenn die BAM geaendert wurde, dann
      |   $B546/46406      Block in Bam freigeben ($ef5f)
      |   $B572/46450      Block in BAM belegen ($ef93)
      |   $B5B4/46516      BAM-Zeiger auf Eintrag fuer aktuellen Track setzen ($f011)
      |   $B5D8/46552      Pruefen, ob Block $4e im aktuellen Track frei ist ($efd2)
      |   $B5F2/46578      Wenn BAM-Puffer leer, dann BAM einlesen ($f0df)
      |   $B612/46610      BAM auf Diskette schreiben
      |   $B633/46643      Verzeichnis-Header in aktuellen Puffer lesen, ggf. BAM lesen
      |   $B643/46659      T&S und Puffernummer eines Dir-Sektors an DC uebergeben
      |   $B64F/46671      BAM-Zeiger auf 1. BAM-Puffer setzen ($ef3a)
      |   $B65B/46683      Anzahl freier Blocks zur Ausgabe bereitstellen ($ef4d)
      |   $B668/46696      Folgeblock fuer Datei suchen ($f11e)
      |   $B6ED/46829      Startblock einer neuen Datei suchen ($f1a9)
      |   $B746/46918      naechsten freien Block im aktuellen Track suchen ($f1fa)
      |   $B75E/46942      Prueft, ob im aktuellen Track die Anzahl freier Blocks stimmt. ($f220)
      |   $B781/46977      Partition-Befehl
      |   $B811/47121      Pruefen, ob alle Blocks der Partition vor dem Anlegen noch frei sind
      |   $B851/47185      Partition-Namen holen
      |   $B85F/47199      Parameter fuer die Partitionerstellung holen
      |   $B88D/47245      Neuen Bereich anlegen
      |   $B8D2/47314      Burst-Befehl $1f: Fastload (bei der 1571: $9080)
      |   $B9D3/47571      ERROR: Controller-Error-Routine des Burst-Fastloads
      |   $B9DF/47583      CMDERR: Fehler-Routine des Burst-Fastloads
      |   $B9EC/47596      Fehlermeldung ausgeben (bei der 1571: $91ad)
      |   $B9FB/47611      #$02 auf FSM-Bus ausgeben (File not found), TXA
      |   $BA06/47622      Filenamen nach Drivenummer durchsuchen
      |   $BA40/47680      Byte auf FSM-Bus ausgeben (bei der 1571: $9228)
      |   $BA64/47716      Fehlerbehandlung fuer Burst-Fastload setzen
      |   $BA7C/47740      Sprungvektoren der Fehlerbehandlung retten
      |   $BA95/47765      Sprungvektoren der Fehlerbehandlung zurueckschreiben
      |   $BAAE/47790      Burst-Befehl: Read mit logischen Blockangaben (bei der 1571: $83a4)
      |   $BAF7/47863      Burst-Status uebermitteln (bei der 1571: $837c)
      |   $BAFC/47868      Status in a setzen und uebermitteln (bei der 1571: $8381)
      |   $BB11/47889      Burst-Befehle $00,$10: Read (bei der 1571: $8371)
      |   $BB74/47988      Burst-Befehl: Write mit logischen Blockangaben
      |   $BBF6/48118      Burststatus bei Schreibfehlern ausgeben
      |   $BC01/48129      Burst-Befehle $02,$12: Write (bei der 1571: $83ec)
      |   $BCB2/48306      Burst-Befehle $04,$14: Inquire Disk (bei der 1571: $848b)
      |   $BD0A/48394      ???
      |   $BD12/48402      Burst-Befehle $06,$07,$16,$17: Format (bei der 1571: $84b7)
      |   $BDFC/48636      Burst-Befehle $08,$09: (n.v.) (bei der 1571: $85a5)
      |   $BE06/48646      Burst-Befehle $0a,$1a: Query Disk Format (bei der 1571: $8517)
      |   $BEBB/48827      Burst-Befehl $0c: Inquire Status (bei der 1571: $856b)
      |   $BEF8/48888      Burst-Befehle $0e,$0f: (n.v.)
      |   $BF02/48898      Burst-Befehle $1c,$1d: Dump Cache
      |   $BF44/48964      Kopf ggf. auf die angegebene Spur setzen (bei der 1571: $891b)
      |   $BF5A/48986      Burst-Status senden, wenn gerade Daten vom Computer empfangen werden
      |   $BF66/48998      Burst-Status setzen
      |   $BF83/49027      FSM: Byte ausgeben (bei der 1571: $9228)
      |   $BFAB/49067      Statusbyte ausgeben
      |   $BFB0/49072      Job ausfuehren und ggf. bei Fehlern mehrmals versuchen (bei der 1571: $864b)
      |   $BFE3/49123      Cachepuffer auf Diskette schreiben
      |   $C026/49190      FSM: Wartet, bis naechstes Byte gesendet werden soll (bei der 1571: $86a0)
      |   $C040/49216      physikalischen Folgesektor holen (bei der 1571: $886c)
      |   $C07A/49274      logischen Folgesektor holen (bei der 1571: $886c)
      |   $C097/49303      Groesste/kleinste Sektornummer suchen (bei der 1571: $8961)
      |   $C0BE/49342      JLCC: Controller-Routine
      |   $C163/49507      Tabellen des Controller-Programms
      |   $C390/50064      JOB $84: MOTON_DV
      |   $C393/50067      JOB $86: MOTOFF_DV
      |   $C396/50070      JOB $88: MOTONI_DV
      |   $C3A9/50089      JOB $8a: MOTOFFI_DV
      |   $C3AF/50095      JOB $8c: SEEK_DV
      |   $C3BB/50107      JOB $8e: FORMAT_DV
      |   $C3D6/50134      Spur formatieren
      |   $C546/50502      LED-Routinen des Controller-Programms
      |   $C56A/50538      JOB $9c: SIDE_DV
      |   $C589/50569      JOB $9e: BUFMOVE_DV
      |   $C5AC/50604      JOB $a2: TRKWRT_DV
      |   $C600/50688      Cachepuffer auf Diskette schreiben
      |   $C6D7/50903      JOBs $92, $a8: DISKIN_DV, PSEEK_DV
      |   $C700/50944      JOB $a6: SP_WRITE
      |   $C800/51200      JOB $a4: SP_READ
      |   $C900/51456      JOBs $80, $90: READ_DV, WRITE_DV
      |   $C9E1/51681      Job $a0: WRTVER_DV
      |   $CA00/51712      Spur mit Cachedaten vergleichen
      |   $CADC/51932      Verify-Error ausgeben
      |   $CAE4/51940      JOB $b8: SEEKPHD_DV
      |   $CB0F/51983      JOB $c0: RESTORE_DV
      |   $CB26/52006      JOBs $d0, $e0: JUMPC_DV, EXBUF_DV: Programm im Jobpuffer ausfuehren
      |   $CB35/52021      JOB $f0: FORMATDK_DV
      |   $CB76/52086      JOB $b6: DETWP_DV
      |   $CB85/52101      Job-Fehlermeldungen
      |   $CB8D/52109      Prueft, ob Sektor in Cachepuffer passt, Cachezeiger setzen
      |   $CB9F/52127      Timer setzen und starten
      |   $CBB1/52145      Laufwerksmotor ein-/ausschalten
      |   $CBC3/52163      Drive LED ein-/ausschalten
      |   $CBD5/52181      Warten ... .  .   .zzz . .z ..
      |   $CBEC/52204      Auf Controller-Ready warten
      |   $CBF4/52212      Kommandobyte in Controller schreiben
      |   $CD00/52480      Blockheader lesen
      |   $CD3F/52543      Controller-Status pruefen
      |   $CD63/52579      Wenn der Motor aus war, Motor einschalten und Verzoegerungszeit einstellen
      |   $CD7B/52603      Anlaufvorgang ueberwachen
      |   $CDBC/52668      Abfragen, ob Diskette eingelegt ist
      |   $CDCC/52684      Jobauftrag beenden, alle Jobs nochmal pruefen
      |   $CDE2/52706      Ruecksprung von Jobroutine, den selben Job nochmal pruefen
      |   $CE00/52736      Hauptsteuerroutine des Controllers
      |   $CE71/52849      Schrittmotor ansteuern
      |   $CEA4/52900      Daten zwischen Cache und Puffer transferieren
      |   $CEDC/52956      JTRANS_TS: logisches in physikalisches Format umwandeln
      |   $CF51/53073      Schreiben/Lesen mit Cache-Daten
      |   $CFA6/53158      Blockheader lesen
      |   $CFB7/53175      Copy-Zeiger auf Cachepuffer-Anfang setzen
      |   $CFC0/53184      Seite auswaehlen
      |   $CFD1/53201      Controller initialisieren
      |   $CFE3/53219      Precompensation ein/ausschalten
      |   $D00D/53261      Daten vom Puffer in den Cache kopieren
      |   $D549/54601      Daten vom Cache in den Puffer kopieren
      |   $DA63/55907      CRC-Pruefsumme des Blockheaders testen
      |   $DAFD/56061      IRQ-Routine
      |   $DBC7/56263      Patches
      |   $FF00/65280      Sprungvektoren
      |   $FF75/65397      Tabelle der DOS-Funktionen
      |
      +------------------------------------------------------------------------