// ============================================
// output - Disassembled Source
// ============================================
// KickAssembler syntax
// Generated by Restore 64 v0.2.1 alpha build 298, 2026-04-11 21:36:49
// https://restore64.dev by datucker / Rabenauge
//
// Load address: $0800  End: $1a7f  (4736 bytes)
// Crunched with Exomizer v2/v3 — depacked by emulation
// Packer entry: $080b (via BASIC SYS 2059)
// Entry point:  $080d (2061)
// IRQ handler:  $ea31 (irq_ea31)
// IRQ handler:  $0c8b (irq_0c8b)
//
// Code: 1409 bytes, Data: 3327 bytes
// Labels: 162, Subroutines: 17
//
// Verification: 3 line(s) auto-corrected to .byte for exact byte matching
//
// Cross-references: all OK
// ============================================


// --- Region $080d-$0884 ---
.pc = $080d "main_080d"

main_080d:
        jsr sub_1a20
        jsr sub_0900
        ldx #$00
        lda #$00

loc_0817:
        sta $d800,x
        sta $d900,x
        sta $da00,x
        sta $db00,x
        inx
        bne loc_0817
        lda #$18
        sta $fe
        lda #$05
        sta $ff
        ldx #$11

loc_0830:
        lda #$20
        ldy #$00
        sta ($fe),y
        ldy #$27
        sta ($fe),y
        lda $fe
        clc
        adc #$28
        sta $fe
        bcc loc_0845
        inc $ff

loc_0845:
        dex
        bne loc_0830
        jsr sub_0be8
        nop
        nop
        nop
        nop
        nop
        lda #$7f
        sta $dc00

loc_0855:
        lda $dc00
        and $dc01
        and #$10
        bne loc_0855
        sei
        lda #$2f
        sta $00
        lda #$37
        sta $01
        ldx #$ff
        txs
        lda #$31
        sta $0314
        lda #$ea
        sta $0315
        lda #$f0
        sta $d01a
        sta $d019
        lda #$01
        sta $dc0e
        jmp $fce2

// --- Region $0900-$09a6 ---
.pc = $0900 "sub_0900"
// Referenced by: jsr from $0810

sub_0900:
        sei
        lda #$15
        sta $d018
        ldx #$00
        lda #$a0

loc_090a:
        sta $0400,x
        sta $0500,x
        sta $0600,x
        sta $0700,x
        sta $d800,x
        sta $d900,x
        sta $da00,x
        sta $db00,x
        inx
        bne loc_090a
        stx $d020
        stx $d021
        ldx #$23

loc_092d:
        lda #$62
        sta $051a,x
        lda #$e2
        sta $079a,x
        dex
        bpl loc_092d
        lda #$40
        sta $fe
        lda #$05
        sta $ff
        ldx #$0f

loc_0944:
        lda #$e1
        ldy #$01
        sta ($fe),y
        ldy #$26
        lda #$61
        sta ($fe),y
        lda $fe
        clc
        adc #$28
        sta $fe
        bcc loc_095b
        inc $ff

loc_095b:
        dex
        bne loc_0944
        lda #$6c
        sta $0519
        lda #$7b
        sta $053e
        lda #$7e
        sta $07be
        lda #$7c
        sta $0799
        nop
        jsr sub_0b05
        lda #$00
        sta $ff

loc_097a:
        lda $d011
        bpl loc_097a
        jsr sub_0a10
        ldy #$04

loc_0984:
        lda $d011
        bpl loc_0984

loc_0989:
        lda $d011
        bmi loc_0989
        dey
        bne loc_0984
        inc $ff
        lda $ff
        cmp #$08
        bne loc_097a
        ldx #$00
        ldy #$00
        stx $ae
        sty $af
        stx $2d
        sty $2e
        rts

dat_09a6:
        .byte $e8                                   // .

// --- Region $09c8-$09fe ---
.pc = $09c8 "sub_09c8"
// Referenced by: jsr from $0b15

sub_09c8:
        sta $d918,x
// Referenced by: jsr from $0b3b, $0b8b

