Th. Tempelmann format

From Software Archive
Jump to navigation Jump to search

As found on Wörter Rennen mit System

There are 4 sector on track 18 in regular format on the disk:

Sector 0, 1, 8 and 11.

The rest of the tracks were written in speed 0. Each of these track contains a single additional regular sector header that was written with speed 3.

Initial code loaded to C64

The first file is linked to t18 s8 that loads auto start code to the C64 from $02d1 to $03cb. Execution entry point is at $0334.

.C:0334  A9 0B       LDA #$0B
.C:0336  20 B0 03    JSR $03B0
.C:0339  A9 2D       LDA #$2D  // "-" -> Send Memory Execute at $07b0 to floppy
.C:033b  20 A8 FF    JSR $FFA8 // Output byte to serial
.C:033e  A9 45       LDA #$45  // "E"
.C:0340  20 A8 FF    JSR $FFA8 // Output byte to serial
.C:0343  A9 B0       LDA #$B0  // Address $07b0
.C:0345  20 A8 FF    JSR $FFA8 // Output byte to serial
.C:0348  A9 07       LDA #$07  //
.C:034a  20 A8 FF    JSR $FFA8 // Output byte to serial
.C:034d  20 FE ED    JSR $EDFE  // Send UNLISTEN
.C:0350  A2 FF       LDX #$FF
.C:0352  AD 00 DD    LDA $DD00
.C:0355  A0 10       LDY #$10
.C:0357  CA          DEX
.C:0358  D0 FD       BNE $0357
.C:035a  88          DEY
.C:035b  D0 FA       BNE $0357
.C:035d  A9 03       LDA #$03
.C:035f  8D 00 DD    STA $DD00
.C:0362  AD 00 DD    LDA $DD00
.C:0365  CD 00 DD    CMP $DD00
.C:0368  F0 FB       BEQ $0365
.C:036a  20 80 03    JSR $0380
.C:036d  85 D1       STA $D1
.C:036f  20 80 03    JSR $0380
.C:0372  85 D2       STA $D2
.C:0374  A0 00       LDY #$00
.C:0376  20 80 03    JSR $0380
.C:0379  91 D1       STA ($D1),Y
.C:037b  88          DEY
.C:037c  D0 F8       BNE $0376
.C:037e  F0 EA       BEQ $036A
.C:0380  78          SEI
.C:0381  A9 27       LDA #$27
.C:0383  8D 00 DD    STA $DD00
.C:0386  2C 00 DD    BIT $DD00
.C:0389  50 FB       BVC $0386
.C:038b  A9 03       LDA #$03
.C:038d  8D 00 DD    STA $DD00
.C:0390  A2 08       LDX #$08
.C:0392  CA          DEX
.C:0393  D0 FD       BNE $0392
.C:0395  A2 04       LDX #$04
.C:0397  AD 00 DD    LDA $DD00
.C:039a  0A          ASL A
.C:039b  08          PHP
.C:039c  0A          ASL A
.C:039d  26 2D       ROL $2D
.C:039f  28          PLP
.C:03a0  26 2D       ROL $2D
.C:03a2  CA          DEX
.C:03a3  D0 F2       BNE $0397
.C:03a5  A9 17       LDA #$17
.C:03a7  8D 00 DD    STA $DD00
.C:03aa  EA          NOP
.C:03ab  EA          NOP
.C:03ac  EA          NOP
.C:03ad  A5 2D       LDA $2D
.C:03af  60          RTS
.C:03b0  8D 11 D0    STA $D011
.C:03b3  A9 08       LDA #$08
.C:03b5  20 0C ED    JSR $ED0C
.C:03b8  A9 6F       LDA #$6F
.C:03ba  20 B9 ED    JSR $EDB9
.C:03bd  A9 4D       LDA #$4D
.C:03bf  4C A8 FF    JMP $FFA8
.C:03c2  4C FE ED    JMP $EDFE
Load Translation Table

The floppy has loaded automatically previously t18 s0 to the buffer at $0700. Aside from the disk title the sector also contains code at $0700 and $07b0.

