Difference between revisions of "Th. Tempelmann format"

From Software Archive
Jump to navigation Jump to search
Line 308: Line 308:
 
  >8:01f8  29 ef 5b 6d  95 29 5a d2  ).[m.)Z.
 
  >8:01f8  29 ef 5b 6d  95 29 5a d2  ).[m.)Z.
  
Code at $0600 loads a custom format sector to $0200
+
===== Load Custom Sector =====
 +
 
 +
Code at $0603 loads a custom format sector to $0200
 
  .8:0600  4C C6 07    JMP $07C6
 
  .8:0600  4C C6 07    JMP $07C6
 
  // this part loads a data sector
 
  // this part loads a data sector
Line 339: Line 341:
 
  .8:0637  59 00 01    EOR $0100,Y // translate from table
 
  .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
 
  .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.
 
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.

Revision as of 17:45, 15 September 2020

As found on Wörter Rennen mit System

There are 4 sector in regular format on the disk:

t18 s0

t18 s1

t18 s8

t18 s11

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.

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


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.

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

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 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


Sectors decoded with g64conv mode 5.

Sector loaded for the forward translation table at $A4: Look at Following raw bytes and ignore the gcr decoded data as there is no gcr here.

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 6, contains the routine loaded to $0300 in the floppy.

  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