sub_09cb:
        sta $d940,x
        sta $d968,x
        sta $d990,x
        sta $d9b8,x
        sta $d9e0,x
        sta $da08,x
        sta $da30,x
        sta $da58,x
        sta $da80,x
        sta $daa8,x
        sta $dad0,x
        sta $daf8,x
        sta $db20,x
        sta $db48,x
        sta $db70,x
        bcs loc_09fd
        sta $db98,x

loc_09fd:
        rts

dat_09fe:
        .byte $00                                   // .

// --- Region $0a10-$0af4 ---
.pc = $0a10 "sub_0a10"
// Referenced by: jsr from $097f

sub_0a10:
        ldy $ff
        lda $0a00,y
        sta $fe
        cpy #$01
        bcs loc_0a31
        ldx #$08

loc_0a1d:
        sta $0594,x
        dex
        bpl loc_0a1d
        ldx #$06

loc_0a25:
        sta $05a0,x
        sta $05ac,x
        dex
        bpl loc_0a25
        sta $05ab

loc_0a31:
        cpy #$02
        bcs loc_0a43
        ldx #$08

loc_0a37:
        sta $05bc,x
        sta $05c7,x
        sta $05d2,x
        dex
        bpl loc_0a37

loc_0a43:
        cpy #$03
        bcs loc_0a55
        ldx #$08

loc_0a49:
        sta $05e4,x
        sta $05ef,x
        sta $05fa,x
        dex
        bpl loc_0a49

loc_0a55:
        cpy #$04
        bcs loc_0a6a
        ldx #$02

loc_0a5b:
        sta $060f,x
        sta $0617,x
        sta $061d,x
        sta $0622,x
        dex
        bpl loc_0a5b

loc_0a6a:
        cpy #$05
        bcs loc_0a8d
        ldx #$02

loc_0a70:
        sta $0637,x
        sta $063f,x
        sta $065f,x
        sta $0667,x
        dex
        bpl loc_0a70
        ldx #$07

loc_0a81:
        sta $064a,x
        sta $0672,x
        dex
        bpl loc_0a81
        sta $067a

loc_0a8d:
        cpy #$06
        bcs loc_0ab0
        ldx #$02

loc_0a93:
        sta $0687,x
        sta $068f,x
        sta $06af,x
        sta $06b7,x
        sta $06bd,x
        sta $06c8,x
        dex
        bpl loc_0a93
        ldx #$07

loc_0aaa:
        sta $069b,x
        dex
        bpl loc_0aaa

loc_0ab0:
        cpy #$07
        bcs loc_0ac7
        ldx #$02

loc_0ab6:
        sta $06d7,x
        dex
        bpl loc_0ab6
        ldx #$08

loc_0abe:
        sta $06df,x
        sta $06ea,x
        dex
        bpl loc_0abe

loc_0ac7:
        cpy #$08
        bcs loc_0af3
        ldx #$02

loc_0acd:
        sta $06ff,x
        sta $0727,x                                 // !SMC: modified by $0d37
        dex
        bpl loc_0acd
        ldx #$08

loc_0ad8:
        sta $0707,x
        sta $0712,x
        dex
        bpl loc_0ad8
        ldx #$06

loc_0ae3:
        sta $0730,x
        dex
        bpl loc_0ae3
        ldx #$07

loc_0aeb:
        sta $073a,x
        dex
        bpl loc_0aeb
        clc
        rts

loc_0af3:
        sec
        rts

// --- Region $0b05-$0bae ---
.pc = $0b05 "sub_0b05"
// Referenced by: jsr from $0973

sub_0b05:
        jsr sub_0b98
        ldy #$00

loc_0b0a:
        lda $0aff,y

loc_0b0d:
        ldx $d011
        bpl loc_0b0d
        clc
        ldx #$26

loc_0b15:
        jsr sub_09c8
        dex
        bne loc_0b15
        ldx #$04

loc_0b1d:
        lda $d011
        bpl loc_0b1d

loc_0b22:
        lda $d011
        bmi loc_0b22
        dex
        bne loc_0b1d
        iny
        cpy #$05
        bne loc_0b0a
        dey

loc_0b30:
        lda $0aff,y