.8:0700  A5 04       LDA $04   // $04 == #$E0
.8:0702  C9 E2       CMP #$E2  // is it #$E2?
.8:0704  F0 27       BEQ $072D // send command find sector
.8:0706  20 56 F5    JSR $F556 // wait for sync
.8:0709  50 FE       BVC $0709
.8:070b  B8          CLV
.8:070c  AD 01 1C    LDA $1C01 // check if first byte is #$6A
.8:070f  C9 6A       CMP #$6A
.8:0711  D0 F3       BNE $0706 // No? try next Sync
.8:0713  A2 64       LDX #$64  // We are at the first data (6A) sector we found after changing to track 2
.8:0715  50 FE       BVC $0715 // wait for byte from disk
.8:0717  B8          CLV
.8:0718  AD 01 1C    LDA $1C01 // read byte from disk
.8:071b  95 00       STA $00,X // read 156 bytes and put them to $64 to $ff
.8:071d  E8          INX
.8:071e  D0 F5       BNE $0715
.8:0720  55 64       EOR $64,X // run EOR checksum over all 156 bytes
.8:0722  E8          INX
.8:0723  E0 9C       CPX #$9C  // 156
.8:0725  D0 F9       BNE $0720
.8:0727  EA          NOP
.8:0728  29 7F       AND #$7F  // use lower 7 bits of checksum for error code, should be #$39
.8:072a  4C 69 F9    JMP $F969 // error entry disk controller -> user code execution continues in $078d
.8:072d  4C CA F6    JMP $F6CA // send command find sector

.. disk title data

.8:07b0  A9 02       LDA #$02    <- The C64 does start execution in the floppy here
.8:07b2  8D 78 02    STA $0278   // init some values for user file execute - number of file names
.8:07b5  A9 2A       LDA #$2A    
.8:07b7  8D 00 02    STA $0200
.8:07ba  A9 01       LDA #$01
.8:07bc  8D 74 02    STA $0274
.8:07bf  A9 00       LDA #$00
.8:07c1  85 7E       STA $7E     // last handled program
.8:07c3  4C AB E7    JMP $E7AB   // Execute USR file, loads t18 s11 into floppy at $0730 and executes it.

The upper routine loads t18 s11 to the floppy ram starting at $0730 to $07b5. Previously there was unused code space due to disk title space in t18 s0. Execution continues at $0730.

Check Track 3 Header / Load Translation Table / Create Sparse Table

From t18 s11

.8:0730  A2 03       LDX #$03  // Seek to track 3
.8:0732  86 0E       STX $0E
.8:0734  A9 00       LDA #$00  // Set sector 0 to look for
.8:0736  85 0F       STA $0F
.8:0738  A9 B0       LDA #$B0  // Set new job: find sector header
.8:073a  85 04       STA $04
.8:073c  A5 04       LDA $04
.8:073e  30 FC       BMI $073C // wait for result code
.8:0740  C9 01       CMP #$01  // 1?
.8:0742  F0 3A       BEQ $077E // OK, go on, otherwise lockup loop
.8:0744  EE FE 02    INC $02FE // 0 -> 1
.8:0747  AD FE 02    LDA $02FE // Lockup
.8:074a  D0 FB       BNE $0747 // Loop
.8:074c  A9 B0       LDA #$B0  // not used
.8:074e  85 04       STA $04   // not used
.8:0750  A5 04       LDA $04   // not used
.8:0752  30 FC       BMI $0750  // not used
.8:0754  C9 01       CMP #$01  // not used
.8:0756  F0 26       BEQ $077E  // not used
.8:0758  CE FE 02    DEC $02FE  // not used
.8:075b  AD FE 02    LDA $02FE  // not used
.8:075e  D0 FB       BNE $075B  // not used
.8:0760  CE FE 02    DEC $02FE  // not used
.8:0763  AD FE 02    LDA $02FE  // not used
.8:0766  D0 FB       BNE $0763  // not used
.8:0768  A9 B0       LDA #$B0  // not used
.8:076a  85 04       STA $04  // not used
.8:076c  A5 04       LDA $04  // not used
.8:076e  30 FC       BMI $076C  // not used
.8:0770  C9 01       CMP #$01  // not used
.8:0772  F0 0A       BEQ $077E  // not used
.8:0774  EE FE 02    INC $02FE  // not used
.8:0777  AD FE 02    LDA $02FE  // not used
.8:077a  D0 FB       BNE $0777  // not used
.8:077c  F0 BA       BEQ $0738  // not used
.8:077e  20 F5 07    JSR $07F5  // check if we are on track 3
.8:0781  A9 22       LDA #$22   // set buffer 4, set track 2
.8:0783  85 0E       STA $0E
.8:0785  A9 E0       LDA #$E0   // Job: motor on, seek track and execute code at $0700
.8:0787  85 04       STA $04    // The code at $0700 loads the forward translation table to $A4
.8:0789  A5 04       LDA $04
.8:078b  30 FC       BMI $0789  // wait for result
.8:078d  C9 39       CMP #$39   // was checksum result #$39 is good
.8:078f  D0 9F       BNE $0730  // if not, go to track 3 sector header find again
.8:0791  C6 31       DEC $31    // $31: #$07 -> #$06 this is our internal sector id for the next sector
.8:0793  78          SEI
.8:0794  A9 EE       LDA #$EE   // What does this do? Init PCR?
.8:0796  8D 0C 1C    STA $1C0C
.8:0799  EA          NOP
.8:079a  A2 00       LDX #$00
.8:079c  B4 64       LDY $64,X
.8:079e  8A          TXA
.8:079f  99 00 01    STA $0100,Y // [$100 + [$64 + X]] = X
.8:07a2  E8          INX         // this means, the loaded data at $64 are used as indices to a new sparse table at $0100.
.8:07a3  E0 40       CPX #$40    // bytes at these indexed positions are filled counting upwards. See table 1 and table 2.
.8:07a5  90 F5       BCC $079C   // The counter here that is also written to table 2 is the actual 6 bit byte value
.8:07a7  20 00 06    JSR $0600   // We have now our translation table, load first sector (id 6) to $0200
.8:07aa  B9 00 02    LDA $0200,Y // copy to $0300 and execute
.8:07ad  99 00 03    STA $0300,Y
.8:07b0  C8          INY
.8:07b1  D0 F7       BNE $07AA
.8:07b3  4C 00 03    JMP $0300

