DeviceList     EQU 350
TrackTask      EQU 302
TrackPort      EQU 36
SPReg          EQU 54
RückAdresse    EQU 70
IDNestCnt      EQU 294
PortStatus     EQU 34
CMD_READ       EQU 2
FindName       EQU -276
Wait           EQU -318
AllocMem       EQU -198
FreeMem        EQU -210

Req1           EQU $01                   ;MEMF_PUBLIC
Req2           EQU $03
TrackSize      EQU $1604                 ;aantal bytes per track

ReadError      EQU 21
NoDisk         EQU 29
NoSync         EQU 21

               lea $fc0000,a0
               cmp.l #$2033332E,$1c(a0)
               bne \Fehler4
               cmp.l #$31393220,$20(a0)
               bne \Fehler4
               move.l $4,a6
               bsr Disable
               move.l #Ende-Anfang,d0
               move.l #Req1,d1
               jsr AllocMem(a6)
               move.l d0,a1
               move.l a1,a4              ;geheugenadres saven
               move.l d0,d4
               beq \Fehler1
               lea TrackName(pc),a1
               lea DeviceList(a6),a0
               jsr FindName(a6)
               tst.l d0
               beq \Fehler3
               move.l d0,a5

               lea MyTask(pc),a0
               lea Anfang(pc),a1
               suba.l a1,a0
               adda.l a0,a4              ;adres van MeinTask
               clr.l d3
\l3:           move.l TrackPort(a5,d3),d0
               beq \l5
               move.l d0,a3
               move.l #TrackSize,d0
               move.l #Req2,d1
               jsr AllocMem(a6)
               lea TrackSpeicher1(pc),a0
               lea (a0,d3),a0            ;trackgeheugen voor drive
               move.l d0,(a0)
               beq \Fehler2
\l1:           btst #0,PortStatus(a3)    ;wachten tot Task de Wait-status heeft
               bne \l1
               move.l #1800,$2c(a3)      ;stappenmotor versnellen
               move.l #1,$30(a3)         ;geen wachttijd na positioneren
               lea TrackTask+SPReg(a3),a2
               move.l (a2),a1
               move.l a4,RückAdresse(a1)
\l5:           addq.l #4,d3
               cmpi.w #16,d3
               bcs \l3

               move.l #Ende-Anfang,d0
               lea Anfang(pc),a0
               move.l d4,a1
\l4:           move.b (a0)+,(a1)+        ;data kopieren
               subq.l #1,d0
               bne \l4
               bsr blink
\Fehler1:
               bsr Enable
\Fehler4:      clr.l d0
               rts
\Fehler2:      subq.l #4,d3
               bcs \Fehler3
               lea TrackSpeicher1(pc),a0
               lea (a0,d3),a0
               move.l (a0),a1
               move.l #TrackSize,d0
               jsr FreeMem(a6)
               bra \Fehler2
\Fehler3:      move.l #Ende-Anfang,d0
               move.l a4,a1
               jsr FreeMem(a6)
               bra \Fehler1

Blink:         move.l D0,-(a7)
               move.l #$20000,d0
\l1:           move.w d0,$dff180
               sub.l #1,d0
               bne \l1
               move.l (a7)+,D0
               rts

Anfang:
Disable:       move.w #$4000,$dff09a
               move.l a6,-(a7)
               move.l $4,a6
               add.b #1,IDNestCnt(a6)
               move.l (a7)+,a6
               rts
Enable:        move.l a6,-(a7)
               move.l $4,a6
               sub.b #1,IDNestCnt(a6)
               bge \l1
               move.w #$c000,$dff09a
\l1:           move.l (a7)+,a6
               rts

DerTask:       MOVEA.L 8(A7),A6
               MOVEA.L 4(A7),A3
               LEA $12E(A3),A0
               MOVE.L A0,$10(A3)
               JSR $FE9960
LFEAE64:       BSR.S LFEAE7A
               MOVE.L #$300,D0
               MOVE.L A6,-(A7)
               MOVEA.L $34(A6),A6
               JSR Wait(A6)