loc_0b33:
        ldx $d011
        bpl loc_0b33
        sec
        ldx #$25

loc_0b3b:
        jsr sub_09cb
        dex
        cpx #$01
        bne loc_0b3b
        ldx #$04

loc_0b45:
        lda $d011
        bpl loc_0b45

loc_0b4a:
        lda $d011
        bmi loc_0b4a
        dex
        bne loc_0b45
        dey
        bpl loc_0b30
        lda #$41
        sta $fe
        lda #$05
        sta $ff
        ldx #$0f

loc_0b5f:
        lda #$20
        ldy #$24

loc_0b63:
        sta ($fe),y
        dey
        bne loc_0b63
        lda $fe
        clc
        adc #$28
        sta $fe
        bcc loc_0b73
        inc $ff

loc_0b73:
        dex
        bne loc_0b5f
        lda #$20

loc_0b78:
        sta $0400,x
        inx
        bne loc_0b78
        ldx #$17

loc_0b80:
        sta $0500,x
        dex
        bpl loc_0b80
        lda #$01
        sec
        ldx #$23

loc_0b8b:
        jsr sub_09cb
        dex
        cpx #$01
        bne loc_0b8b
        rts

dat_0b94:
        .byte $00,$00,$00,$00                       // ....
// Referenced by: jsr from $0b05

sub_0b98:
        lda #$00
        tax

loc_0b9b:
        sta $d400,x
        inx
        cpx #$10
        bne loc_0b9b
        ldx #$1f

loc_0ba5:
        lda $09a8,x
        sta $d400,x
        dex
        bpl loc_0ba5
        rts

// --- Region $0bb8-$0c5d ---
.pc = $0bb8 "sub_0bb8"
// Referenced by: jsr from $0c51

sub_0bb8:
        ldx #$00
        ldy #$10
        stx $0bb0
        sty $0bb1
        stx $c1
        sty $c2
        rts

dat_0bc7:
        .byte $00                                   // .
// Referenced by: jsr from $0c54

sub_0bc8:
        lda #$07
        sta $0bb2
        ora #$10
        sta $d011
        lda #$01
        sta $0bb3
        sta $0bb6
        sta $0bb4
        sta $0bb7
        lda #$00
        sta $0bb5
        jmp loc_0d18
// Referenced by: jsr from $0848

sub_0be8:
        sei
        lda #$7f
        sta $dc0e
        lda #$00
        sta $dc0d
        lda $dc0d
        lda #$01
        sta $d01a
        sta $d019
        lda #$30
        sta $d012
        ldx #$8b
        ldy #$0c
        stx $0314
        sty $0315
        jsr sub_0c80
        lda #$00
        sta $d020
        sta $d021
        lda #$55
        ldx #$17

loc_0c1c:
        sta $0340,x
        dex
        bpl loc_0c1c
        lda #$00
        sta $d017
        lda #$03
        sta $d010
        lda #$7f
        sta $d015
        sta $d01c
        sta $d01d
        ldy #$18
        ldx #$0c

loc_0c3b:
        lda #$66
        sta $d001,x
        tya
        sta $d000,x
        clc
        adc #$30
        tay
        dex
        dex
        bpl loc_0c3b
        lda #$00
        sta $d025
        jsr sub_0bb8
        jsr sub_0bc8
        lda #$17
        sta $d018
        cli
        rts

// --- Region $0c68-$0e3e ---
.pc = $0c68 "loc_0c68"

loc_0c68:
        stx $0314
        sty $0315
        sta $d012
        lda #$01
        sta $d019
        lda $dc0d
        jmp $ea81

dat_0c7c:
        .byte $aa,$68,$40,$00                       // .h@.

// Referenced by: jsr from $0c0d
sub_0c80: {
        ldx #$07
        lda #$0d
loop:
        sta $07f8,x
        dex
        bpl loop
        rts
}