.. remaining bytes .. From t18 s0, loads a custom sector header

.8:07c6  20 56 F5    JSR $F556 // wait for sync
.8:07c9  50 FE       BVC $07C9 // wait for data byte
.8:07cb  B8          CLV
.8:07cc  AD 01 1C    LDA $1C01 // read data byte
.8:07cf  C9 73       CMP #$73  // #$73 is the code for a sector header
.8:07d1  D0 F3       BNE $07C6 // no? then try again
.8:07d3  50 FE       BVC $07D3 // wait for data byte
.8:07d5  B8          CLV
.8:07d6  AD 01 1C    LDA $1C01 // read a skip byte
.8:07d9  50 FE       BVC $07D9 // wait for data byte
.8:07db  B8          CLV
.8:07dc  AC 01 1C    LDY $1C01   // read data byte
.8:07df  B9 00 01    LDA $0100,Y // translate to 6 bit byte through lookup table
.8:07e2  C5 31       CMP $31     // $31 contains the wanted sector number (first one read is 6)
.8:07e4  D0 E0       BNE $07C6   // no? then next sector header
.8:07e6  20 03 06    JSR $0603   // Read sector data
.8:07e9  E8          INX         // with the correct checksum X is #$FF when $0603 returns
.8:07ea  D0 DA       BNE $07C6   // wrong checksum? try read again
.8:07ec  A5 31       LDA $31     // set next sector id +2 (e.g. 8)
.8:07ee  69 02       ADC #$02
.8:07f0  29 0F       AND #$0F
.8:07f2  85 31       STA $31
.8:07f4  60          RTS
.8:07f5  A5 22       LDA $22  // current track
.8:07f7  C9 03       CMP #$03 // are we on 3?
.8:07f9  D0 94       BNE $078F // repeat, set track 3, find header
.8:07fb  09 20       ORA #$20  //
.8:07fd  85 22       STA $22   // #$23 -> $22
.8:07ff  60          RTS

Sector id translation: Mark for header is after snyc #$73, then a skip byte follow, typically #$4d, then the header byte follows:

#$4A -> $31 = 0x00
#$4B -> $31 = 0x01
#$4D -> $31 = 0x02
#$4E -> $31 = 0x03
#$52 -> $31 = 0x04
#$53 -> $31 = 0x05
#$55 -> $31 = 0x06
#$56 -> $31 = 0x07
#$57 -> $31 = 0x08
#$59 -> $31 = 0x09
#$5A -> $31 = 0x0A
#$5B -> $31 = 0x0B
#$5D -> $31 = 0x0C
#$5E -> $31 = 0x0D
#$65 -> $31 = 0x0E
#$66 -> $31 = 0x0F