MyTask:        MOVEA.L (A7)+,A6
               BRA.S LFEAE64
LFEAE7A:       BSET #0,$22(A3)
               BNE NoMessage
LFEAE84:       MOVEA.L A3,A0
               MOVE.L A6,-(A7)
               MOVEA.L $34(A6),A6
               JSR -$174(A6)
               MOVEA.L (A7)+,A6
               TST.L D0
               BEQ LFEAF3E
               MOVEA.L D0,A2
               BCLR #3,$40(A3)
               BEQ LFEAF1E
               MOVEA.L $52(A3),A0
               BCLR #0,2(A0)
               BEQ LFEAEBA
               MOVE.L A0,$4E(A3)
               JSR $FEA958
LFEAEBA:       MOVEA.L $52(A3),A0
               MOVEQ #-1,D0
               MOVE.W D0,0(A0)
               MOVE.W D0,$4C(A3)
               MOVEQ #0,D0
               JSR $FEA462
               MOVEA.L A6,A0
               MOVEA.L $34(A0),A6
               ADDQ.B #1,$127(A6)
               MOVEA.L A0,A6
               TST.W $24(A3)
               BNE LFEAF12
               MOVEQ #0,D0
               MOVE.B $43(A3),D0
               MOVE.L A6,-(A7)
               MOVEA.L $3C(A6),A6
               JSR -$C(A6)
               MOVEA.L (A7)+,A6
               LEA $24(A6),A0
               MOVEQ #0,D0
               MOVE.B $43(A3),D0
               LSL.L #2,D0
               ADDA.L D0,A0
               CLR.L (A0)
               SUBA.L A1,A1
               MOVE.L A6,-(A7)
               MOVEA.L $34(A6),A6
               JSR -$120(A6)
               MOVEA.L (A7)+,A6
LFEAF12:       MOVE.L A6,-(A7)
               MOVEA.L $34(A6),A6
               JSR -$8A(A6)
               MOVEA.L (A7)+,A6
LFEAF1E:       MOVEA.L A2,A1
               LEA $86(A3),A0
               CMPA.L A0,A2
               BNE.S LFEAF30
               JSR $FE9960
               BRA LFEAE84
LFEAF30:       BSET #1,$22(A3)
               bsr Schritt1
               BRA LFEAE84
LFEAF3E:       BCLR #1,$22(A3)
               BCLR #0,$22(A3)
NoMessage:     RTS

Schritt1:      MOVE.L A2,-(A7)
               MOVEA.L A1,A2
               ANDI.B #-6,$40(A3)
               jsr $FE998C
               MOVEA.L A2,A1
               MOVE.W $1C(A2),D0
               cmp.b #CMD_READ,d0
               beq Schritt2
               BTST #$F,D0
               BEQ.S LFEA052
               BSET #2,$40(A3)
               MOVE.L $126(A3),D1
               CMP.L $30(A2),D1
               BLS.S LFEA052
               MOVE.B #$1D,$1F(A2)
               JSR $FEA1B0
               BRA.S LFEA066
LFEA052:       MOVEQ #0,D1
               MOVE.B D0,D1
               LSL.W #2,D1
               LEA $FEA300,A0
               MOVEA.L 0(A0,D1.W),A0
               JSR (A0)
LadenEnde:
               JSR $FE998C
LFEA066:       MOVEA.L (A7)+,A2
               RTS

Schritt2:      bsr Blink
               bsr Schritt3
               bra LadenEnde

Schritt3:
 MOVEM.L A2-A4,-(A7)
 MOVEA.L $18(A1),A3
 MOVEA.L A1,A2
 MOVE.L A2,$44(A3)
 MOVE.L #0,$20(A2)
 MOVE.L $28(A2),$56(A3)
 MOVE.L $2C(A2),D0
 JSR $FEA182
 TST.L D0
 BMI LFEA92A
 MOVE.W D0,$4A(A3)
 MOVE.B D1,$49(A3)
 MOVE.L $2C(A2),D0
 ADD.L $24(A2),D0
 JSR $FEA182
 TST.L D0
 BMI LFEA92A
 BTST #2,$40(A3)
 BEQ.S LFEA78E
 MOVE.L $34(A2),$5A(A3)
 BEQ.S LFEA78E
 BSET #0,$40(A3)