irq_0c8b:
        lda $0bb2
        and #$07
        ora #$10
        sta $d011
        jsr sub_0df8
        lda $0bb7
        beq loc_0ce0
        dec $0bb3
        bne loc_0ce0
        lda $0bb6
        sta $0bb3
        ldx $0bb0
        ldy $0bb1
        stx $c1
        sty $c2
        lda $0bb2
        ldy $0bb5
        cpy #$01
        bne loc_0cf0
        sec
        sbc #$01
        php
        and #$07
        sta $0bb2
        plp
        bpl loc_0ce0
        lda $0bb0
        clc
        adc #$28
        sta $0bb0
        bcc loc_0cd6
        inc $0bb1

loc_0cd6:
        sta $c1
        lda $0bb1
        sta $c2
        jsr loc_0d18

loc_0ce0:
        jsr sub_0d68
        lda #$2f
        ldx #$8b
        ldy #$0c
        jmp loc_0f00

dat_0cec:
        .byte $00,$00,$00,$00                       // ....

loc_0cf0:
        cpy #$02
        bne loc_0ce0
        clc
        adc #$01
        pha
        and #$07
        sta $0bb2
        pla
        cmp #$08
        bcc loc_0ce0
        lda $0bb0
        sec
        sbc #$28
        sta $0bb0
        bcs loc_0d10
        dec $0bb1

loc_0d10:
        jsr loc_0d18
        clc
        bcc loc_0ce0
        brk

dat_0d17:
        .byte $00                                   // .

loc_0d18:
        lda $0bb0
        sta $c1
        lda $0bb1
        sta $c2
        lda #$00
        sta $c3
        lda #$04
        sta $c4
        lda #$07
        sta $c0

loc_0d2e:
        ldy #$00
        ldx #$28

loc_0d32:
        lda ($c1),y
        eor #$80
        cmp #$8d
        bne loc_0d44
        lda #$20

loc_0d3c:
        sta ($c3),y
        iny
        dex
        bne loc_0d3c
        beq $0d4a

loc_0d44:
        sta ($c3),y
        iny
        dex
        bne loc_0d32
        lda $c1
        clc
        adc #$28
        sta $c1
        bcc loc_0d55
        inc $c2

loc_0d55:
        lda $c3
        clc
        adc #$28
        sta $c3
        bcc loc_0d60
        inc $c4

loc_0d60:
        dec $c0
        bne loc_0d2e
        rts

dat_0d65:
        .byte $00,$00,$00                           // ...
// Referenced by: jsr from $0ce0

sub_0d68:
        jsr sub_0d70
        jmp loc_0db8

dat_0d6e:
        .byte $00,$00                               // ..
// Referenced by: jsr from $0d68

sub_0d70:
        lda #$01
        bit $dc00
        beq loc_0d9c
        lda #$02
        bit $dc00
        beq loc_0d9c
        ldx $0bb4
        beq loc_0d87
        dec $0bb4
        rts

loc_0d87:
        ldx $0bb6
        cpx #$07
        beq loc_0d98
        inx
        stx $0bb6

loc_0d92:
        ldx #$08
        stx $0bb4
        rts

loc_0d98:
        lda #$00
        nop
        nop

loc_0d9c:
        sta $0bb5
        ldx $0bb4
        beq loc_0da8
        dec $0bb4
        rts

loc_0da8:
        ldx $0bb6
        dex
        beq loc_0db1
        stx $0bb6

loc_0db1:
        clc
        bcc loc_0d92
        brk

dat_0db5:
        .byte $00,$00,$00                           // ...

loc_0db8:
        lda $0bb5
        cmp #$02
        bne loc_0dd6
        ldx $0bbb
        dex
        cpx $0bb1
        bne loc_0dec

loc_0dc8:
        lda #$00
        sta $0bb7
        sta $0bb5
        nop
        nop
        nop
        nop
        nop
        rts

loc_0dd6:
        cmp #$01
        bne loc_0df1
        lda $0bb0
        ldx $0bb1
        sta $c1
        stx $c2
        ldy #$f0
        lda ($c1),y
        cmp #$ff
        beq loc_0dc8

loc_0dec:
        lda #$01
        sta $0bb7

loc_0df1:
        rts

dat_0df2:
        .byte $00,$00,$00,$00,$00,$00               // ......
// Referenced by: jsr from $0c95

sub_0df8:
        ldx $d012
        inx
        inx