As one sees the same lookup is used as installed through table 1 in table 2.

Table 1 (Translation Table)

With the routine at $079a this table is translated to $0100 such that #$00 -> $014a, #$01 -> $014b, #$02 -> 014d a.s.o. The background is: The floppy can not store native bytes with more than two zeros in a row. The following table translates 6 bit wide numbers from #$00 to #$3f to native bytes in the floppy sector ($64 to $a3).

With the transfer to $0100 the new table at $0100 can be used as lookup to translate the native floppy bytes to 6 bit wide bytes. Such that [$0100 + native_floppy_byte] == translated_byte, where translated_byte is a 6 bit wide value from $00 to $3f.

>8:0064  4a 4b 4d 4e  52 53 55 56   JKMNRSUV
>8:006c  57 59 5a 5b  5d 5e 65 66   WYZ[]^ef
>8:0074  67 69 6a 6b  6d 6e 72 73   gijkmnrs
>8:007c  75 76 77 79  7a 7b 7d 7e   uvwyz{}~
>8:0084  95 96 97 9a  9b 9d 9e a5   ........
>8:008c  a6 a7 a9 aa  ab ad ae b2   ........
>8:0094  b3 b5 b6 b7  b9 ba bb bd   ........
>8:009c  be ca cb cd  ce d2 d3 d5   ........