LFEA78E:BTST #1,$40(A3)
 BEQ.S LFEA7A0
 MOVE.B #$1D,$1F(A2)
 BRA LFEA920
LFEA7A0:MOVE.W $4A(A3),D0
 JSR $FEA93C
 MOVE.L A0,$4E(A3)
 BNE.S LFEA804
 jsr $FEA952
 MOVEA.L A0,A2
 MOVE.L A2,$4E(A3)
LFEA7B8:BTST #0,2(A2)                    ;spoor in buffer
 BEQ.S LFEA7D4                           ;nee, lezen
 JSR $FEA958
 TST.L D0
 BEQ.S LFEA7D4
 MOVEA.L $44(A3),A1
 MOVE.B D0,$1F(A1)
 BRA LFEA920
LFEA7D4:MOVE.W $4A(A3),0(A2)
 BCLR #0,2(A2)
 CLR.B $42(A3)
 bsr lesen                               ;spoor in buffer lezen
 MOVE.B 3(A2),D0
 CMPI.B #$B,D0
 BCS.S LFEA804
 MOVE.W #-1,0(A2)
 MOVEA.L $44(A3),A1
 MOVE.B D0,$1F(A1)
 BRA LFEA920
LFEA804:MOVEA.L $44(A3),A2
 MOVE.W $1C(A2),D0
 MOVEA.L $4E(A3),A0
 CMPI.B #3,D0
 BNE LFEA890
 BSET #0,2(A0)
 MOVEQ #0,D0
 MOVE.B $49(A3),D0
 SUB.B 3(A0),D0
 BPL.S LFEA82E
 ADDI.B #$B,D0
LFEA82E:MULU #$440,D0
 LEA $680(A0),A4
 ADDA.L D0,A4
 BTST #0,$40(A3)
 BEQ.S LFEA866
 MOVEA.L $5A(A3),A0
 MOVE.L #$10,D0
 LEA $10(A4),A1
 JSR $FEAB4A
 LEA 8(A4),A0
 MOVE.W #$28,D1
 JSR $FEADA4
 LEA $30(A4),A0
 JSR $FEAD46
LFEA866:MOVEA.L $56(A3),A0
 MOVE.L #$200,D0
 LEA $40(A4),A1
 JSR $FEAB4A
 LEA $40(A4),A0
 MOVE.W #$400,D1
 JSR $FEADA4
 LEA $38(A4),A0
 JSR $FEAD46
 BRA LFEA8D6
LFEA890:MOVEQ #0,D0
 BTST #0,$40(A3)                         ;SecLabel gezet?
 BEQ.S LFEA8C4                           ;nee
 MOVE.B $49(A3),D0                       ;sektornummer naar D0
 SUB.B 3(A0),D0
 BPL.S LFEA8A0
 ADDI.B #$B,D0
LFEA8A0:MULU #$440,D0
 LEA $680(A0),A4
 ADDA.L D0,A4
 LEA $10(A4),A1
 MOVEA.L $5A(A3),A0
 MOVE.L #$10,D0
 JSR $FEACB2
LFEA8C4:
 clr.l d0
 MOVE.B $49(A3),D0                       ;sektornummer naar D0
 MOVEA.L $56(A3),A1                      ;doeladres
 lea TrackSpeicher1(pc),a0
 clr.l d1
 move.b $43(a3),d1
 lsl.w #2,d1
 adda.l d1,a0
 movea.l (a0),a0
 mulu #$200,d0
 adda.l d0,a0
 move.w #$200,d0
 bsr CopyBlock
LFEA8D6:MOVE.L #$200,D1
 ADD.L D1,$56(A3)
 MOVE.L $20(A2),D0
 ADD.L D1,D0
 MOVE.L D0,$20(A2)
 BTST #0,$40(A3)
 BEQ.S LFEA8FA
 ADDI.L #$10,$5A(A3)