.label smc_0dfe = * + 1
        ldy #$13                                    // !SMC: modified by $0e20
.label loc_0e00 = * + 1
        bit $a8

loc_0e01:
        lda $0e40,y
        beq loc_0e00
        sta $d021
        iny
        ldx $d012
        cpx #$67
        bcc loc_0e01
        lda #$17
        jsr sub_0eb0
        ldy smc_0dfe
        iny
        lda $0e40,y
        bne loc_0e20
        tay

loc_0e20:
        sty smc_0dfe                                // SMC: modifies $0dfe
        ldy #$07
.label loc_0e26 = * + 1
        bit $a8
        lda $0ea0,y
        beq loc_0e26
        jsr sub_0eb9
.label smc_0e30 = * + 1
        ldx #$06                                    // !SMC: modified by $0e3a
        dex
        bne loc_0e3a

dat_0e34:
        .byte $c8,$8c,$24,$0e,$a2,$06               // ..$...

loc_0e3a:
        stx smc_0e30                                // SMC: modifies $0e30
        rts

dat_0e3e:
        .byte $00                                   // .

// --- Region $0eb0-$0ec7 ---
.pc = $0eb0 "sub_0eb0"
// Referenced by: jsr from $0e13

sub_0eb0:
        sta $d011
        lda #$00
        sta $d021
        rts
// Referenced by: jsr from $0e2c

sub_0eb9:
        sta $d021
        ldx #$6e

loc_0ebe:
        cpx $d012
        bne loc_0ebe
        nop
        sta $d020
        rts

// --- Region $0f00-$0f1c ---
.pc = $0f00 "loc_0f00"

loc_0f00:
        lda $d011
        bpl loc_0f00
        lda #$30

loc_0f07:
        cmp $d012
        bne loc_0f07
        lda #$00
        sta $d020
        sta $d021
        lda #$2f
        ldx #$8b
        ldy #$0c
        jmp loc_0c68

// --- Region $1a20-$1a22 ---
.pc = $1a20 "sub_1a20"
// Referenced by: jsr from $080d

sub_1a20:
        jmp loc_1a63

// --- Region $1a63-$1a6e ---
.pc = $1a63 "loc_1a63"

loc_1a63:
        ldx #$00
        txa

loc_1a66:
        sta $0340,x
        inx
        cpx #$c0
        bne loc_1a66
        rts

// ============================================
// Data blocks
// ============================================

// --- Region $0801-$080c ---
.pc = $0801 "dat_0801"

dat_0801:
        // === BASIC loader stub ===
        .byte $0b,$08                               // next line pointer ($080b)
        .byte $d3,$07                                                     // [corrected] was: .byte $00,$00                               // line number 0
        .byte $9e                                   // SYS token
        .byte $32,$30,$35,$39
        .byte $00                                   // end of line
        .byte $80,$00                                                     // [corrected] was: .byte $00,$00                               // end of BASIC program

// --- Region $0885-$0885 ---
.pc = $0885 "dat_0885"

dat_0885:
        // === Fill data (1 bytes, $0885-$0885) ===
        .byte $00                                   // .

// --- Region $09a7-$09c7 ---
.pc = $09a7 "Program $09a7"
        .byte $0b,$10,$04,$00,$00,$21,$ac,$0a,$20,$04,$00,$00,$21,$ac,$0a,$30 // .....!.. ...!..0
        .byte $04,$00,$00,$21,$ac,$0a,$00,$00,$00,$0f,$00,$00,$00,$00,$00,$00 // ...!............
        .byte $00                                   // .

// --- Region $09ff-$0a0f ---
.pc = $09ff "Program $09ff"
        .byte $00,$63,$77,$78,$e2,$f9,$ef,$e4,$a0,$00,$00,$00,$00,$00,$00,$00 // .cwx............
        .byte $00                                   // .

// --- Region $0af5-$0b04 ---
.pc = $0af5 "dat_0af5"

dat_0af5:
        .fill 11, $00
        .byte $0b,$0c,$0f,$01,$00                   // .....

// --- Region $0baf-$0bb7 ---
.pc = $0baf "dat_0baf"

