Star Rank Boxing. V-Max protection code .8:0323 A9 20 LDA #$20 .8:0325 85 3C STA $3C .8:0327 A9 FF LDA #$FF .8:0329 85 3B STA $3B .8:032b C6 3C DEC $3C .8:032d D0 03 BNE $0332 .8:032f 4C D1 03 JMP $03D1 .8:0332 A9 11 LDA #$11 .8:0334 85 06 STA $06 ; Track 17 in buffer 0 (sector is 0) .8:0336 A9 B0 LDA #$B0 .8:0338 85 00 STA $00 ; command code for buffer 0 (read in sector to $300 and fetch header ID) .8:033a 20 67 05 JSR $0567 ; check for tampering .8:033d B0 F0 BCS $032F .8:033f 58 CLI .8:0340 A5 00 LDA $00 .8:0342 30 FC BMI $0340 .8:0344 78 SEI .8:0345 C9 03 CMP #$03 .8:0347 F0 E6 BEQ $032F .8:0349 C9 02 CMP #$02 .8:034b B0 DE BCS $032B .8:034d A5 18 LDA $18 ; get track .8:034f C9 11 CMP #$11 ; is it track 17? .8:0351 D0 D8 BNE $032B .8:0353 A9 EE LDA #$EE .8:0355 8D 0C 1C STA $1C0C ; set aux control register (byte ready overflow on, read) .8:0358 A0 11 LDY #$11 ; track 17 .8:035a 20 D4 03 JSR $03D4 ; move head to requested track .8:035d B0 72 BCS $03D1 .8:035f A5 1C LDA $1C .8:0361 D0 6E BNE $03D1 .8:0363 20 67 05 JSR $0567 ; check for tampering .8:0366 B0 69 BCS $03D1 .8:0368 20 3A 04 JSR $043A ; Check header lengths and byte before/after each data block sync .8:036b B0 5B BCS $03C8 .8:036d 20 67 05 JSR $0567 ; lots of tamper checking going on here .8:0370 B0 5F BCS $03D1 .8:0372 20 BE 05 JSR $05BE ; count cycles spent between syncs in header blocks .8:0375 B0 51 BCS $03C8 .8:0377 99 C0 01 STA $01C0,Y ; store count value in $1c0+track .8:037a 20 67 05 JSR $0567 ; you tampering yet? .8:037d B0 52 BCS $03D1 .8:037f 20 BE 05 JSR $05BE ; check the header length cycle count again .8:0382 B0 44 BCS $03C8 .8:0384 79 C0 01 ADC $01C0,Y .8:0387 6A ROR A .8:0388 99 C0 01 STA $01C0,Y ; ADC/ROR, store again .8:038b 20 67 05 JSR $0567 ; If you haven't been caught tampering yet, it's unlikely you will be .8:038e B0 41 BCS $03D1 .8:0390 A9 FF LDA #$FF .8:0392 85 3B STA $3B .8:0394 A4 18 LDY $18 ; get current track .8:0396 88 DEY ; down to next track .8:0397 C0 0B CPY #$0B ; are we at track 11? .8:0399 D0 BF BNE $035A ; if not, move the drive head down a track, repeat the checks .8:039b 20 DB 04 JSR $04DB ; strict sync length check of track 12 .8:039e B0 31 BCS $03D1 .8:03a0 A0 12 LDY #$12 .8:03a2 20 D4 03 JSR $03D4 ; move drive head back to track 18 .8:03a5 B0 2A BCS $03D1 .8:03a7 20 67 05 JSR $0567 ; The tamper check .8:03aa B0 25 BCS $03D1 .8:03ac 20 BE 05 JSR $05BE ; get header length cycle count for track 18 .8:03af B0 17 BCS $03C8 .8:03b1 99 C0 01 STA $01C0,Y ; store in table .8:03b4 20 67 05 JSR $0567 ; One more check to ensure you haven't fiddled with anything! .8:03b7 B0 18 BCS $03D1 .8:03b9 20 BE 05 JSR $05BE ; get header length cycle count for track 18 again .8:03bc B0 0A BCS $03C8 .8:03be 79 C0 01 ADC $01C0,Y .8:03c1 6A ROR A .8:03c2 99 C0 01 STA $01C0,Y ; ADC/ROR, store again .8:03c5 4C FE 05 JMP $05FE ; verify the cycle counts .8:03c8 20 23 04 JSR $0423 ; if we got here, something failed, start over again after decreasing retry counter .8:03cb B0 04 BCS $03D1 .8:03cd C6 3B DEC $3B .8:03cf D0 92 BNE $0363 .8:03d1 4C A6 04 JMP $04A6 .8:03d4 84 18 STY $18 ; move drive head to requested track .8:03d6 98 TYA .8:03d7 A2 01 LDX #$01 .8:03d9 C5 22 CMP $22 .8:03db F0 2B BEQ $0408 .8:03dd E5 22 SBC $22 .8:03df 10 04 BPL $03E5 .8:03e1 49 FF EOR #$FF .8:03e3 A2 FF LDX #$FF .8:03e5 0A ASL A .8:03e6 A8 TAY .8:03e7 8A TXA .8:03e8 18 CLC .8:03e9 6D 00 1C ADC $1C00 .8:03ec 85 21 STA $21 .8:03ee AD 00 1C LDA $1C00 .8:03f1 29 FC AND #$FC .8:03f3 05 21 ORA $21 .8:03f5 8D 00 1C STA $1C00 .8:03f8 86 21 STX $21 .8:03fa 84 2D STY $2D .8:03fc 20 67 05 JSR $0567 ; We really want to make sure you're not tampering .8:03ff B0 37 BCS $0438 .8:0401 A6 21 LDX $21 .8:0403 A4 2D LDY $2D .8:0405 88 DEY .8:0406 D0 DF BNE $03E7 .8:0408 A4 18 LDY $18 .8:040a 84 22 STY $22 .8:040c 18 CLC .8:040d 60 RTS .8:040e A0 22 LDY #$22 .8:0410 98 TYA .8:0411 78 SEI .8:0412 99 00 03 STA $0300,Y .8:0415 88 DEY .8:0416 10 F8 BPL $0410 .8:0418 A9 F3 LDA #$F3 .8:041a 2D 00 1C AND $1C00 .8:041d 09 0C ORA #$0C .8:041f 8D 00 1C STA $1C00 .8:0422 60 RTS .8:0423 A9 FF LDA #$FF ; find sync mark routine .8:0425 8D 05 18 STA $1805 ; set timer .8:0428 2C 05 18 BIT $1805 .8:042b 10 0B BPL $0438 ; branch if timed out .8:042d 2C 00 1C BIT $1C00 .8:0430 30 F6 BMI $0428 ; wait for sync .8:0432 AD 01 1C LDA $1C01 ; read GCR byte before sync .8:0435 B8 CLV .8:0436 18 CLC .8:0437 60 RTS .8:0438 38 SEC .8:0439 60 RTS .8:043a 20 1F 05 JSR $051F ; locate sector header 0 on track .8:043d B0 F9 BCS $0438 .8:043f 20 23 04 JSR $0423 ; wait for data block sync mark .8:0442 B0 F4 BCS $0438 .8:0444 A9 11 LDA #$11 .8:0446 85 21 STA $21 .8:0448 20 AF 04 JSR $04AF ; count bytes in sector 0 data block .8:044b 20 AF 04 JSR $04AF ; count bytes in sector 1 header block, A=last GCR byte in header block before sync .8:044e C9 AF CMP #$AF ; GCR byte needs to be $AF .8:0450 D0 52 BNE $04A4 .8:0452 C0 11 CPY #$11 ; There needs to be 17 bytes in the header block .8:0454 D0 4E BNE $04A4 .8:0456 A5 15 LDA $15 .8:0458 D0 4A BNE $04A4 ; since this was a header block, $15 should contain $0. .8:045a 2C 00 1C BIT $1C00 .8:045d 10 FB BPL $045A ; wait for end of sync (sync mark for data block 1) .8:045f 2C 01 1C BIT $1C01 .8:0462 B8 CLV .8:0463 50 FE BVC $0463 ; wait for byte ready .8:0465 AD 01 1C LDA $1C01 ; read GCR byte .8:0468 C9 55 CMP #$55 ; byte after sync must be $55 .8:046a D0 38 BNE $04A4 .8:046c 20 AF 04 JSR $04AF ; Count bytes in data block 1 .8:046f A5 15 LDA $15 .8:0471 F0 31 BEQ $04A4 ; number of bytes must be > $FF or branch to failure .8:0473 8C 51 01 STY $0151 ; store Y (which is count mod $FF), should be $55 .8:0476 20 AF 04 JSR $04AF ; count bytes in header block 2 .8:0479 C9 AF CMP #$AF ; header block needs to end in GCR $AF .8:047b D0 27 BNE $04A4 .8:047d C0 11 CPY #$11 ; header block 2 must have 17 bytes as well .8:047f D0 23 BNE $04A4 .8:0481 A5 15 LDA $15 .8:0483 D0 1F BNE $04A4 .8:0485 2C 00 1C BIT $1C00 .8:0488 10 FB BPL $0485 ; wait for end of sync (sync mark for data block 2) .8:048a 2C 01 1C BIT $1C01 .8:048d B8 CLV .8:048e 50 FE BVC $048E ; wait for byte ready .8:0490 AD 01 1C LDA $1C01 .8:0493 C9 55 CMP #$55 ; first byte in data block 2 must be $55 .8:0495 D0 0D BNE $04A4 .8:0497 20 AF 04 JSR $04AF ; count bytes in data block 2 .8:049a A5 15 LDA $15 .8:049c F0 06 BEQ $04A4 ; must be > $FF bytes in the block (($15) = 1) .8:049e C6 21 DEC $21 .8:04a0 D0 D4 BNE $0476 ; Check 16 more blocks (19 sectors total) .8:04a2 18 CLC ; All good if we got here .8:04a3 60 RTS .8:04a4 38 SEC ; Something went wrong. Check failed. .8:04a5 60 RTS .8:04a6 A9 00 LDA #$00 .8:04a8 85 77 STA $77 .8:04aa 85 78 STA $78 .8:04ac 4C 47 06 JMP $0647 .8:04af B8 CLV ; Counts bytes. ($15)*FF+Y=number of bytes read before sync. A=GCR byte before sync .8:04b0 50 FE BVC $04B0 ; wait for byte ready .8:04b2 B8 CLV .8:04b3 A0 04 LDY #$04 .8:04b5 84 2D STY $2D ; read up to 4 blocks without a sync before giving up .8:04b7 A0 00 LDY #$00 .8:04b9 84 15 STY $15 .8:04bb AE 00 1C LDX $1C00 .8:04be 10 0F BPL $04CF ; branch if sync set .8:04c0 50 F9 BVC $04BB ; branch if byte not ready .8:04c2 B8 CLV .8:04c3 AD 01 1C LDA $1C01 ; read GCR byte .8:04c6 C8 INY ; increase byte counter .8:04c7 D0 F2 BNE $04BB ; branch if <= $FF .8:04c9 E6 15 INC $15 ; increase block counter .8:04cb C6 2D DEC $2D .8:04cd D0 EC BNE $04BB ; loop if we haven't reached a sync mark yet and haven't read 4 blocks worth .8:04cf 50 09 BVC $04DA ; if byte not ready, just RTS .8:04d1 AD 01 1C LDA $1C01 ; read the first GCR byte before the sync we hit .8:04d4 B8 CLV .8:04d5 C8 INY ; last byte read counts toward total .8:04d6 D0 02 BNE $04DA .8:04d8 E6 15 INC $15 ; if the last byte crossed a block boundary, increase counter .8:04da 60 RTS .8:04db A9 0A LDA #$0A .8:04dd 85 06 STA $06 ; Number of retries .8:04df 20 1F 05 JSR $051F ; locate sector 0 header .8:04e2 B0 35 BCS $0519 .8:04e4 20 23 04 JSR $0423 ; wait for sync .8:04e7 B0 30 BCS $0519 .8:04e9 A9 28 LDA #$28 .8:04eb 85 07 STA $07 ; Number of syncs to check .8:04ed 50 FE BVC $04ED ; wait for byte ready (sync done) .8:04ef A9 FF LDA #$FF .8:04f1 2C 00 1C BIT $1C00 .8:04f4 30 FB BMI $04F1 ; wait for sync .8:04f6 B8 CLV .8:04f7 8D 05 18 STA $1805 .8:04fa 8D 04 18 STA $1804 ; VIA timer = $FFFF, start counting down .8:04fd 50 FE BVC $04FD ; wait for sync done .8:04ff 4D 04 18 EOR $1804 ; EOR low byte of timer with $FF, store in A .8:0502 2C 01 1C BIT $1C01 .8:0505 B8 CLV .8:0506 18 CLC .8:0507 69 03 ADC #$03 ; add 3 .8:0509 29 F0 AND #$F0 ; clear low nibble .8:050b C9 60 CMP #$60 .8:050d 90 0A BCC $0519 .8:050f C9 90 CMP #$90 .8:0511 B0 06 BCS $0519 ; result must be between $60 and $90 .8:0513 C6 07 DEC $07 .8:0515 D0 D6 BNE $04ED ; Check 40 sync lengths .8:0517 18 CLC ; carry clear = success .8:0518 60 RTS .8:0519 C6 06 DEC $06 .8:051b D0 C2 BNE $04DF ; retry whole track again if retries != 0 .8:051d 38 SEC .8:051e 60 RTS .8:051f A9 00 LDA #$00 ; Locate sector header on track .8:0521 85 19 STA $19 ; sector .8:0523 45 18 EOR $18 ; track .8:0525 45 17 EOR $17 .8:0527 45 16 EOR $16 .8:0529 85 1A STA $1A .8:052b 20 34 F9 JSR $F934 ; GCR encode the block header .8:052e A2 5A LDX #$5A .8:0530 20 23 04 JSR $0423 .8:0533 B0 27 BCS $055C .8:0535 A0 00 LDY #$00 .8:0537 50 FE BVC $0537 .8:0539 B8 CLV .8:053a AD 01 1C LDA $1C01 .8:053d D9 24 00 CMP $0024,Y ; verify GCR header .8:0540 D0 17 BNE $0559 .8:0542 C8 INY .8:0543 C0 0A CPY #$0A .8:0545 D0 F0 BNE $0537 .8:0547 A0 04 LDY #$04 .8:0549 50 FE BVC $0549 .8:054b B8 CLV .8:054c AD 01 1C LDA $1C01 .8:054f D9 62 05 CMP $0562,Y ; verify header gap bytes (52 94 a5 29 4a) .8:0552 D0 05 BNE $0559 .8:0554 88 DEY .8:0555 10 F2 BPL $0549 .8:0557 18 CLC .8:0558 60 RTS .8:0559 CA DEX .8:055a D0 D4 BNE $0530 .8:055c A9 FF LDA #$FF .8:055e A4 18 LDY $18 .8:0560 38 SEC .8:0561 60 RTS .8:0567 AD FC FF LDA $FFFC ; check for tampering. Load reset vector low byte into A (should be $a0) .8:056a 85 10 STA $10 ; store it at $10 .8:056c CD 46 01 CMP $0146 ; compare to previously stored value .8:056f D0 4B BNE $05BC ; it's changed for some reason. branch to failure .8:0571 AD FD FF LDA $FFFD ; load reset vector high byte into A .8:0574 85 11 STA $11 ; store at $11 .8:0576 CD 47 01 CMP $0147 ; compare to previously stored value .8:0579 D0 41 BNE $05BC ; fail if different .8:057b 18 CLC .8:057c A9 00 LDA #$00 .8:057e A8 TAY .8:057f AA TAX .8:0580 8D 4B 01 STA $014B ; zero out $14b .8:0583 48 PHA ; push A to stack .8:0584 B1 10 LDA ($10),Y ; load contents of reset routine into A .8:0586 4D 4B 01 EOR $014B .8:0589 8D 4B 01 STA $014B ; EOR and store (get checksum of drive kernel, starting at reset routine) .8:058c 68 PLA .8:058d 71 10 ADC ($10),Y .8:058f 90 02 BCC $0593 .8:0591 E8 INX .8:0592 18 CLC .8:0593 C8 INY ; next byte .8:0594 D0 ED BNE $0583 ; hash $FF bytes .8:0596 CD 49 01 CMP $0149 ; compare to previous values to see if anything's changed .8:0599 D0 21 BNE $05BC .8:059b EC 4A 01 CPX $014A .8:059e D0 1C BNE $05BC .8:05a0 AD 4B 01 LDA $014B .8:05a3 CD 48 01 CMP $0148 .8:05a6 D0 14 BNE $05BC .8:05a8 A0 00 LDY #$00 .8:05aa 18 CLC .8:05ab 98 TYA .8:05ac 79 00 FF ADC $FF00,Y ; get checksum of higher $FF bytes of drive kernel ($FF00-$FFFF) .8:05af 59 00 FF EOR $FF00,Y .8:05b2 88 DEY .8:05b3 D0 F7 BNE $05AC .8:05b5 CD 4C 01 CMP $014C ; compare to previous value .8:05b8 D0 02 BNE $05BC .8:05ba 18 CLC .8:05bb 60 RTS .8:05bc 38 SEC ; failed .8:05bd 60 RTS ; Count cycles between syncs in header blocks. Get average of 8 counts (although total count seems to overflow) .8:05be 20 1F 05 JSR $051F ; locate sector 0 on track .8:05c1 90 06 BCC $05C9 ; branch if successful .8:05c3 A9 FF LDA #$FF .8:05c5 A4 18 LDY $18 .8:05c7 38 SEC .8:05c8 60 RTS .8:05c9 A0 00 LDY #$00 .8:05cb 84 21 STY $21 ; variable. count total .8:05cd A9 20 LDA #$20 .8:05cf 85 2D STA $2D ; variable. max number tries .8:05d1 A2 00 LDX #$00 ; initialize sync count to 0 .8:05d3 20 23 04 JSR $0423 ; find sync mark .8:05d6 B0 EB BCS $05C3 .8:05d8 AD 00 1C LDA $1C00 .8:05db 10 FB BPL $05D8 ; wait for sync done .8:05dd AD 00 1C LDA $1C00 .8:05e0 10 0A BPL $05EC ; branch if sync set .8:05e2 E8 INX ; increase counter .8:05e3 D0 F8 BNE $05DD ; loop until sync found or X runs past $FF (as is case in data block) .8:05e5 C6 2D DEC $2D ; decrease number of retries .8:05e7 D0 EA BNE $05D3 ; move to next sync mark, try again .8:05e9 38 SEC .8:05ea B0 D7 BCS $05C3 .8:05ec 8A TXA ; Move the counter to A .8:05ed 18 CLC .8:05ee 65 21 ADC $21 ; Add with carry to what's already in $21 .8:05f0 85 21 STA $21 ; store back in #$21 .8:05f2 C8 INY .8:05f3 C0 08 CPY #$08 ; look for 8 syncs embedded in the data block .8:05f5 D0 DA BNE $05D1 ; loop until we've found 8 .8:05f7 4A LSR A .8:05f8 4A LSR A .8:05f9 4A LSR A ; divide total by 8 (get average count) .8:05fa A4 18 LDY $18 ; get track number into Y .8:05fc 18 CLC .8:05fd 60 RTS .8:05fe BE C0 01 LDX $01C0,Y ; start checking the cycle count table, starting with track 18 and working back .8:0601 CA DEX ; subtract 1 from the value .8:0602 8A TXA ; store in acc .8:0603 88 DEY ; check next lower track .8:0604 D9 C0 01 CMP $01C0,Y ; compare (track 18 value - 1) to current track value .8:0607 B0 03 BCS $060C ; branch if the track had a value less than track 18's modified value, it should be .8:0609 4C 2B 03 JMP $032B ; start the protection check all over again if we failed here. .8:060c 88 DEY ; check next lower track .8:060d C0 0C CPY #$0C ; have we reached track 12? .8:060f B0 F3 BCS $0604 ; keep comparing if we haven't .8:0611 AD CC 01 LDA $01CC ; load first value (from track 12) into acc .8:0614 18 CLC .8:0615 6D CD 01 ADC $01CD ; add w/carry track 12 & 13 .8:0618 6A ROR A ; rotate result right .8:0619 8D CC 01 STA $01CC ; store back in track 12's location .8:061c AD CE 01 LDA $01CE .8:061f 18 CLC .8:0620 6D CF 01 ADC $01CF .8:0623 6A ROR A .8:0624 8D CE 01 STA $01CE ; add track 14 & 15's values, rotate right, store in track 14's location .8:0627 AD D0 01 LDA $01D0 .8:062a 18 CLC .8:062b 6D D1 01 ADC $01D1 .8:062e 6A ROR A .8:062f 8D D0 01 STA $01D0 ; add track 16 & 17's values, rotate right, store in track 16's location .8:0632 CD CC 01 CMP $01CC ; compare the result to the track 12/13 calc .8:0635 B0 D2 BCS $0609 ; result is track 16/17 value must be greater than track 12/13 value .8:0637 AD CC 01 LDA $01CC .8:063a CD CE 01 CMP $01CE .8:063d B0 CA BCS $0609 ; track 12/13 value must be greater than track 14/15 value .8:063f AD A7 01 LDA $01A7 .8:0642 09 90 ORA #$90 .8:0644 8D A7 01 STA $01A7 ; $1a7 will now contain $96 .8:0647 A0 00 LDY #$00 .8:0649 98 TYA .8:064a 99 00 03 STA $0300,Y .8:064d 99 00 04 STA $0400,Y .8:0650 C8 INY .8:0651 D0 F6 BNE $0649 ; wipe out protection code .8:0653 A5 77 LDA $77 .8:0655 D0 03 BNE $065A .8:0657 4C 06 07 JMP $0706 .8:065a A2 12 LDX #$12 .8:065c 86 06 STX $06 .8:065e CA DEX .8:065f 86 07 STX $07 .8:0661 58 CLI .8:0662 A9 80 LDA #$80 .8:0664 85 00 STA $00 .8:0666 20 67 05 JSR $0567 .8:0669 B0 EC BCS $0657 .8:066b A5 00 LDA $00 .8:066d 30 F7 BMI $0666 .8:066f C9 03 CMP #$03 .8:0671 F0 E4 BEQ $0657 .8:0673 C9 01 CMP #$01 .8:0675 D0 EB BNE $0662 .8:0677 A2 05 LDX #$05 .8:0679 BD 1D 07 LDA $071D,X .8:067c 9D BF 01 STA $01BF,X .8:067f CA DEX .8:0680 D0 F7 BNE $0679 .8:0682 BD 00 03 LDA $0300,X .8:0685 4D C0 01 EOR $01C0 .8:0688 9D 00 03 STA $0300,X .8:068b 2E C1 01 ROL $01C1 .8:068e 6E C0 01 ROR $01C0 .8:0691 2E C3 01 ROL $01C3 .8:0694 6E C2 01 ROR $01C2 .8:0697 90 08 BCC $06A1 .8:0699 AD C2 01 LDA $01C2 .8:069c 49 B3 EOR #$B3 .8:069e 8D C2 01 STA $01C2 .8:06a1 E8 INX .8:06a2 D0 DE BNE $0682 .8:06a4 E6 07 INC $07 .8:06a6 A0 40 LDY #$40 .8:06a8 B9 00 03 LDA $0300,Y .8:06ab 99 50 01 STA $0150,Y .8:06ae 88 DEY .8:06af 10 F7 BPL $06A8 .8:06b1 AD FD 03 LDA $03FD .8:06b4 8D FE 07 STA $07FE .8:06b7 AD FE 03 LDA $03FE .8:06ba 8D FF 07 STA $07FF .8:06bd A9 80 LDA #$80 .8:06bf 85 00 STA $00 .8:06c1 20 67 05 JSR $0567 .8:06c4 B0 40 BCS $0706 .8:06c6 A5 00 LDA $00 .8:06c8 30 F7 BMI $06C1 .8:06ca C9 03 CMP #$03 .8:06cc F0 38 BEQ $0706 .8:06ce B0 ED BCS $06BD .8:06d0 A2 05 LDX #$05 .8:06d2 BD 24 07 LDA $0724,X .8:06d5 9D BF 01 STA $01BF,X .8:06d8 CA DEX .8:06d9 D0 F7 BNE $06D2 .8:06db AD C2 01 LDA $01C2 .8:06de 5D 00 03 EOR $0300,X .8:06e1 9D 00 03 STA $0300,X .8:06e4 6E C0 01 ROR $01C0 .8:06e7 2E C1 01 ROL $01C1 .8:06ea 6E C3 01 ROR $01C3 .8:06ed 2E C4 01 ROL $01C4 .8:06f0 2E C2 01 ROL $01C2 .8:06f3 90 08 BCC $06FD .8:06f5 AD C0 01 LDA $01C0 .8:06f8 49 CD EOR #$CD .8:06fa 8D C0 01 STA $01C0 .8:06fd E8 INX .8:06fe D0 DB BNE $06DB .8:0700 A9 02 LDA #$02 .8:0702 48 PHA .8:0703 A9 FF LDA #$FF .8:0705 48 PHA .8:0706 A0 00 LDY #$00 .8:0708 98 TYA .8:0709 99 00 05 STA $0500,Y .8:070c 99 00 06 STA $0600,Y .8:070f C8 INY .8:0710 D0 F6 BNE $0708 .8:0712 A0 13 LDY #$13 .8:0714 98 TYA .8:0715 99 00 07 STA $0700,Y .8:0718 88 DEY .8:0719 D0 F9 BNE $0714 .8:071b 58 CLI .8:071c 60 RTS .8:0423 A9 FF LDA #$FF .8:0425 8D 05 18 STA $1805 ; set timer .8:0428 2C 05 18 BIT $1805 .8:042b 10 0B BPL $0438 ; branch if sync not found before time out .8:042d 2C 00 1C BIT $1C00 .8:0430 30 F6 BMI $0428 ; wait for sync .8:0432 AD 01 1C LDA $1C01 ; acc contains last byte read before sync .8:0435 B8 CLV .8:0436 18 CLC .8:0437 60 RTS .8:0438 38 SEC .8:0439 60 RTS