LFEA8FA:CMP.L $24(A2),D0
 BCC.S LFEA920
 MOVEA.L $4E(A3),A2
 ADDQ.B #1,$49(A3)
 CMPI.B #$B,$49(A3)
 BLT LFEA804
 MOVE.B #0,$49(A3)
 ADDQ.W #1,$4A(A3)
 BRA LFEA7B8
LFEA920:MOVEA.L $44(A3),A1
 JSR $FEA1B0
 BRA.S LFEA936
LFEA92A:MOVEA.L $44(A3),A1
 MOVE.B #-4,$1F(A1)
 BRA.S LFEA920
LFEA936:MOVEM.L (A7)+,A2-A4
 RTS
lesen:         MOVEM.L A2,-(A7)
               MOVEA.L $4E(A3),A2
               MOVEQ #1,D0
               jsr $FEA462               ;motor aan
LFEA9AC:       MOVEQ #0,D0
               MOVE.W $4A(A3),D0
               jsr $FEA3DA               ;kop positioneren
LFEA9B6:       LEA 1664(A2),A0
               lea TrackSpeicher1(pc),a1
               clr.l d0
               move.b $43(a3),d0
               lsl.w #2,d0
               adda.l d0,a1
               move.l (a1),a1
               bsr tracklesen
               move.w FirstBlock(pc),D0
               MOVE.B d0,3(A2)
               lea ErrorFlag(pc),a0
               tst.w (a0)
               beq \Ende                 ;geen fout
\Error:        MOVE.B 1(a0),3(A2)        ;fout overnemen
               ADDQ.B #1,$42(A3)
               MOVE.B $42(A3),D0
               CMP.B $34(A3),D0
               BGT.S \Ende               ;einde bij teveel fouten
               ANDI.B #3,D0
               BNE.S LFEA9B6
               MOVE.W #-1,$4C(A3)
               BRA.S LFEA9AC
\Ende:         MOVEM.L (A7)+,A2
               RTS

;Track lezen en decoderen
;>= A1 = pointer naar buffer voor gedecodeerde data
;>= A0 = pointer naar buffer voor gecodeerde data

Tracklesen:
               MOVEM.L D2-D4/a4-a5,-(A7)
               move.l a0,a5
               move.l a1,a4
               lea ErrorFlag(pc),a1
               clr.w (a1)
               lea DecodeAnz(pc),a1
               move.w #$080,(a1)         ;aantal langwoorden te decoderen
               lea $40(a5),a0
               lea DecodeAdr(pc),a1
               move.l a0,(a1)            ;datagebied van 1. block
               adda.l #$400,a0
               lea FTestAdr(pc),a1
               move.l a0,(a1)            ;adres van volgende block
               jsr $FEADDC               ;drive aanmelden
               MOVE.B $41(A3),$BFD100
               BTST #2,$BFE001           ;diskette in drive
               BNE.S \FL3                ;Ok
               lea ErrorFlag(pc),a1
               move.w #NoDisk,(a1)       ;geen diskette in drive
               BRA   \FL5                ;einde

\FL3:          bsr Disable
               move.l a6,-(a7)
               MOVEA.L A5,A6             ;trackbuffer
               move.l #$aaaaaaaa,(a6)+
               move.w #$4489,(a6)+       ;eerste Sync invoeren
               bsr suchen
               tst.l d0
               bpl \FL8
               lea ErrorFlag(pc),a1
               move.w #NoSync,(a1)       ;geen Sync
               bra \FL9                  ;einde
\FL8:          bsr FLösch                ;trackbuffer klaarmaken
               clr.l d2
               move.w BytesVLücke(pc),d2 ;aantal bytes voor `gap'
               tst.l d2
               beq \FL1                  ;geen bytes voor `gap'
               lea BlockAdr(pc),a1
               clr.w (a1)                ;offset in het block
               bsr Anzlesen              ;bytes lezen
               clr.l d0
               move.w BytesVLücke(pc),d0
               move.l a5,a6
               adda.l d0,a6              ;pointer naar volgende buffer
               move.l #$aaaaaaaa,(a6)+
               move.w #$4489,(a6)+       ;eerste Sync invoeren