dat_0baf:
        .byte $58,$00,$10,$07,$05,$00,$00,$06,$01   // X........

// --- Region $0c5e-$0c67 ---
.pc = $0c5e "dat_0c5e"

dat_0c5e:
        .fill 10, $00

// --- Region $0e3f-$0eaf ---
.pc = $0e3f "Program $0e3f"
        .byte $00,$0b,$0b,$0b,$0b,$0c,$0c,$0c,$0f,$0f,$01,$0f,$0f,$0c,$0c,$0c // ................
        .byte $0b,$0b,$0b,$0b,$06,$06,$06,$06,$0e,$0e,$0e,$03,$03,$01,$03,$03 // ................
        .byte $0e,$0e,$0e,$06,$06,$06,$06,$05,$05,$05,$05,$0d,$0d,$0d,$03,$03 // ................
        .byte $01,$03,$03,$0d,$0d,$0d,$05,$05,$05,$05,$02,$02,$02,$02,$0a,$0a // ................
        .byte $0a,$04,$04,$01,$04,$04,$0a,$0a,$0a,$02,$02,$02,$02,$09,$09,$09 // ................
        .byte $09,$08,$08,$08,$07,$07,$01,$07,$07,$08,$08,$08,$09,$09,$09,$09 // ................
        .byte $00,$0b,$0c,$0f,$0c,$0b,$06,$0e,$03,$0e,$06,$00,$00,$00,$00,$00 // ................
        .byte $00                                   // .

// --- Region $0ec8-$0ec8 ---
.pc = $0ec8 "dat_0ec8"

dat_0ec8:
        // === Fill data (1 bytes, $0ec8-$0ec8) ===
        .byte $00                                   // .

// --- Region $0f1d-$0f1d ---
.pc = $0f1d "dat_0f1d"

dat_0f1d:
        // === Fill data (1 bytes, $0f1d-$0f1d) ===
        .byte $00                                   // .

// --- Region $1000-$1a1f ---
.pc = $1000 "dat_1000"

dat_1000:
        .byte $5b                                   // [

dat_1001:
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $5b,$5d                               // []

txt_1029:
        .text "  BROUGHT TO YOU BY THE WORLD FAMOUS  "
        .byte $5d,$5d                               // ]]

txt_1051:
        .text "      TEESSIDE CRACKING SERVICE       "
        .byte $5d,$5d                               // ]]

dat_1079:
        .text "                                      "
        .byte $5d,$5d                               // ]]

txt_10a1:
        .text "--USE JOY.PORT(B) TO SCROLL MESSAGE --"
        .byte $5d,$5b                               // ][

dat_10c9:
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $40                                   // @ character
        .byte $5b                                   // [

dat_10f0:
        .text "                                        WELCOME TO ARKANOID+, THIS VERSION OF   ARKANOID HAS SEVERAL SPECIAL FEATURES.."

dat_1167:
        // === Fill data (42 bytes, $1167-$1190) ===
        .fill 42, $20
        .text "*THE TWO PLAYER "
        .text "BUG HAS BEEN REM"
        .text "OVED.   *YOU MAY"
        .text " SELECT INFINITE"
        .text " LIVES.         "
        .text "*YOU MAY START O"
        .text "N ANY OF THE 33 "
        .text "LEVELS   EXCEPT "
        .text "FOR THE LAST ONE"
        .text "!               "
        .text "*YOU MAY HAVE NO"
        .text "TICED THAT THE A"
        .text "RCADE    VERSION"
        .text " OF THE GAME GIV"
        .text "ES YOU A LOT    "
        .text " MORE 'L' BRICKS"
        .text ", WHEREAS THIS V"
        .text "ERSION   GIVES M"
        .text "ORE 'B' BRICKS. "
        .text " TO OVERCOME    "
        .text " THIS PROBLEM YO"
        .text "U MAY SWAP THEM "
        .text "ROUND    BY SELE"
        .text "CTING THE APPROP"
        .text "IATE KEY.       "
        .text "*A RESTART KEY H"
        .text "AS BEEN ADDED"