>8:00a4  57 4a 4a 4a  76 4b 52 4b   WJJJvKRK
>8:00ac  7b 76 4d 56  7a 4a 4a 4a   {vMVzJJJ
>8:00b4  4a 75 4e 56  4d 4d 55 4e   JuNVMMUN
>8:00bc  4e 56 7b 4d  77 77 4d 4a   NV{MwwMJ
>8:00c4  4a 53 55 53  4e 53 75 55   JSUSNSuU
>8:00cc  7d 7b 56 76  4e 7b 52 4d   }{VvN{RM
>8:00d4  56 53 4d 4a  4e 4e 4a 75   VSMJNNJu
>8:00dc  4e 76 77 75  75 4e 77 4a   NvwuuNwJ
>8:00e4  55 52 4d 4b  4d 53 7a 7a   URMKMSzz
>8:00ec  4b 4b 7e 4e  52 4b 55 4e   KK~NRKUN
>8:00f4  52 4d 4d 4a  52 79 4a 4d   RMMJRyJM
>8:00fc  4a 4d 4e 53  00 c9 00 00   JMNS....
Table 2 (Sparse Table)

sparse table for translating native_floppy_bytes to translated bytes, [$0100 + native_floppy_byte] == translated_byte

>8:0100  00 c9 00 00  00 00 00 00   ........
>8:0108  00 00 00 00  00 00 00 00   ........
>8:0110  00 00 00 00  00 00 00 00   ........
>8:0118  00 00 00 00  00 00 00 00   ........
>8:0120  00 00 00 00  63 f9 3a f5   ....c.:.
>8:0128  10 63 7e fe  00 00 02 20   .c~....
>8:0130  7e fe 31 d1  31 d1 ba f4   ~.1.1...
>8:0138  07 e0 77 f9  7e fe 00 03   ..w.~...
>8:0140  e0 a1 89 07  fe eb 00 00   ........
>8:0148  00 00 00 01  00 02 03 00   ........
>8:0150  00 00 04 05  00 06 07 08   ........
>8:0158  00 09 0a 0b  00 0c 0d 00   ........
>8:0160  00 00 00 00  00 0e 0f 10   ........
>8:0168  00 11 12 13  00 14 15 00   ........
>8:0170  00 00 16 17  00 18 19 1a   ........
>8:0178  00 1b 1c 1d  00 1e 1f 00   ........
>8:0180  00 00 00 00  00 00 00 00   ........
>8:0188  00 00 00 00  00 00 00 00   ........
>8:0190  00 00 00 00  00 20 21 22   ..... !"
>8:0198  00 00 23 24  00 25 26 00   ..#$.%&.
>8:01a0  00 00 00 00  00 27 28 29   .....'()
>8:01a8  00 2a 2b 2c  00 2d 2e 00   .*+,.-..
>8:01b0  00 00 2f 30  00 31 32 33   ../0.123
>8:01b8  00 34 35 36  2f 37 38 9e   .456/78.
>8:01c0  fd e7 4e 52  9d a9 f9 52   ..NR...R
>8:01c8  54 9d 39 3a  52 3b 3c a9   T.9:R;<.
>8:01d0  f9 4b 3d 3e  a9 3f 4b 54   .K=>.?KT
>8:01d8  9d a9 f9 4a  54 9d a9 f9   ...JT...
>8:01e0  4a 54 bc 9f  27 c9 4a 7a   JT..'.Jz
>8:01e8  ae d7 4f d3  9d a9 7a b5   ..O...z.
>8:01f0  54 9d a9 7a  b5 54 96 9b   T..z.T..
>8:01f8  29 ef 5b 6d  95 29 5a d2   ).[m.)Z.
Load Custom Sector

Code at $0603 loads a custom format sector to $0200

.8:0600  4C C6 07    JMP $07C6
// this part loads a data sector
.8:0603  20 56 F5    JSR $F556 //wait for sync // - load data from disk and decode
.8:0606  50 FE       BVC $0606
.8:0608  AD 01 1C    LDA $1C01 // read data byte
.8:060b  B8          CLV
.8:060c  C9 6A       CMP #$6A  // #$6A is the code for a data sector
.8:060e  D0 F3       BNE $0603
.8:0610  98          TYA       // Y is returned 0 from wait for sync
.8:0611  AA          TAX       // now all registers are zeroed
.8:0612  50 FE       BVC $0612
.8:0614  B8          CLV
.8:0615  AC 01 1C    LDY $1C01   // Read 256 bytes to $0200
.8:0618  59 00 01    EOR $0100,Y // translate from table, data sector gets EORed
.8:061b  9D 00 02    STA $0200,X //
.8:061e  E8          INX
.8:061f  D0 F1       BNE $0612  // loop
.8:0621  A2 55       LDX #$55   // Read 85 bytes more and put from $F9 to $A4
.8:0623  50 FE       BVC $0623
.8:0625  B8          CLV
.8:0626  AC 01 1C    LDY $1C01
.8:0629  59 00 01    EOR $0100,Y // translate from table
.8:062c  95 A4       STA $A4,X   
.8:062e  CA          DEX
.8:062f  10 F2       BPL $0623  
.8:0631  50 FE       BVC $0631
.8:0633  B8          CLV
.8:0634  AC 01 1C    LDY $1C01  // Read byte 86.
.8:0637  59 00 01    EOR $0100,Y // translate from table
.8:063a  AA          TAX        // if checksum is correct, then A should be 0 here, A -> X
Translate 6-bit to 8-bit

The following loop takes #$55 bytes with 6 bit values from $A4 - $FF and add two bits each to bytes in groups of 3 at $0200. Y counts 1 each from the part at $A4 (downwards)

X counts 3 each for the part at $0200 (upwards)

.8:063b  A0 55       LDY #$55   // 85
.8:063d  B9 A4 00    LDA $00A4,Y // get lower bits from $F9 to $A4, e.g. pattern --543210
.8:0640  4A          LSR A       // pattern 0 -> Carry
.8:0641  3E 02 02    ROL $0202,X // [$0200 + 3 * X + 2] -bbbbbb0
.8:0644  4A          LSR A       // next bit to carry
.8:0645  3E 02 02    ROL $0202,X // [$0200 + 3 * X + 2] bbbbbb01
.8:0648  4A          LSR A       // 
.8:0649  3E 01 02    ROL $0201,X //
.8:064c  4A          LSR A       //
.8:064d  3E 01 02    ROL $0201,X // [$0200 + 3 * X + 1] bbbbbb23
.8:0650  4A          LSR A       // 
.8:0651  3E 00 02    ROL $0200,X
.8:0654  4A          LSR A
.8:0655  3E 00 02    ROL $0200,X [$0200 + 3 * X + 0] bbbbbb45
.8:0658  E8          INX         // step 3 bytes
.8:0659  E8          INX
.8:065a  E8          INX
.8:065b  88          DEY         // do that 0x55 times (0x55 * 3 = 0xFF) == 0x2FF
.8:065c  D0 DF       BNE $063D
.8:065e  A5 A4       LDA $A4     // lowest two bit from start $A4 to 0x2FF
.8:0660  4A          LSR A
.8:0661  2E FF 02    ROL $02FF
.8:0664  4A          LSR A
.8:0665  2E FF 02    ROL $02FF
.8:0668  18          CLC        // If checksum at $063a was correct then X is here 3 * 0x55 = 0xFF
.8:0669  60          RTS
.8:066a  55 00       EOR $00,X

The code at $0300 gets loaded from custom sector id 6 and loads remaining code for the 'second stage loader'. At the start the next sector to load is id 8.

.8:0300  A2 FF       LDX #$FF   // reset stack 
.8:0302  9A          TXS
.8:0303  20 00 06    JSR $0600  // load sector id 8 and move to $0400
.8:0306  A2 00       LDX #$00
.8:0308  BD 00 02    LDA $0200,X
.8:030b  9D 00 04    STA $0400,X
.8:030e  E8          INX
.8:030f  D0 F7       BNE $0308
.8:0311  20 00 06    JSR $0600 // load sector id a and move to $0500
.8:0314  A2 00       LDX #$00
.8:0316  BD 00 02    LDA $0200,X
.8:0319  9D 00 05    STA $0500,X
.8:031c  E8          INX
.8:031d  D0 F7       BNE $0316
.8:031f  E6 31       INC $31
.8:0321  E6 31       INC $31
.8:0323  20 00 06    JSR $0600 // load sector id e and move to $0700
.8:0326  A2 00       LDX #$00
.8:0328  BD 00 02    LDA $0200,X
.8:032b  9D 00 07    STA $0700,X
.8:032e  E8          INX
.8:032f  E0 98       CPX #$98
.8:0331  90 F5       BCC $0328
.8:0333  20 00 06    JSR $0600 // load sector id 0 to $0200
.8:0336  A2 00       LDX #$00
.8:0338  4C 00 07    JMP $0700 // start second stage
Example Sectors

Sectors decoded with g64conv mode 5.

Sector with Translation Table

Sector loaded for the forward translation table. Routine at $0700:

Header sector 5 (not evaluated):

  sync 64
  ; Following raw bytes:  73 4d 53 56 55 55 55 55 55 55 55 55 52 bf
  ; Following raw bits: 111

Data:

  sync 23
  ; Following raw bytes:  6a 4a 4b 4d 4e 52 53 55 56 57 59 5a 5b 5d 5e 65 66 67 69 6a 6b 6d 6e 72 73 75 76 77 79 7a 7b 7d 7e 95 96 97 9a 9b 9d 9e a5 a6 a7 a9 aa ab ad ae b2 b3 b5 b6 b7 b9 ba bb bd be ca cb cd ce d2 d3 d5 57 4a 4a 4a 76 4b 52 4b 7b 76 4d 56 7a 4a 4a 4a 4a 75 4e 56 4d 4d 55 4e 4e 56 7b 4d 77 77 4d 4a 4a 53 55 53 4e 53 75 55 7d 7b 56 76 4e 7b 52 4d 56 53 4d 4a 4e 4e 4a 75 4e 76 77 75 75 4e 77 4a 55 52 4d 4b 4d 53 7a 7a 4b 4b 7e 4e 52 4b 55 4e 52 4d 4d 4a 52 79 4a 4d 4a 4d 4e 53 4b 53 76 4a 7b 52 53 4b 7b 76 4a 53 56 4e 4e 53 7d 4a 4a 4a 57 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 6e 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 53 69 ad b2 b7 b3 ce 77 72 b7 9a b2 66 75 76 4e 95 a6 7d 7b 5e d2 57 6e 6e 95 b5 be 79 4b 6d 5a 6a d3 59 67 59 95 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4d 55 55 55 55 55 55 55 55 55 55 55 55 5f
  ; Following raw bits: 1111
Sector with Code

Sector 6, contains the routine loaded to $0300 in the floppy. Routine is called at $07a7

  sync 64
  ; Following raw bytes:  73 4d 55 57 55 55 55 55 55 55 55 56 52 bf
  ; Following raw bits: 111
  sync 23
  ; Following raw bytes:  6a a6 73 76 ae 57 4b a7 a6 b2 b2 4a a5 a5 4b cd 65 59 ba 57 4b a7 a6 b2 b2 4a a5 a5 4b cd 65 59 52 ba ba ba 52 57 4b a7 a6 b2 b2 4a a5 a5 4b cd 4d 7d 4d 76 ba 57 4b a7 a6 6b 6b 4b 4b 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 7b 7a 6b 6d 55 5d 59 5e 67 be 72 ae 7b 5e 67 a6 b6 4e 69 7a 5d 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4a 4b 4a aa aa aa aa aa aa aa aa aa aa aa bf
  ; Following raw bits: 111