\FL1:          move.w BytesNLücke(pc),d2
               tst.l d2
               beq \FL2
               lea BlockAdr(pc),a1
               clr.w (a1)
               bsr Anzlesen
               bsr letzterblock
\FL2:          move.l #$aaaaaaaa,$2ec0(a5) ;`gap' na de data aanmaken
               BTST #2,$BFE001           ;diskette in drive?
               bne   \FL9                ;Ok, diskette in drive
               lea ErrorFlag(pc),a1
               move.w #NoDisk,(a1)
\FL9:          move.l (a7)+,a6
\FL5:          bsr Enable
               jsr $FEAE42               ;drive afmelden
               MOVEM.L (A7)+,D2-D4/a4-a5
               RTS

;trackbuffer voorbereiden (blockbegin wissen)
;>= A5 = pointer naar trackbuffer

FLösch:        move.l a5,a0
               move.w #10,d1
               clr.l d0
\L1:           move.l d0,$440(a0)
               adda.l #$440,a0
               dbf d1,\L1
               lea BlockMeldung(pc),a0
               move.w #10,d1
\L2:           clr.w (a0)+
               dbf d1,\L2
               rts

;ingesteld aantal bytes lezen
;>= A6 = pointer naar doel
;>= D2 = aantal te lezen bytes

Anzlesen:
               bsr install
               MOVE.W D2,D0
               LSR.W #1,D0
               ORI.W #$8000,D0
               add.w #1,d0
               MOVE.W D0,36(A1)
               MOVE.W D0,36(A1)
               bsr decode
               LEA $DFF000,A1
               MOVE.W #$4000,$24(A1)
               rts

;voorbereiding tot lezen
;>= A6 pointer naar trackbuffer

install:       LEA $DFF000,A1
               move.w #$4000,$24(a1)     ;Disk-Len terug zetten
               move.w #$8400,$9e(a1)     ;Disk Sync inschakelen
               move.w #$4489,$7e(a1)     ;SYNC-markering
               MOVE.L A6,$20(A1)         ;buffer doorgeven
               move.w #$0002,$dff09c
               rts

;langwoord coderen en invoeren in buffer
;>= D0 = langwoord
;>= A0 = pointer naar buffer

CodeLWort:     MOVEM.L D2-D3,-(A7)
               MOVE.L D0,D3
               LSR.L #1,D0
               BSR \CH1
               MOVE.L D3,D0
               BSR \CH1
               BSR Randsetzen
               MOVEM.L (A7)+,D2-D3
               RTS
\CH1:          ANDI.L #$55555555,D0
               MOVE.L D0,D2
               EORI.L #$55555555,D2
               MOVE.L D2,D1
               LSL.L #1,D2
               LSR.L #1,D1
               BSET #$1F,D1
               AND.L D2,D1
               OR.L D1,D0
               BTST #0,-1(A0)
               BEQ.S \CH2
               BCLR #$1F,D0
\CH2:          MOVE.L D0,(A0)+
               RTS
;randen juist plaatsen

Randsetzen:    MOVE.B (A0),D0
               BTST #0,-1(A0)
               BNE.S \CH4
               BTST #6,D0
               BNE.S \CH6
               BSET #7,D0
               BRA.S \CH5
\CH4:          BCLR #7,D0
\CH5:          MOVE.B D0,(A0)
\CH6:          RTS

;checksum van data bepalen
;>= D1 = aantal bytes (moet altijd door vier deelbaar zijn)
;>= A0 = pointer naar buffer
;=> D0 = checksum

PrüfSumme:     MOVE.L D2,-(A7)
               LSR.W #2,D1
               SUBQ.W #1,D1
               MOVEQ #0,D0
\PS1:          MOVE.L (A0)+,D2
               EOR.L D2,D0
               DBRA D1,\PS1
               ANDI.L #$55555555,D0
               MOVE.L (A7)+,D2
               RTS