dat_133e:
        // === Fill data (50 bytes, $133e-$136f) ===
        .fill 50, $20
        .text "TO ENTER THE OPT"
        .text "IONS MENU AT ANY"
        .text " TIME   PRESS CT"
        .text "RL AND COMMODORE"
        .text " KEYS TOGETHER."

dat_13bf:
        // === Fill data (41 bytes, $13bf-$13e7) ===
        .fill 41, $20
        .text "THE END SCREEN A"
        .text "ND FINAL MUSIC A"
        .text "RE ACE!"

dat_140f:
        // === Fill data (41 bytes, $140f-$1437) ===
        .fill 41, $20

dat_1438:
        // === Fill data (40 bytes, $1438-$145f) ===
        .fill 40, $2d
        .text "GREETINGS TO DYN"
        .text "AMIC DUO, 1001 C"
        .text "REW, TLCUCF, IRA"
        .text "TA AND JABBA, DA"
        .text "NISH GOLD, DCS, "
        .text "KERNAL, STOAT AN"
        .text "D TIM, AND REST "
        .text "OF T.C.S"

dat_14d8:
        // === Fill data (40 bytes, $14d8-$14ff) ===
        .fill 40, $2d

dat_1500:
        // === Fill data (40 bytes, $1500-$1527) ===
        .fill 40, $20
        .text "INSTRUCTIONS :-"

dat_1537:
        // === Fill data (65 bytes, $1537-$1577) ===
        .fill 65, $20
        .text "GET TO THE LAST "
        .text "LEVEL !         "
        .fill 8, $20
        .text "SOME BRICKS WHEN"
        .text " HIT RELEASE FEA"
        .text "TURES :"

dat_15c7:
        // === Fill data (42 bytes, $15c7-$15f0) ===
        .fill 42, $20
        .text "B = SKIP TO NEXT"
        .text " LEVEL          "
        .fill 8, $20
        .text "P = EXTRA MAN   "
        .fill 24, $20
        .text "D = DIVIDE BOLT "
        .text "INTO THREE BOLTS"
        .fill 8, $20
        .text "E = EXPAND BAT  "
        .fill 24, $20
        .text "S = TOGGLE SPEED"
        .text " OF BOLT        "
        .fill 8, $20
        .text "L = LASER (BLAST"
        .text "S BRICKS)       "
        .fill 8, $20
        .text "C = CATCH BOLT ("
        .text "FIRE THROWS)"

dat_16fd:
        // === Fill data (51 bytes, $16fd-$172f) ===
        .fill 51, $20
        .text "SOME BRICKS ARE "
        .text "INDESTRUCABLE, A"
        .text "ND SOME TAKE SEV"
        .text "ERAL HITS BEFORE"
        .text " CRUMBLING."

dat_177b:
        // === Fill data (85 bytes, $177b-$17cf) ===
        .fill 85, $20
        .text "HOPE YOU LIKE TH"
        .text "E NEW INTRO ... "
        .text "WATCH   OUT FOR "

chr_1800:
        // === Charset data (544 bytes, $1800-$1a1f) ===
        .byte $44,$45,$4c,$54,$41,$20,$41,$4e       // char 0 @+0
        .byte $44,$20,$4e,$45,$4d,$45,$53,$49       // char 1 @+1
        .byte $53,$20,$57,$48,$49,$43,$48,$20       // char 2 @+2
        .byte $49,$20,$48,$4f,$50,$45,$20,$20       // char 3 @+3
        .byte $54,$4f,$20,$47,$45,$54,$20,$4d       // char 4 @+4
        .byte $59,$20,$4d,$49,$54,$54,$53,$20       // char 5 @+5
        .byte $4f,$4e,$20,$56,$45,$52,$59,$20       // char 6 @+6
        .byte $53,$4f,$4f,$4e,$20,$21               // char 7 (partial)