;blockheader decoderen
;>= A0 is pointer naar header
;=> D0 = header

Header:        move.l (a0)+,D0
               move.l (a0)+,D1
               andi.l #$55555555,d0
               andi.l #$55555555,d1
               lsl.l #1,D0
               or.l D1,D0
               rts

;zoeken naar het eerste niet vernielde block
;=> A6 = pointer naar trackbuffer
;=> D0 = nul: block gevonden
;=> BytesVLücke = aantal bytes voor de `gap'
;=> BytesNLücke = aantal bytes na de `gap'

suchen:        
               movem.l d2-d4/a2,-(a7)
               move.w #11,d2             ;aantal toegestane fouten
\SU1:          bsr install
               move.w #$8024,d0          ;$24 woorden lezen
               MOVE.W D0,$dff024
               MOVE.W D0,$dff024
               bsr Blockready            ;wachten op block ready
               tst.l d0                  ;fout, dan D0 = -1
               bmi \SUError

               lea 8(a5),a0              ;pointer naar blockheader
               moveq #$28,d1             ;langwoordaantal
               bsr Prüfsumme             ;header checksum
               move.l d0,d3              ;checksum saven
               lea 48(a5),a0             ;*checksum
               bsr Header                ;checksum uit de header halen
               cmp.l d0,d3               ;checksums vergelijken
               bne \SUNeu
               lea 8(a5),a0
               bsr Header                ;header decoderen
               move.w d0,d3              ;header naar D3
               lsr.w #8,d3
               andi.w #$00ff,d3          ;sektornummer isoleeren
               addi.w #1,d3              ;sektornummer verhogen
               cmp.w #$000a,d3           ;nummer > 10?
               bls \SU2                  ;nee, OK
               clr.w d3                  ;nummer = 0
\SU2:          lea SektNum(pc),a2
               move.w d3,(a2)            ;nummer saven
               lea FirstBlock(pc),a2
               move.w d3,(a2)            ;nummer eerste block

               move.w d0,d3              ;header
               andi.w #$ff,d3            ;sektoren tot gap
               cmp.b #$0c,d3             ;header OK?
               bcs.s \SUok
\SUNeu:        dbf d2,\SU1
               bra \SUError
\SUok:

               sub.w #1,d3               ;aantal blokken tot gap
               move.w d3,d2
               move.w #$000b,d4
               sub.b d2,d4               ;aantal blokken na de gap
               mulu #$440,d3             ;aantal bytes tot gap
               mulu #$440,d4             ;aantal bytes na de gap
               clr.l d0
               lea BytesVLücke(pc),a2
               move.w d3,(a2)
               lea BytesNLücke(pc),a2
               move.w d4,(a2)
               lea SektBL(pc),a2
               move.w #$0b,(a2)          ;sektoren voor de gap na het laden
               bra \SUEnd
\SUError:      move.l #-1,d0
               lea ErrorFlag(pc),a2
               move.w #ReadError,(a2)
\SUEnd:        movem.l (a7)+,d2-d4/a2
               rts

Blockready:    clr.l d0                  ;error-vlag wissen
               move.l #$20000,d1
               move.w #$0002,$dff09c     ;DiskInt wissen
\B1:           MOVE.W $DFF01E,D0
               BTST #1,D0
               bne.s \B2
               sub.l #1,d1
               bne \B1
               move.l #-1,d0             ;fout opgetreden
\B2:           RTS


;bytes decoderen, tot block gelezen

decode:
               movem.l d2-d4/a2-a3,-(a7)
               clr.l d3
               move.l a3,d4                  ;Laufwerks-Port retten
               move.w BlockAdr(pc),d3        ;offset in het block
               move.l FTestAdr(pc),a0        ;adres voor testen of
                                             ;block al geladen is
               move.l DecodeAdr(pc),a2       ;adres, waarbij wordt gedecodeerd
               move.w DecodeAnz(pc),d2       ;aantal voor decodering

\DC1:          MOVE.W $DFF01E,D0
               BTST #1,D0                ;gebied al gelezen
               bne  \DCEnd               ;ja, einde
               tst.l (a0)                ;TestAdr
               beq \DC1                  ;wachten tot block gelezen

               movem.l a0-a1,-(a7)       ;register redden
               lea -$40(a2),a1           ;* blockbegin
               move.l d4,a3              ;* drive-port
               bsr BlockCheck            ;block checken
               movem.l (a7)+,a0-a1       ;register terughalen
               move.w SektNum(pc),d0
               mulu #$200,d0
               move.l a4,a1              ;basisadres voor `doel'data
               add.l d0,a1               ;adres van block
\DC2:
               MOVE.W $DFF01E,D0
               BTST #1,D0
               bne.s \DCEnd              ;gebied al gelezen

               move.l (a2),D0
               move.l $200(a2),D1
               adda.l #4,a2
               andi.l #$55555555,d0
               andi.l #$55555555,d1
               lsl.l #1,D0
               or.l D1,D0
               move.l d0,(a1,d3)         ;langwoord invoeren
               addq.w #4,d3
               subq.w #1,D2              ;decodeer aantal
               bne \DC2
               adda.l #$240,a2           ;verhoog adres
               adda.l #$440,a0           ;TestAdr
               move.l #$080,D2           ;decodeer aantal
               clr.w d3                  ;offset op nul
               lea SektNum(pc),a3
               add.w #1,(a3)             ;sektornummer verhogen
               cmp.w #$0b,(a3)           ;nummer > 10?
               bcs \DC3                  ;nee, OK
               clr.w (a3)                ;nummer = 0
\DC3:          bra \DC1

\DCEnd:
               lea BlockAdr(pc),a3
               move.w d3,(a3)
               lea DecodeAdr(pc),a3
               move.l a2,(a3)
               lea FTestAdr(pc),a3
               move.l a0,(a3)
               lea DecodeAnz(pc),a3
               move.w D2,(a3)

               movem.l (a7)+,d2-d4/a2-a3
               RTS

;laatste block decoderen

LetzterBlock:  
               movem.l d2-d3/a2,-(a7)

               move.w SektNum(pc),d0
               mulu #$200,d0
               move.l a4,a1              ;basisadres voor `doel'data
               add.l d0,a1               ;adres van het block
               clr.l d3
               move.l DecodeAdr(pc),a2
               move.w DecodeAnz(pc),d2
\LB1:          move.l (a2),D0
               move.l $200(a2),D1
               adda.l #4,a2
               andi.l #$55555555,d0
               andi.l #$55555555,d1
               lsl.l #1,D0
               or.l D1,D0
               move.l d0,(a1,d3)
               addq.w #$4,d3
               subq.w #1,D2               ;decodeer aantal
               bne \LB1
               movem.l (a7)+,d2-d3/a2
               RTS

;block controleren op fouten
;A1 = pointer naar blockbegin

BlockCheck:
               movem.l d2-d3/a2,-(a7)
               clr.l d3
               move.w SektNum(pc),d3
               lsl.w #1,d3               ;sektornummer => offset
               lea BlockMeldung(pc),a0
               move.w (a0,d3),d0         ;invoer halen
               tst.w d0                  ;al gecontroleerd?
               bne \CBEnd2               ;ja, einde

               lea 64(a1),a0
               move.w #$400,d1
               bsr Prüfsumme             ;checksum van datablock
               move.l d0,d2              ;checksum saven
               lea 56(a1),a0             ;pointer naar checksum van data
               bsr Header                ;checksum decoderen
               cmp.l d0,d2
               bne \DatenFalsch

               lea 8(a1),a0
               bsr Header                ;header decoderen
               move.w d0,d2              ;onderste woord saven
               lsr.w #8,d2               ;sektornummer naar d2
               cmp.b SektNum+1(pc),d2    ;juiste sektor
               bne \FalscherSektor
               swap d0                   ;tracknummer naar D0
               cmp.b 77(a3),d0           ;juiste track?
               bne \FalscherTrack
               andi.l #$ff00,d0
               cmp.w #$ff00,d0
               bne \KeinDosTrack
               lea 8(a1),a0
               moveq #$28,d1             ;aantal langwoorden
               bsr Prüfsumme             ;checksum van header
               move.l d0,d2              ;checksum saven
               lea 48(a1),a0             ;*checksum
               bsr Header                ;checksum uit header halen
               cmp.l d0,d2               ;checksum vergelijken
               bne \HeaderFalsch
               move.w #$ffff,d0