dat_183e:
        // === Fill data (90 bytes, $183e-$1897) ===
        .fill 90, $20
        .byte $4f,$48,$20,$59,$45,$41,$48,$2c       // char 19 @+19
        .byte $20,$41,$20,$4d,$45,$53,$53,$41       // char 20 @+20
        .byte $47,$45,$20,$54,$4f,$20,$49,$41       // char 21 @+21
        .byte $4e,$20,$41,$4e,$44,$20,$53,$50       // char 22 @+22
        .byte $45,$57,$20,$4f,$46,$20,$20,$20       // char 23 @+23
        .byte $54,$48,$45,$20,$43,$4c,$45,$56       // char 24 @+24
        .byte $45,$4c,$41,$4e,$44,$20,$43,$52       // char 25 @+25
        .byte $41,$50,$50,$49,$4e,$47,$20,$53       // char 26 @+26
        .byte $45,$52,$56,$49,$43,$45,$20,$2e       // char 27 @+27
        .byte $2e,$2e,$2e                           // char 28 (partial)

dat_18e3:
        // === Fill data (45 bytes, $18e3-$190f) ===
        .fill 45, $20
        .byte $22,$57,$48,$45,$4e,$20,$59,$4f       // char 34 '"'
        .byte $55,$52,$45,$20,$46,$55,$43,$4b       // char 35 '#'
        .byte $49,$4e,$47,$20,$45,$41,$43,$48       // char 36 '$'
        .byte $20,$4f,$54,$48,$45,$52,$2c,$20       // char 37 '%'
        .byte $44,$4f,$4e,$27,$54,$20,$20,$20       // char 38 '&'
        .byte $20,$46,$4f,$52,$47,$45,$54,$20       // char 39 '''
        .byte $54,$4f,$20,$57,$45,$41,$52,$20       // char 40 '('
        .byte $41,$20,$43,$4f,$4e,$44,$4f,$4d       // char 41 ')'
        .byte $20,$2e,$2e,$2e,$20,$49,$54,$53       // char 42 '*'
        .byte $20,$53,$41,$46,$45,$52,$20,$20       // char 43 '+'
        .byte $20,$54,$48,$41,$54,$20,$57,$41       // char 44 ','
        .byte $59,$21,$21,$20,$22,$2e               // char 45 (partial)

dat_196e:
        // === Fill data (115 bytes, $196e-$19e0) ===
        .fill 115, $20
        .byte $2d,$2d,$2d,$20,$45,$4e,$44           // char 60 (partial)
        .byte $20,$4f,$46,$20,$54,$45,$58,$54       // char 61 '='
        .byte $20,$2d,$2d,$2d,$20,$20,$20,$20       // char 62 '>'
        .byte $20,$20,$20,$20,$20,$20,$20,$20       // char 63 '?'

dat_1a00:
        // === Fill data (32 bytes, $1a00-$1a1f) ===
        .fill 32, $ff

// --- Region $1a23-$1a62 ---
.pc = $1a23 "chr_1a23"

chr_1a23:
        // === Charset data (64 bytes, $1a23-$1a62) ===
        .byte $5b                                   // char 0 (partial)

txt_1a24:
        .byte $49,$4e,$54,$52,$4f,$20,$57           // char 0 (partial)
        .byte $41,$53,$20,$52,$49,$50,$50,$45       // char 1 @+1
        .byte $44,$20,$41,$4e,$44,$20,$53,$4d       // char 2 @+2
        .byte $41,$4c,$4c,$20,$46,$49,$58,$2d       // char 3 @+3
        .byte $41,$44,$44,$45,$44,$20,$42,$59       // char 4 @+4
        .byte $20,$43,$45,$4e,$54,$52,$41,$58       // char 5 @+5
        .byte $2b,$2f,$2b,$41,$47,$4f,$4e,$59       // char 6 @+6
        .byte $5f                                   // char 7 (partial)

txt_1a5c:
        .byte $56,$4f,$54,$45,$3a,$2d,$3e           // char 7 (partial)

// --- Region $1a6f-$1a7f ---
.pc = $1a6f "chr_1a6f"

chr_1a6f:
        // === Charset data (17 bytes, $1a6f-$1a7f) ===
        .byte $52,$49,$50,$20,$4e,$55,$4d,$42       // char 0 @+0
        .byte $45,$52,$23,$30,$35,$38,$30,$21       // char 1 @+1
        .byte $5d                                   // char 2 (partial)