\CBEnd1:       lea BlockMeldung(pc),a0
               move.w d0,(a0,d3)
               btst #0,-1(a1)
               beq \CB1
               move.l #$2aaaaaaa,(a1)
               bra \CB2
\CB1:          move.l #$aaaaaaaa,(a1)
\CB2:          move.l #$44894489,4(a1)
               move.w #$ff00,d0          ;header opnieuw aanmaken
               move.b 77(a3),d0
               swap d0
               move.b SektNum+1(pc),d0
               lsl.w #8,d0
               move.b SektBL+1(pc),d0
               lea 8(a1),a0
               bsr CodeLWort             ;header invoeren
               lea 8(a1),a0
               moveq #$28,d1             ;aantal langwoorden
               bsr Prüfsumme             ;checksum van header
               lea 48(a1),a0             ;*checksum
               bsr CodeLWort             ;checksum invoeren
               lea SektBL(pc),a2
               subq.w #1,(a2)
\CBEnd2:       movem.l (a7)+,d2-d3/a2
               rts

\FalscherSektor: move.w #$0017,d0
                 bra \Flagsetzen
\FalscherTrack: move.w #$0017,d0
                 bra \Flagsetzen
\KeinDosTrack:  move.w #$0017,d0
                 bra \Flagsetzen
\HeaderFalsch:  move.w #$001b,d0
                 bra \Flagsetzen
\DatenFalsch:   move.w #$0019,d0
\Flagsetzen:    lea ErrorFlag(pc),a2
                move.w d0,(a2)
                bra \CBEnd1

;datablock coderen
;>= D0 = lengte v/d oorsprong (bron)
;>= A0 = pointer naar oorsprong
;>= A1 = pointer naar doel

CopyBlock:
               move.l a2,-(a7)
               move.l a0,a2
               LSL.W #2,D0
               ORI.W #8,D0
               lea $dff000,a0
               bsr BlitWart
               bsr BlitterCode
               move.l (a7)+,a2
               RTS

;A0 = $dff000
;D0 = lengte v/d oorsprong
;D1 = oorsprong
;A5 = doel

BlitterCode:
               bsr Modulu                ;Modulu zetten
               MOVE.L a2,$50(A0)         ;Source
               MOVE.L a1,$54(A0)         ;Dest
               MOVE.W #$09F0,$40(A0)
               MOVE.W #0,$42(A0)
               bsr StartBlit
               rts

;starten van blitter en wachten op einde

StartBlit:
               MOVE.W d0,$dff058
BlitWart:      btst #14,$dff002
               bne.s BlitWart
               rts

;Modulu gereed maken voor codering
;>= A0 = $dff000
Modulu:
               movem.l d0/a1,-(a7)
               MOVEQ #0,D0
               LEA $44(A0),A1
               MOVE.L #-1,(A1)
               LEA $62(A0),A1
               MOVE.L D0,(A1)+
               MOVE.W D0,(A1)+
               movem.l (a7)+,d0/a1
               rts



BytesVLücke:   dc.w 0
BytesNLücke:   dc.w 0
ErrorFlag:     dc.w 0
DecodeAnz:     dc.w 0
DecodeAdr:     dc.l 0
FTestAdr:      dc.l 0
BlockAdr:      dc.w 0
SektNum:       dc.w 0
FirstBlock:    dc.w 0
SektBL:        dc.w 0
TrackSpeicher1:dc.l 0
TrackSpeicher2:dc.l 0
TrackSpeicher3:dc.l 0
TrackSpeicher4:dc.l 0

BlockMeldung:  ds.w 11

TrackName:     dc.b 'trackdisk.device',0,0
Ende:
               END