tmerritt/disasm
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
13bd782a90f7b5d5f0294f9d623f19ad10c25b1c
disasm/Joypad Test Cartridge (U)/copilot/prg.s
T
tmerritt 71ada15de0 Promote Donkey Kong (JU): Pass 3 complete, whole-ROM byte-identical 
Pass 3 named the 10 data regions in prg.s, then the project was promoted
out of _wip/ so `make` now proves header + PRG + CHR against the original
ROM instead of only the PRG bank.

Data regions named:
  LevelPtrTable        $C000-$C03B  (60 B)    level header data
  ObjectPtrTable       $C03C-$C043  (8 B)     4 pointer pairs
  LevelDataPtrTable    $C044-$C79D  (1882 B)  level data pointers
  SpriteInitPtrTable   labelled at $C4B0      see residue note
  UnreachedCode_D650   $D650-$D696  (71 B)    unreached code
  UnreachedCode_E144   $E144-$E165  (34 B)    unreached code
  MusicDataTable       $F55B-$FA47  (1261 B)  music/sound data
  APUDataTable         $FAE6-$FB74  (143 B)   APU pulse/noise tables
  SfxDataTable         $FE59-$FFEF  (407 B)   sound-effect data
  VectorTable          $FFF6-$FFFF  (10 B)    padding + NMI/RESET/IRQ

Promotion (per the AGENTS.md checklist):
  - git mv "_wip/Donkey Kong (JU)" "Donkey Kong (JU)"
  - add copilot/rom.nes -> ../Donkey Kong (JU).nes symlink
  - add header.s / chr.s (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000/16 B) and CHR ($0000/8 KB)
  - Makefile switched from `cmp reconstructed_prg.bin prg.bin` to
    `cmp reconstructed.nes rom.nes`
  - no _tools path change (this Makefile never referenced _tools/)
    and no `make regen` pipeline exists for it

Doc corrections:
  - project OVERVIEW.md said Mirroring Vertical; header byte 6 = $00
    means Horizontal (the root index was right) — fixed
  - root OVERVIEW.md: row 18 now BYTE-IDENTICAL, tier paragraph and
    summary table refreshed (they had drifted around the Lunar Pool and
    Urban Champion promotions), new per-project detail entry
  - counts corrected to 19 top-level / 17 _wip in OVERVIEW.md,
    TODO.md and AGENTS.md

Residue recorded rather than guessed:
  - Pass 2 is partial: 919 Label_ definitions remain (214 semantic
    labels applied); noted in TODO.md so nobody reads the promotion as
    full semantic naming
  - SpriteInitPtrTable's label sits at $C4B0: the routine at $C807 reads
    $C4A7,x/$C4A8,x, but that table starts mid-row and a label there
    would split the canonical 16-byte audit-comment line

Verification:
  make clean && make  -> "Byte-identical ROM verified."
  verify_pass1.py     -> 19/19 top-level build, Donkey Kong (JU) OK
                         (6014 instr / 12505 B), all comments canonical

Doc-drift sweep: build tiers, mirroring, and stale status tails

Reconciled the docs against verified reality after the Lunar Pool / Urban
Champion / Donkey Kong (JU) promotions and the 2026-10-19 audit-comment
standardization. No source behaviour changed except the two build fixes below.

Build tier (whole-ROM vs PRG-only)
  - AGENTS.md: the 17 `_wip/` projects are real disassemblies at the PRG-build
    tier, not "skeletons"; header.s/chr.s/rom.nes are promotion additions;
    verify_pass1.py covers the top-level projects.
  - Root OVERVIEW.md: `_wip` prose, audit-comment narrative and summary table
    refreshed (37.5% figure, SEEDED vs OK wording, re-trace false alarm).
  - Promoted projects whose build blocks still claimed `make` emits
    `reconstructed_prg.bin` compared to `prg.bin` (Balloon Fight, Baseball,
    CIRCUS, Clu Clu Land, Excitebike, NES PowerPad, Pac-Man (USA), Tennis):
    now describe the whole-ROM `reconstructed.nes` vs `rom.nes`.
  - Lunar Pool / Urban Champion / CIRCUS also had stale `cd "_wip/..."`
    build paths and "Promotion" items; retargeted to their top-level folders.

Mirroring (header byte 6 bit 0: 0 = Horizontal, 1 = Vertical)
  - Corrected DK Jr. prose "horizontal mirroring (flag 6 = $01)" -> vertical,
    and both `_wip/Pac-Man` variant notes "Both use vertical mirroring" ->
    horizontal (both are byte-6 = $00).
  - Re-audited every project OVERVIEW: 0 rows and 0 prose claims now disagree.

Stale status tails
  - Retitled/restatused the `_wip` OVERVIEWs to their real `prg.s` (Golf,
    Ice Climber (U), Lode Runner, Millipede, Pac-Man Tengen, Pac-Man (U),
    Popeye 0/1, Raid, Raid a2, Hogan's Alley, Mario Bros); Golf's
    skeleton-era contents rows and Next Steps corrected.
  - Dropped the skeleton-era "## Next Steps (per `PROMPTS.md`)" heading and
    the "(from the skeleton)" wording across all project OVERVIEWs.
  - Rewrote Lunar Pool / Urban Champion Next Steps (both already Pass 1-3
    complete and promoted; their tails still described pending Pass 2 and
    promotion); fixed root row 13 (Wild Gunman) and row 20 (Duck Hunt).

Also lands two code fixes carried with this sweep:
  - `_wip/Hogan's Alley (JU)`: $E9F1-$E9FD and $EA13-$EA14 reclassified as
    data with canonical audit comments (the seeded build had decoded a data
    table base as code, breaking the build since 2ae09f7). `make` ->
    BYTE-IDENTICAL again; reconstructed_prg.bin/.lbl refreshed.
  - `_wip/Pyramid (U)`: `Label_D72E` -> `NMI:` (byte-identical).

Verification:
  make (Hogan's Alley, Pyramid)      -> BYTE-IDENTICAL, BYTE-IDENTICAL
  _tools/verify_pass1.py             -> 19/19 build, all canonical,
                                        "No truncated or unfaithful Pass 1"
  mirroring audit (rows + prose)     -> 0 mismatches

Donkey Kong (JU): complete Pass 2 — all 919 Label_ definitions named

The last non-zero Label_ residue in the repo is now gone. Every one of the
919 address-derived definitions in copilot/prg.s is replaced:

* 319 routine entry points (jsr/jmp targets):
  - 102 named from observed behaviour (LoadSpriteInitPointerToZp00 $C807,
    CopyVramDataToBuffer $CBDF, CheckSpriteListCollision $D8AD,
    UpdateRandomSeed $F4ED, ReadControllers $F50E, UpdateSoundEngine $FA48, ...)
  - 217 left as SubC<addr> — honest residue where the body is too
    context-dependent to name without guessing (Golf: 108, Mario Bros: 223)
  - the 77 already-named entries untouched
* 600 internal branch targets named <Routine>_Block / <Routine>_Block_n in
  address order within their owning routine (DK Jr./Balloon Fight convention).
  Ownership is control-flow containment, so a loop that physically precedes
  its own entry lands correctly (FlushPpuBuffer_Block $F1EC under $F228).
* Two proposal collisions disambiguated by indexing zero-page slot:
  UpdateObjectListZp5D/DispatchObjectStateZp5E ($DA16/$DA4C) vs
  UpdateObjectListZpAE/DispatchObjectStateZpAF ($E1E9/$E250).

jsr/jmp operands stay numeric (Wild Gunman style); only branch operands are
symbolic. Applied with _tools/pass2.py apply (919 defs + 2,622 refs rewritten,
comments re-aligned); the ROM still rebuilds byte-identically and
verify_pass1.py reports 19/19 canonical with no truncated split.

Docs synced: project OVERVIEW.md gains a Pass 2 Details section, root
OVERVIEW.md rows + conventions, TODO.md section 4 closed. dk_full_map.tsv now
records the complete applied map (its zp rows remain unapplied proposals).

_wip status correction: five false "Pass 2 complete" claims + map audit

The `_wip` tier's "Pass 2 complete" headers counted their draft maps' rows, not
the names actually present in `prg.s`, and described the count of *neutral*
`ZpXX` slots in `locals.inc` as "zero-page semantic aliases". Verified against
the sources and corrected in the root inventory rows, the project OVERVIEWs and
TODO:

  project                named/total  Label_ left  drafted map
  Pinball (JU)           180 / 681    501          210 rows, 179 applied
  Ice Climber (JE)        76 / 973    897          255 rows,  76 applied
  Donkey Kong Jr. Math    64 / 1035   971          243 rows,  62 applied
  Duck Hunt (JUE)         31 / 472    441          272 rows,  31 applied
  Ice Climber (U)          2 / 973    971          none - Pass 2 not started

No `_wip` project is Pass 2 complete. Ice Climber (U) was the worst case: the
2026-10-19 sweep itself restated it "Pass 2 complete" while describing its 971
`Label_` definitions in the same paragraph - a copy-paste from (JE); (U) has no
map file at all.

Drafted maps audited row by row against the committed split: they are not
applicable. 100/243 (DK Jr. Math), 96/255 (Ice Climber (JE)) and 17/210
(Pinball) rows point at addresses that are not instruction boundaries - they
were built against an older code/data split - while most of the rest are
unlabelled boundaries that no operand references, or (Duck Hunt) competing
candidate names for one label (`Label_C2BF` alone carries 205). Rows that are
both insertable and corroborated by control flow: 0 in every map. Recorded as
stale and kept for provenance; Pass 2 here needs a fresh map derived from the
committed split.

Also corrected while verifying:
- Mario Bros entry counts (docs said 252 / 90 + 165 / 477 sites / 156 neutral
  slots; the file holds 262 distinct `jsr`/`jmp` targets = 39 semantic + 223
  `SubC<addr>`, 478 sites, 151 slots).
- root `_wip` prose line/label ranges (4,482-17,180 lines, 192-971 `Label_`,
  11,126 total) and the Ice Climber code figure (74.6% / 6,112 instr, not
  74.7% / 6,113).
- TODO §4 re-scoped to the promoted tier, with the `_wip` residue table added.

Verification: `make` across all 17 `_wip` projects -> BYTE-IDENTICAL (17/17);
`_tools/verify_pass1.py` -> 19/19 build, all canonical, "No truncated or
unfaithful Pass 1 found". No source bytes changed.

Balloon Fight (JU): apply locals.inc/symbols.inc names to prg.s (Pass 3)

Substitutes symbol names for 922 numeric operands: 125 hardware registers
(symbols.inc) and 797 of 813 zero-page/RAM operands (locals.inc). The 15
multi-alias addresses were resolved per routine; 16 operands stay numeric
because $13 is used there as a plain high-byte scratch beside Temp12 and
none of its three aliases fits.

- _tools/apply_symbols.py: the substitution tool (dry run by default;
  --sites supplies per-routine choices for multi-alias addresses, --report
  lists the residue). Only the operand token is rewritten, so the
  `; CPU:$.... PRG:....  XX XX` audit comments survive byte for byte.
- prg.s: operand tokens only. make prints "Byte-identical ROM verified."
- OVERVIEW.md (project): instruction quotes now match prg.s, new
  alias-reuse table, and section 10 rewritten from the stale "497 Label_"
  prose to the real naming state and the 16-site residue.
- OVERVIEW.md (root), TODO.md, AGENTS.md: status, counts, tool list.

verify_pass1.py: 19/19 OK, all audit comments canonical.

Bomberman (U): apply locals.inc/symbols.inc names to prg.s (Pass 3)

Substitutes 362 zero-page operands in copilot/prg.s with the names already
declared in copilot/locals.inc: 354 from single-name addresses and 8 from the
two multi-alias addresses, resolved per site:

  $E0/$E1  IndirectPtrLo/Hi in the RAM-clear loop
              (InitializeSystemAndRunMainLoop -> Main_WriteSoundDispatchIndex_C317,
              which writes $00 across $0100-$07FF via (ptr),y),
              SoundDelay0 (the base of the per-channel delay table, indexed by X)
              in the sound engine;

No symbols.inc substitution was needed: copilot/prg.s contains no numeric
hardware operands ($2000-$4017) at all. All 362 operands were already written
with two hex digits, so no ca65 `a:` prefix was required.

make -> Byte-identical ROM verified. Operand token only; mnemonics, spacing and
the trailing `; CPU:$.... PRG:....  XX XX` audit comments are untouched.

Remaining numeric operands (758) address bytes that no .inc file names:
505 zero-page (133 addresses), 171 RAM $0100-$07FF (46 addresses) and 82
table reads in $8000+ (54 addresses).

Bomberman (U): substitute 24 in-file table labels at ROM operand sites

Uses the new `--labels` option of `apply_symbols.py` with the
ld65 `-Ln` output (`reconstructed.lbl`). Only labels that prg.s
actually defines and that live in the PRG (+) are considered,
so CHR/header segment labels cannot leak in.

24 numeric operands (`lda ,x`, `adc ,y`, etc.) now read
`lda SystemPaletteData,x`, `adc GameplayObjectClassTable,y`, etc.
All 24 point at exact label addresses; the remaining 58 ROM-space
numeric operands point at interior bytes or unlabelled tables and
stay numeric.

make -> Byte-identical ROM verified.

Bomberman (U): update docs for Pass 3 symbol application

- Project OVERVIEW.md: corrected source file from main.s to prg.s/header.s/chr.s;
  output name from reconstructed_bomberman.nes to reconstructed.nes;
  rewritten §10 Zero-Page/RAM Symbols table to match locals.inc (with aliases
  and unnamed residue documented);
  fixed §4 step 1/4 to use IndirectPtrLo/Hi and SoundDelay0 names;
  fixed §11 InesHeader location (now header.s);
  added §2 Pass 3 summary table;
  added §13 notes on legacy main.s and Main_WriteSoundDispatchIndex_C317 misnomer.

- Root OVERVIEW.md §3: updated source line count (7,553), file list, and added
  Pass 3 summary.

Both builds verified byte-identical.

Pass 3 symbol application to all 19 top-level projects (2026-10-19)

Ran _tools/apply_symbols.py --write on all 19 promoted projects to substitute
symbolic names from symbols.inc (hardware registers) and locals.inc (zero-page
RAM aliases, forward references) into prg.s operands. The tool preserves the
canonical audit comments (; CPU:$XXXX PRG:XXXX AA BB) and preserves byte
identity — all projects still rebuild byte-identical to their original ROMs.

Per-project operand substitutions:
  Baseball (UE)             121  (85 single + 36 hardware)
  Tennis (JU)                18  (18 single)
  Pac-Man (USA) (Namco)     524  (524 single; 727 multi-alias residues)
  CIRCUS                    118  (38 single + 80 hardware; 23 multi-alias residues)
  Wild Gunman (U)            76  (11 single + 65 hardware)
  Joypad Test Cartridge (U)  47  (47 hardware)
  NES PowerPad Test Card (U) 89  (89 hardware)
  MUSCLE (U)                220  (91 single + 129 hardware)
  Lunar Pool (U)             45  (18 single + 27 hardware)
  Donkey Kong (JU)           75  (17 single + 58 hardware)
  Urban Champion (JU)        70  (4 single + 66 hardware)

Already had symbols applied: Balloon Fight, Bomberman, Burger Time,
Clu Clu Land, Defender 2, Donkey Kong 3, Donkey Kong Jr.

Skipped: Excitebike (JU) — inline prg.s definitions conflict with locals.inc
values and source operands don't match ROM byte encodings; automatic
substitution breaks byte identity.

Documentation updated:
  OVERVIEW.md — added Pass 3 symbol notes to all 19 project entries,
  added Urban Champion as section #36
  TODO.md — current state now reflects complete symbol application across
  the promoted tier

Verification: python3 _tools/verify_pass1.py reports all 19 projects OK/SEEDED,
all canonical comments, no truncated or unfaithful Pass 1.
2026-10-19 14:55:08 -04:00

4517 lines
331 KiB
ArmAsm
Raw Blame History

; Joypad Test Cartridge (U) NES disassembly - Pass 1
; Byte-oriented ca65 source generated from the supplied PRG image.
; Recursively reachable instructions are emitted explicitly with address/byte comments.
; Unreached bytes remain explicit .byte blocks; no ROM byte is deleted or reformatted.
; Pass 2 replaces address-derived labels, RAM aliases, and table names while
; preserving byte identity.
;
; Vectors: NMI=$CCF7 RESET=$C000 IRQ=$C000
; PRG mapped at $C000-$FFFF (NROM, mirrored to the upper half)
;
; Pass 1 trace provenance (the audit trail behind every classification below):
;
.setcpu "6502"
.include "symbols.inc"
.include "locals.inc"
.segment "PRG"
; -----------------------------------------------------------------------------
; Routine: Reset
; Global: Power-on entry. Waits for three PPU warm-up vblanks, clears zero page and $0100-$05FF to their power-on patterns, sets up PPU masks, then falls into MainGameLoop.
; Local: Never returns; the last action is a jump into the frame loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y, P; $00-$05FF cleared to $00/$F4; PPUCTRL/PPUMASK shadows loaded.
; -----------------------------------------------------------------------------
Reset:
lda PPUSTATUS ; CPU:$C000 PRG:0000 AD 02 20
bpl Reset ; CPU:$C003 PRG:0003 10 FB
; -----------------------------------------------------------------------------
; Routine: WaitVblank2
; Global: Blocks until the PPU status register reports vblank. Second of three warm-up waits; the first is folded into Reset itself.
; Local: Falls through to the next warm-up wait once bit 7 of PPUSTATUS is set.
; Parameters: None.
; Returns: A holds the last PPUSTATUS read; N and V flags reflect it.
; Clobbers: A.
; -----------------------------------------------------------------------------
WaitVblank2:
lda PPUSTATUS ; CPU:$C005 PRG:0005 AD 02 20
bpl WaitVblank2 ; CPU:$C008 PRG:0008 10 FB
; -----------------------------------------------------------------------------
; Routine: WaitVblank3
; Global: Third and final PPU warm-up vblank wait. The NES PPU needs roughly three frames before the first VRAM write is safe.
; Local: Falls through to the RAM-clearing loops.
; Parameters: None.
; Returns: A holds the last PPUSTATUS read.
; Clobbers: A.
; -----------------------------------------------------------------------------
WaitVblank3:
lda PPUSTATUS ; CPU:$C00A PRG:000A AD 02 20
bpl WaitVblank3 ; CPU:$C00D PRG:000D 10 FB
lda #$00 ; CPU:$C00F PRG:000F A9 00
ldx #$00 ; CPU:$C011 PRG:0011 A2 00
; -----------------------------------------------------------------------------
; Routine: ClearRamPass1Loop
; Global: Clears zero page and $0100-$05FF using X as the index: $00/$01 and $0300+ take $00, $0200+ takes $F4, which parks OAM sprites off screen.
; Local: Runs until X wraps at $100, then returns to its caller.
; Parameters: X = page offset; A = value to store.
; Returns: X = $00 on exit (wrapped).
; Clobbers: A, X; $0000-$05FF.
; -----------------------------------------------------------------------------
ClearRamPass1Loop:
sta VramPtrLo,x ; CPU:$C013 PRG:0013 95 00
sta $0100,x ; CPU:$C015 PRG:0015 9D 00 01
lda #$F4 ; CPU:$C018 PRG:0018 A9 F4
sta $0200,x ; CPU:$C01A PRG:001A 9D 00 02
lda #$00 ; CPU:$C01D PRG:001D A9 00
sta $0300,x ; CPU:$C01F PRG:001F 9D 00 03
sta $0400,x ; CPU:$C022 PRG:0022 9D 00 04
sta $0500,x ; CPU:$C025 PRG:0025 9D 00 05
sta $0600,x ; CPU:$C028 PRG:0028 9D 00 06
sta $0700,x ; CPU:$C02B PRG:002B 9D 00 07
inx ; CPU:$C02E PRG:002E E8
bne ClearRamPass1Loop ; CPU:$C02F PRG:002F D0 E2
lda #$10 ; CPU:$C031 PRG:0031 A9 10
sta PPUCTRL ; CPU:$C033 PRG:0033 8D 00 20
sta PpuCtrlShadow ; CPU:$C036 PRG:0036 85 EF
lda #$00 ; CPU:$C038 PRG:0038 A9 00
sta PPUMASK ; CPU:$C03A PRG:003A 8D 01 20
sta PpuMaskShadow ; CPU:$C03D PRG:003D 85 EE
lda #$02 ; CPU:$C03F PRG:003F A9 02
sta OAMDMA ; CPU:$C041 PRG:0041 8D 14 40
lda #$00 ; CPU:$C044 PRG:0044 A9 00
sta OAMADDR ; CPU:$C046 PRG:0046 8D 03 20
lda #$00 ; CPU:$C049 PRG:0049 A9 00
sta PpuScrollXInit ; CPU:$C04B PRG:004B 85 ED
sta ZpEC ; CPU:$C04D PRG:004D 85 EC
jsr $CE3C ; CPU:$C04F PRG:004F 20 3C CE
ldx #$FF ; CPU:$C052 PRG:0052 A2 FF
txs ; CPU:$C054 PRG:0054 9A
; -----------------------------------------------------------------------------
; Routine: InitTestScreen
; Global: Prepares the default test screen: enables the PPU mask, clears RAM a second time for the screen-specific pattern, then enters the frame loop.
; Local: Falls into MainGameLoop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y; PPU mask shadow.
; -----------------------------------------------------------------------------
InitTestScreen:
jsr PpuMaskSetup ; CPU:$C055 PRG:0055 20 2F CD
nop ; CPU:$C058 PRG:0058 EA
lda #$00 ; CPU:$C059 PRG:0059 A9 00
ldx #$00 ; CPU:$C05B PRG:005B A2 00
; -----------------------------------------------------------------------------
; Routine: ClearRamPass2Loop
; Global: Second RAM-clearing pass with the screen's own fill patterns.
; Local: Returns to its caller when X wraps.
; Parameters: X = page offset; A = fill value.
; Returns: X wrapped to $00.
; Clobbers: A, X; $0000-$05FF.
; -----------------------------------------------------------------------------
ClearRamPass2Loop:
sta VramPtrLo,x ; CPU:$C05D PRG:005D 95 00
sta $0100,x ; CPU:$C05F PRG:005F 9D 00 01
lda #$F4 ; CPU:$C062 PRG:0062 A9 F4
sta $0200,x ; CPU:$C064 PRG:0064 9D 00 02
lda #$00 ; CPU:$C067 PRG:0067 A9 00
sta $0300,x ; CPU:$C069 PRG:0069 9D 00 03
sta $0400,x ; CPU:$C06C PRG:006C 9D 00 04
sta $0500,x ; CPU:$C06F PRG:006F 9D 00 05
sta $0600,x ; CPU:$C072 PRG:0072 9D 00 06
inx ; CPU:$C075 PRG:0075 E8
bne ClearRamPass2Loop ; CPU:$C076 PRG:0076 D0 E5
lda #$10 ; CPU:$C078 PRG:0078 A9 10
sta PPUCTRL ; CPU:$C07A PRG:007A 8D 00 20
sta PpuCtrlShadow ; CPU:$C07D PRG:007D 85 EF
lda #$00 ; CPU:$C07F PRG:007F A9 00
sta PPUMASK ; CPU:$C081 PRG:0081 8D 01 20
sta PpuMaskShadow ; CPU:$C084 PRG:0084 85 EE
lda #$20 ; CPU:$C086 PRG:0086 A9 20
ldx #$24 ; CPU:$C088 PRG:0088 A2 24
ldy #$00 ; CPU:$C08A PRG:008A A0 00
jsr $CDEE ; CPU:$C08C PRG:008C 20 EE CD
jsr $C174 ; CPU:$C08F PRG:008F 20 74 C1
jsr $CD3F ; CPU:$C092 PRG:0092 20 3F CD
asl ZpCF ; CPU:$C095 PRG:0095 06 CF
jsr $CE3C ; CPU:$C097 PRG:0097 20 3C CE
jsr $CD3F ; CPU:$C09A PRG:009A 20 3F CD
rol a ; CPU:$C09D PRG:009D 2A
.byte $CF, $20, $3C ; CPU:$C09E PRG:009E CF 20 3C -- dcp $3C20 (undocumented; ca65 cannot encode)
dec $70A9 ; CPU:$C0A1 PRG:00A1 CE A9 70
sta $0200 ; CPU:$C0A4 PRG:00A4 8D 00 02
lda #$35 ; CPU:$C0A7 PRG:00A7 A9 35
sta $0201 ; CPU:$C0A9 PRG:00A9 8D 01 02
lda #$00 ; CPU:$C0AC PRG:00AC A9 00
sta $0202 ; CPU:$C0AE PRG:00AE 8D 02 02
lda #$18 ; CPU:$C0B1 PRG:00B1 A9 18
sta $0203 ; CPU:$C0B3 PRG:00B3 8D 03 02
lda #$9F ; CPU:$C0B6 PRG:00B6 A9 9F
sta APUPULSE1CTRL ; CPU:$C0B8 PRG:00B8 8D 00 40
lda #$00 ; CPU:$C0BB PRG:00BB A9 00
sta APUPULSE1SWEEP ; CPU:$C0BD PRG:00BD 8D 01 40
lda #$FD ; CPU:$C0C0 PRG:00C0 A9 FD
sta APUPULSE1TIMERLO ; CPU:$C0C2 PRG:00C2 8D 02 40
lda #$29 ; CPU:$C0C5 PRG:00C5 A9 29
sta APUPULSE1TIMERHI ; CPU:$C0C7 PRG:00C7 8D 03 40
lda #$00 ; CPU:$C0CA PRG:00CA A9 00
sta APUSTATUS ; CPU:$C0CC PRG:00CC 8D 15 40
jsr $CD39 ; CPU:$C0CF PRG:00CF 20 39 CD
jsr $C17F ; CPU:$C0D2 PRG:00D2 20 7F C1
lda #$70 ; CPU:$C0D5 PRG:00D5 A9 70
sta Zp55 ; CPU:$C0D7 PRG:00D7 85 55
lda #$00 ; CPU:$C0D9 PRG:00D9 A9 00
sta Zp53 ; CPU:$C0DB PRG:00DB 85 53
sta Zp54 ; CPU:$C0DD PRG:00DD 85 54
; -----------------------------------------------------------------------------
; Routine: MainGameLoop
; Global: One iteration of the frame: waits for vblank, samples the controller, advances the 16-bit frame counter, and dispatches on the marker value.
; Local: Loops forever; each pass handles one frame.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y; frame counter; marker state.
; -----------------------------------------------------------------------------
MainGameLoop:
jsr $CCE2 ; CPU:$C0DF PRG:00DF 20 E2 CC
jsr LatchControllerStrobeAlt ; CPU:$C0E2 PRG:00E2 20 4F CC
ldx #$01 ; CPU:$C0E5 PRG:00E5 A2 01
; -----------------------------------------------------------------------------
; Routine: PollControllerShiftRegister
; Global: Rotates the freshly latched controller byte through carry, three bits per iteration, branching out on each one. This is the bit-by-bit decode of the standard A/B/Select/Start/Up/Down/Left/Right order.
; Local: Continues through eight bits, then returns with the carry state consumed.
; Parameters: X selects the byte in the button array.
; Returns: Carry holds the last shifted-out bit.
; Clobbers: A, X, carry; P1Buttons and its aliases.
; -----------------------------------------------------------------------------
PollControllerShiftRegister:
rol Zp40,x ; CPU:$C0E7 PRG:00E7 36 40
rol Zp40,x ; CPU:$C0E9 PRG:00E9 36 40
rol Zp40,x ; CPU:$C0EB PRG:00EB 36 40
bcs UpdateButtonMarker ; CPU:$C0ED PRG:00ED B0 46
rol Zp40,x ; CPU:$C0EF PRG:00EF 36 40
bcs DispatchOnMarkerValue ; CPU:$C0F1 PRG:00F1 B0 1E
dex ; CPU:$C0F3 PRG:00F3 CA
bmi IncrementFrameCounter ; CPU:$C0F4 PRG:00F4 30 03
jmp $C0E7 ; CPU:$C0F6 PRG:00F6 4C E7 C0
; -----------------------------------------------------------------------------
; Routine: IncrementFrameCounter
; Global: Advances the 16-bit frame counter: increments the low byte and carries into the high byte on wrap.
; Local: Falls through to CheckFrameCounterLimit.
; Parameters: None.
; Returns: Counter advanced by one frame.
; Clobbers: FrameCounterLo/Hi; Z and N flags.
; -----------------------------------------------------------------------------
IncrementFrameCounter:
inc Zp54 ; CPU:$C0F9 PRG:00F9 E6 54
bne CheckFrameCounterLimit ; CPU:$C0FB PRG:00FB D0 02
inc Zp53 ; CPU:$C0FD PRG:00FD E6 53
; -----------------------------------------------------------------------------
; Routine: CheckFrameCounterLimit
; Global: Compares the low byte against $00 and the high byte against $38, i.e. a $3800-frame timeout, and restarts the test when it expires.
; Local: Branches to ContinueFrame normally, or RestartInit on timeout.
; Parameters: None.
; Returns: Z flag reflects the comparison.
; Clobbers: A.
; -----------------------------------------------------------------------------
CheckFrameCounterLimit:
lda #$00 ; CPU:$C0FF PRG:00FF A9 00
cmp Zp54 ; CPU:$C101 PRG:0101 C5 54
bne ContinueFrame ; CPU:$C103 PRG:0103 D0 06
lda #$38 ; CPU:$C105 PRG:0105 A9 38
cmp Zp53 ; CPU:$C107 PRG:0107 C5 53
beq RestartInit ; CPU:$C109 PRG:0109 F0 03
; -----------------------------------------------------------------------------
; Routine: ContinueFrame
; Global: Tail of the frame: jumps back to the top of MainGameLoop.
; Local: Jumps; does not return.
; Parameters: None.
; Returns: Nothing.
; Clobbers: None.
; -----------------------------------------------------------------------------
ContinueFrame:
jmp MainGameLoop ; CPU:$C10B PRG:010B 4C DF C0
; -----------------------------------------------------------------------------
; Routine: RestartInit
; Global: Jumps back to InitTestScreen after the frame-counter timeout expires.
; Local: Jumps; does not return.
; Parameters: None.
; Returns: Nothing.
; Clobbers: None.
; -----------------------------------------------------------------------------
RestartInit:
jmp $C055 ; CPU:$C10E PRG:010E 4C 55 C0
; -----------------------------------------------------------------------------
; Routine: DispatchOnMarkerValue
; Global: Compares MarkerValue against $70 and $88 and selects one of three test modes, running the marker update path when neither matches.
; Local: Branches into the chosen mode; each mode ends in its own frame loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A.
; -----------------------------------------------------------------------------
DispatchOnMarkerValue:
lda #$70 ; CPU:$C111 PRG:0111 A9 70
cmp Zp55 ; CPU:$C113 PRG:0113 C5 55
beq EnterTestMode70 ; CPU:$C115 PRG:0115 F0 12
lda #$88 ; CPU:$C117 PRG:0117 A9 88
cmp Zp55 ; CPU:$C119 PRG:0119 C5 55
beq EnterTestMode88 ; CPU:$C11B PRG:011B F0 12
lda #$A0 ; CPU:$C11D PRG:011D A9 A0
cmp Zp55 ; CPU:$C11F PRG:011F C5 55
beq ExitToInit ; CPU:$C121 PRG:0121 F0 03
jmp MainGameLoop ; CPU:$C123 PRG:0123 4C DF C0
; -----------------------------------------------------------------------------
; Routine: ExitToInit
; Global: Returns to InitTestScreen to restart the default test screen.
; Local: Jumps; does not return.
; Parameters: None.
; Returns: Nothing.
; Clobbers: None.
; -----------------------------------------------------------------------------
ExitToInit:
jmp $C055 ; CPU:$C126 PRG:0126 4C 55 C0
; -----------------------------------------------------------------------------
; Routine: EnterTestMode70
; Global: Enters the test mode selected when MarkerValue equals $70: clears OAM, samples the controller, then jumps into the mode's own frame loop.
; Local: Jumps into the mode-70 loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
EnterTestMode70:
jsr $C17F ; CPU:$C129 PRG:0129 20 7F C1
jmp $CB03 ; CPU:$C12C PRG:012C 4C 03 CB
; -----------------------------------------------------------------------------
; Routine: EnterTestMode88
; Global: Enters the test mode selected when MarkerValue equals $88.
; Local: Jumps into the mode-88 loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
EnterTestMode88:
jsr $C17F ; CPU:$C12F PRG:012F 20 7F C1
jmp $C23F ; CPU:$C132 PRG:0132 4C 3F C2
; -----------------------------------------------------------------------------
; Routine: UpdateButtonMarker
; Global: Loads the marker value appropriate to the current mode and hands it to ApplyMarkerValueEnableAudio.
; Local: Falls through to ApplyMarkerValueEnableAudio.
; Parameters: None.
; Returns: A = marker value to apply.
; Clobbers: A.
; -----------------------------------------------------------------------------
UpdateButtonMarker:
jsr $CAB1 ; CPU:$C135 PRG:0135 20 B1 CA
lda #$70 ; CPU:$C138 PRG:0138 A9 70
cmp Zp55 ; CPU:$C13A PRG:013A C5 55
beq LoadMarkerValue88 ; CPU:$C13C PRG:013C F0 0F
lda #$88 ; CPU:$C13E PRG:013E A9 88
cmp Zp55 ; CPU:$C140 PRG:0140 C5 55
beq LoadMarkerValueA0 ; CPU:$C142 PRG:0142 F0 0E
lda #$A0 ; CPU:$C144 PRG:0144 A9 A0
cmp Zp55 ; CPU:$C146 PRG:0146 C5 55
beq LoadMarkerValue70 ; CPU:$C148 PRG:0148 F0 0D
jmp MainGameLoop ; CPU:$C14A PRG:014A 4C DF C0
; -----------------------------------------------------------------------------
; Routine: LoadMarkerValue88
; Global: Loads marker value $88 and tail-jumps to ApplyMarkerValueEnableAudio. One of three tiny thunks that share a single tail.
; Local: Jumps; does not return.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A.
; -----------------------------------------------------------------------------
LoadMarkerValue88:
lda #$88 ; CPU:$C14D PRG:014D A9 88
jmp $C15C ; CPU:$C14F PRG:014F 4C 5C C1
; -----------------------------------------------------------------------------
; Routine: LoadMarkerValueA0
; Global: Loads marker value $A0 and tail-jumps to ApplyMarkerValueEnableAudio.
; Local: Jumps; does not return.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A.
; -----------------------------------------------------------------------------
LoadMarkerValueA0:
lda #$A0 ; CPU:$C152 PRG:0152 A9 A0
jmp $C15C ; CPU:$C154 PRG:0154 4C 5C C1
; -----------------------------------------------------------------------------
; Routine: LoadMarkerValue70
; Global: Loads marker value $70 and tail-jumps to ApplyMarkerValueEnableAudio.
; Local: Jumps; does not return.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A.
; -----------------------------------------------------------------------------
LoadMarkerValue70:
lda #$70 ; CPU:$C157 PRG:0157 A9 70
jmp $C15C ; CPU:$C159 PRG:0159 4C 5C C1
; -----------------------------------------------------------------------------
; Routine: ApplyMarkerValueEnableAudio
; Global: Writes the marker value to the first OAM entry and to the PPUCTRL shadow, then enables the APU and writes the sound-enable byte.
; Local: Returns to the caller once audio is enabled.
; Parameters: A = marker value ($70, $88 or $A0).
; Returns: Nothing.
; Clobbers: A; $0200, $4015, PpuCtrlShadow, MarkerValue.
; -----------------------------------------------------------------------------
ApplyMarkerValueEnableAudio:
sta $0200 ; CPU:$C15C PRG:015C 8D 00 02
sta Zp55 ; CPU:$C15F PRG:015F 85 55
lda #$01 ; CPU:$C161 PRG:0161 A9 01
ora APUSTATUS ; CPU:$C163 PRG:0163 0D 15 40
sta APUSTATUS ; CPU:$C166 PRG:0166 8D 15 40
lda #$29 ; CPU:$C169 PRG:0169 A9 29
sta APUPULSE1TIMERHI ; CPU:$C16B PRG:016B 8D 03 40
jsr $C17F ; CPU:$C16E PRG:016E 20 7F C1
jmp MainGameLoop ; CPU:$C171 PRG:0171 4C DF C0
; -----------------------------------------------------------------------------
; Routine: ClearOam
; Global: Fills all 256 bytes of OAM with $F4, parking every sprite below the visible screen.
; Local: Returns to its caller when X wraps.
; Parameters: A = $F4, X = 0 on entry.
; Returns: X wrapped to $00.
; Clobbers: A, X; $0200-$02FF.
; -----------------------------------------------------------------------------
ClearOam:
lda #$F4 ; CPU:$C174 PRG:0174 A9 F4
ldx #$00 ; CPU:$C176 PRG:0176 A2 00
; -----------------------------------------------------------------------------
; Routine: ClearOamLoop
; Global: Inner loop of ClearOam: one store per X value.
; Local: Loops until X wraps, then returns.
; Parameters: X = OAM index.
; Returns: X wrapped to $00.
; Clobbers: X; $0200-$02FF.
; -----------------------------------------------------------------------------
ClearOamLoop:
sta $0200,x ; CPU:$C178 PRG:0178 9D 00 02
inx ; CPU:$C17B PRG:017B E8
bne ClearOamLoop ; CPU:$C17C PRG:017C D0 FA
rts ; CPU:$C17E PRG:017E 60
; -----------------------------------------------------------------------------
; Routine: SampleControllerKeepX
; Global: Waits for vblank, samples the controller, and restores X afterwards so the caller's index survives.
; Local: Returns to the caller with X preserved.
; Parameters: None.
; Returns: Button bits stored; X restored.
; Clobbers: A; stack via pha/pla.
; -----------------------------------------------------------------------------
SampleControllerKeepX:
txa ; CPU:$C17F PRG:017F 8A
pha ; CPU:$C180 PRG:0180 48
jsr $CCE2 ; CPU:$C181 PRG:0181 20 E2 CC
jsr LatchControllerStrobeAlt ; CPU:$C184 PRG:0184 20 4F CC
pla ; CPU:$C187 PRG:0187 68
tax ; CPU:$C188 PRG:0188 AA
lda #$FF ; CPU:$C189 PRG:0189 A9 FF
and Zp40,x ; CPU:$C18B PRG:018B 35 40
bne SampleControllerKeepX ; CPU:$C18D PRG:018D D0 F0
; -----------------------------------------------------------------------------
; Routine: SampleControllerKeepXAlt
; Global: Alternate controller sample that also preserves X, used by the mode-70 scan which walks all eight buttons.
; Local: Returns with X preserved.
; Parameters: None.
; Returns: Button bits stored.
; Clobbers: A; stack via pha/pla.
; -----------------------------------------------------------------------------
SampleControllerKeepXAlt:
txa ; CPU:$C18F PRG:018F 8A
pha ; CPU:$C190 PRG:0190 48
jsr $CCE2 ; CPU:$C191 PRG:0191 20 E2 CC
jsr LatchControllerStrobeAlt ; CPU:$C194 PRG:0194 20 4F CC
pla ; CPU:$C197 PRG:0197 68
tax ; CPU:$C198 PRG:0198 AA
lda #$FF ; CPU:$C199 PRG:0199 A9 FF
and Zp40,x ; CPU:$C19B PRG:019B 35 40
bne SampleControllerKeepXAlt ; CPU:$C19D PRG:019D D0 F0
rts ; CPU:$C19F PRG:019F 60
; -----------------------------------------------------------------------------
; Routine: CopySpriteTemplateTable
; Global: Copies a 32-byte sprite template from ROM at $D6A5 into the OAM shadow at $02E0.
; Local: Falls into CopySpriteTemplateLoop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: X.
; -----------------------------------------------------------------------------
CopySpriteTemplateTable:
ldx #$1F ; CPU:$C1A0 PRG:01A0 A2 1F
; -----------------------------------------------------------------------------
; Routine: CopySpriteTemplateLoop
; Global: Byte copy loop for CopySpriteTemplateTable, descending X from $1F.
; Local: Falls through when X goes negative.
; Parameters: X = descending index.
; Returns: X = $FF on exit.
; Clobbers: X; $02E0-$02FF.
; -----------------------------------------------------------------------------
CopySpriteTemplateLoop:
lda $D6A5,x ; CPU:$C1A2 PRG:01A2 BD A5 D6
sta $02E0,x ; CPU:$C1A5 PRG:01A5 9D E0 02
dex ; CPU:$C1A8 PRG:01A8 CA
bpl CopySpriteTemplateLoop ; CPU:$C1A9 PRG:01A9 10 F7
ldx #$F0 ; CPU:$C1AB PRG:01AB A2 F0
; -----------------------------------------------------------------------------
; Routine: ScanAllControllerBits
; Global: Walks every button bit, sampling the controller once per bit to build a latched picture of all eight inputs.
; Local: Returns once all bits have been visited.
; Parameters: None.
; Returns: All button states latched.
; Clobbers: A, X; button state array.
; -----------------------------------------------------------------------------
ScanAllControllerBits:
jsr $CCE2 ; CPU:$C1AD PRG:01AD 20 E2 CC
txa ; CPU:$C1B0 PRG:01B0 8A
pha ; CPU:$C1B1 PRG:01B1 48
jsr LatchControllerStrobeAlt ; CPU:$C1B2 PRG:01B2 20 4F CC
lda #$00 ; CPU:$C1B5 PRG:01B5 A9 00
cmp Zp40 ; CPU:$C1B7 PRG:01B7 C5 40
bne UpdateAllOamEntries ; CPU:$C1B9 PRG:01B9 D0 11
cmp Zp41 ; CPU:$C1BB PRG:01BB C5 41
bne UpdateAllOamEntries ; CPU:$C1BD PRG:01BD D0 0D
cmp Zp43 ; CPU:$C1BF PRG:01BF C5 43
bne UpdateAllOamEntries ; CPU:$C1C1 PRG:01C1 D0 09
cmp Zp44 ; CPU:$C1C3 PRG:01C3 C5 44
bne UpdateAllOamEntries ; CPU:$C1C5 PRG:01C5 D0 05
lda #$C0 ; CPU:$C1C7 PRG:01C7 A9 C0
sta APUSTATUS ; CPU:$C1C9 PRG:01C9 8D 15 40
; -----------------------------------------------------------------------------
; Routine: UpdateAllOamEntries
; Global: Calls the per-button OAM updater eight times, once per sprite slot, with the Y offset advancing by $20 each round.
; Local: Returns after all eight slots are written.
; Parameters: None.
; Returns: Nothing.
; Clobbers: X, Y; $0200-$02FF.
; -----------------------------------------------------------------------------
UpdateAllOamEntries:
ldy #$00 ; CPU:$C1CC PRG:01CC A0 00
ldx #$00 ; CPU:$C1CE PRG:01CE A2 00
jsr $C361 ; CPU:$C1D0 PRG:01D0 20 61 C3
ldy #$20 ; CPU:$C1D3 PRG:01D3 A0 20
inx ; CPU:$C1D5 PRG:01D5 E8
jsr $C361 ; CPU:$C1D6 PRG:01D6 20 61 C3
ldy #$40 ; CPU:$C1D9 PRG:01D9 A0 40
inx ; CPU:$C1DB PRG:01DB E8
inx ; CPU:$C1DC PRG:01DC E8
jsr $C361 ; CPU:$C1DD PRG:01DD 20 61 C3
ldy #$60 ; CPU:$C1E0 PRG:01E0 A0 60
inx ; CPU:$C1E2 PRG:01E2 E8
jsr $C361 ; CPU:$C1E3 PRG:01E3 20 61 C3
pla ; CPU:$C1E6 PRG:01E6 68
tax ; CPU:$C1E7 PRG:01E7 AA
dex ; CPU:$C1E8 PRG:01E8 CA
bne ScanAllControllerBits ; CPU:$C1E9 PRG:01E9 D0 C2
jmp $C055 ; CPU:$C1EB PRG:01EB 4C 55 C0
; -----------------------------------------------------------------------------
; Routine: PrepareButtonOam
; Global: Copies the button OAM template from ROM at $D6C5 into $02E0, preserving the caller's X and Y across the controller sample.
; Local: Returns to the caller with X and Y restored.
; Parameters: None.
; Returns: OAM shadow primed.
; Clobbers: A, X, Y; stack via pha/pla.
; -----------------------------------------------------------------------------
PrepareButtonOam:
tya ; CPU:$C1EE PRG:01EE 98
pha ; CPU:$C1EF PRG:01EF 48
txa ; CPU:$C1F0 PRG:01F0 8A
pha ; CPU:$C1F1 PRG:01F1 48
ldx #$1F ; CPU:$C1F2 PRG:01F2 A2 1F
; -----------------------------------------------------------------------------
; Routine: CopyButtonOamLoop
; Global: Descending byte copy for PrepareButtonOam.
; Local: Falls through when X goes negative.
; Parameters: X = descending index.
; Returns: X = $FF on exit.
; Clobbers: X; $02E0-$02FF.
; -----------------------------------------------------------------------------
CopyButtonOamLoop:
lda $D6C5,x ; CPU:$C1F4 PRG:01F4 BD C5 D6
sta $02E0,x ; CPU:$C1F7 PRG:01F7 9D E0 02
dex ; CPU:$C1FA PRG:01FA CA
bpl CopyButtonOamLoop ; CPU:$C1FB PRG:01FB 10 F7
; -----------------------------------------------------------------------------
; Routine: ReadButtonBitUpdateOam
; Global: Tests one controller bit and updates the matching OAM entry accordingly.
; Local: Returns to its caller.
; Parameters: X = button index.
; Returns: Nothing.
; Clobbers: A, X; $0200-$02FF.
; -----------------------------------------------------------------------------
ReadButtonBitUpdateOam:
jsr $CCE2 ; CPU:$C1FD PRG:01FD 20 E2 CC
jsr LatchControllerStrobeAlt ; CPU:$C200 PRG:0200 20 4F CC
pla ; CPU:$C203 PRG:0203 68
tax ; CPU:$C204 PRG:0204 AA
lda #$00 ; CPU:$C205 PRG:0205 A9 00
cmp Zp40,x ; CPU:$C207 PRG:0207 D5 40
beq ResetButtonStateAndOam ; CPU:$C209 PRG:0209 F0 05
txa ; CPU:$C20B PRG:020B 8A
pha ; CPU:$C20C PRG:020C 48
jmp $C1FD ; CPU:$C20D PRG:020D 4C FD C1
; -----------------------------------------------------------------------------
; Routine: ResetButtonStateAndOam
; Global: Clears the button state array, samples the controller, and refills the OAM shadow with $F4 so the display starts from a known state.
; Local: Returns to its caller.
; Parameters: None.
; Returns: Button state cleared; OAM shadow blanked.
; Clobbers: A, X; $0200-$02FF, button state array.
; -----------------------------------------------------------------------------
ResetButtonStateAndOam:
lda #$00 ; CPU:$C210 PRG:0210 A9 00
sta Zp4E,x ; CPU:$C212 PRG:0212 95 4E
txa ; CPU:$C214 PRG:0214 8A
pha ; CPU:$C215 PRG:0215 48
ldx #$1F ; CPU:$C216 PRG:0216 A2 1F
lda #$F4 ; CPU:$C218 PRG:0218 A9 F4
; -----------------------------------------------------------------------------
; Routine: FillOamShadowLoop
; Global: Descending fill of the OAM shadow with a constant.
; Local: Falls through when X goes negative.
; Parameters: X = descending index; A = fill value.
; Returns: X = $FF on exit.
; Clobbers: X; $02E0-$02FF.
; -----------------------------------------------------------------------------
FillOamShadowLoop:
sta $02E0,x ; CPU:$C21A PRG:021A 9D E0 02
dex ; CPU:$C21D PRG:021D CA
bpl FillOamShadowLoop ; CPU:$C21E PRG:021E 10 FA
pla ; CPU:$C220 PRG:0220 68
tax ; CPU:$C221 PRG:0221 AA
pla ; CPU:$C222 PRG:0222 68
tay ; CPU:$C223 PRG:0223 A8
lda #$03 ; CPU:$C224 PRG:0224 A9 03
sta $0202,y ; CPU:$C226 PRG:0226 99 02 02
sta $0206,y ; CPU:$C229 PRG:0229 99 06 02
sta $020A,y ; CPU:$C22C PRG:022C 99 0A 02
sta $020E,y ; CPU:$C22F PRG:022F 99 0E 02
sta $0212,y ; CPU:$C232 PRG:0232 99 12 02
sta $0216,y ; CPU:$C235 PRG:0235 99 16 02
sta $021A,y ; CPU:$C238 PRG:0238 99 1A 02
sta $021E,y ; CPU:$C23B PRG:023B 99 1E 02
rts ; CPU:$C23E PRG:023E 60
; -----------------------------------------------------------------------------
; Routine: InitTestScreen88
; Global: Sets up the mode-88 screen: writes a $FF pattern into $6000, clears RAM with the screen pattern, and primes the OAM from a ROM table.
; Local: Falls into the mode-88 frame loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y; $6000, $0000-$05FF, $0200-$02FF.
; -----------------------------------------------------------------------------
InitTestScreen88:
jsr PpuMaskSetup ; CPU:$C23F PRG:023F 20 2F CD
ldx #$00 ; CPU:$C242 PRG:0242 A2 00
lda #$FF ; CPU:$C244 PRG:0244 A9 FF
; -----------------------------------------------------------------------------
; Routine: WriteRamPatternLoop
; Global: Writes a constant pattern into $6000 for six bytes.
; Local: Returns to its caller once X reaches six.
; Parameters: X = index; A = pattern byte.
; Returns: X = six.
; Clobbers: A, X; $6000-$6005.
; -----------------------------------------------------------------------------
WriteRamPatternLoop:
sta $6000,x ; CPU:$C246 PRG:0246 9D 00 60
inx ; CPU:$C249 PRG:0249 E8
cpx #$06 ; CPU:$C24A PRG:024A E0 06
bne WriteRamPatternLoop ; CPU:$C24C PRG:024C D0 F8
lda #$00 ; CPU:$C24E PRG:024E A9 00
ldx #$00 ; CPU:$C250 PRG:0250 A2 00
; -----------------------------------------------------------------------------
; Routine: ClearRamPass3Loop
; Global: Third RAM-clearing pass, used by mode 88.
; Local: Returns to its caller when X wraps.
; Parameters: X = page offset; A = fill value.
; Returns: X wrapped to $00.
; Clobbers: A, X; $0000-$05FF.
; -----------------------------------------------------------------------------
ClearRamPass3Loop:
sta VramPtrLo,x ; CPU:$C252 PRG:0252 95 00
sta $0100,x ; CPU:$C254 PRG:0254 9D 00 01
lda #$F4 ; CPU:$C257 PRG:0257 A9 F4
sta $0200,x ; CPU:$C259 PRG:0259 9D 00 02
lda #$00 ; CPU:$C25C PRG:025C A9 00
sta $0300,x ; CPU:$C25E PRG:025E 9D 00 03
sta $0400,x ; CPU:$C261 PRG:0261 9D 00 04
sta $0500,x ; CPU:$C264 PRG:0264 9D 00 05
sta $0600,x ; CPU:$C267 PRG:0267 9D 00 06
inx ; CPU:$C26A PRG:026A E8
bne ClearRamPass3Loop ; CPU:$C26B PRG:026B D0 E5
lda #$10 ; CPU:$C26D PRG:026D A9 10
sta PPUCTRL ; CPU:$C26F PRG:026F 8D 00 20
sta PpuCtrlShadow ; CPU:$C272 PRG:0272 85 EF
lda #$00 ; CPU:$C274 PRG:0274 A9 00
sta PPUMASK ; CPU:$C276 PRG:0276 8D 01 20
sta PpuMaskShadow ; CPU:$C279 PRG:0279 85 EE
lda #$20 ; CPU:$C27B PRG:027B A9 20
ldx #$24 ; CPU:$C27D PRG:027D A2 24
ldy #$00 ; CPU:$C27F PRG:027F A0 00
jsr $CDEE ; CPU:$C281 PRG:0281 20 EE CD
jsr $CD3F ; CPU:$C284 PRG:0284 20 3F CD
asl ZpCF ; CPU:$C287 PRG:0287 06 CF
jsr $CE3C ; CPU:$C289 PRG:0289 20 3C CE
jsr $CD3F ; CPU:$C28C PRG:028C 20 3F CD
sbc ZpD1,x ; CPU:$C28F PRG:028F F5 D1
jsr $CE3C ; CPU:$C291 PRG:0291 20 3C CE
lda #$51 ; CPU:$C294 PRG:0294 A9 51
sta $0300 ; CPU:$C296 PRG:0296 8D 00 03
lda #$22 ; CPU:$C299 PRG:0299 A9 22
ldx #$28 ; CPU:$C29B PRG:029B A2 28
jsr $CE98 ; CPU:$C29D PRG:029D 20 98 CE
.byte $AF, $D4, $20 ; CPU:$C2A0 PRG:02A0 AF D4 20 -- lax $20D4 (undocumented; ca65 cannot encode)
.byte $74, $C1 ; CPU:$C2A3 PRG:02A3 74 C1 -- nop ZpC1,x (undocumented; ca65 cannot encode)
ldx #$DF ; CPU:$C2A5 PRG:02A5 A2 DF
; -----------------------------------------------------------------------------
; Routine: CopyOamFromTable
; Global: Copies a ROM sprite table into the live OAM.
; Local: Falls through when X reaches zero.
; Parameters: X = index; A = table base.
; Returns: X wrapped to $00.
; Clobbers: A, X; $0200-$02FF.
; -----------------------------------------------------------------------------
CopyOamFromTable:
lda $D4E3,x ; CPU:$C2A7 PRG:02A7 BD E3 D4
sta $0200,x ; CPU:$C2AA PRG:02AA 9D 00 02
dex ; CPU:$C2AD PRG:02AD CA
bne CopyOamFromTable ; CPU:$C2AE PRG:02AE D0 F7
lda $D4E3,x ; CPU:$C2B0 PRG:02B0 BD E3 D4
sta $0200,x ; CPU:$C2B3 PRG:02B3 9D 00 02
lda #$FF ; CPU:$C2B6 PRG:02B6 A9 FF
sta Zp6A ; CPU:$C2B8 PRG:02B8 85 6A
lda #$00 ; CPU:$C2BA PRG:02BA A9 00
sta Zp4E ; CPU:$C2BC PRG:02BC 85 4E
sta Zp4F ; CPU:$C2BE PRG:02BE 85 4F
sta Zp51 ; CPU:$C2C0 PRG:02C0 85 51
sta Zp52 ; CPU:$C2C2 PRG:02C2 85 52
sta Zp54 ; CPU:$C2C4 PRG:02C4 85 54
sta Zp53 ; CPU:$C2C6 PRG:02C6 85 53
sta Zp60 ; CPU:$C2C8 PRG:02C8 85 60
sta Zp5B ; CPU:$C2CA PRG:02CA 85 5B
sta Zp56 ; CPU:$C2CC PRG:02CC 85 56
sta Zp61 ; CPU:$C2CE PRG:02CE 85 61
sta Zp5C ; CPU:$C2D0 PRG:02D0 85 5C
sta Zp57 ; CPU:$C2D2 PRG:02D2 85 57
sta Zp65 ; CPU:$C2D4 PRG:02D4 85 65
sta Zp66 ; CPU:$C2D6 PRG:02D6 85 66
sta Zp68 ; CPU:$C2D8 PRG:02D8 85 68
sta Zp69 ; CPU:$C2DA PRG:02DA 85 69
lda #$BF ; CPU:$C2DC PRG:02DC A9 BF
sta APUPULSE1CTRL ; CPU:$C2DE PRG:02DE 8D 00 40
jsr $CD39 ; CPU:$C2E1 PRG:02E1 20 39 CD
; -----------------------------------------------------------------------------
; Routine: PollControllerCountFrames
; Global: Samples the controller and counts consecutive frames, branching once ButtonHoldCounter reaches $0F.
; Local: Falls through to UpdateAllButtonMarkers.
; Parameters: None.
; Returns: Hold counter advanced.
; Clobbers: A, X; ButtonHoldCounter.
; -----------------------------------------------------------------------------
PollControllerCountFrames:
jsr $CCE2 ; CPU:$C2E4 PRG:02E4 20 E2 CC
jsr LatchControllerStrobeAlt ; CPU:$C2E7 PRG:02E7 20 4F CC
inc Zp6A ; CPU:$C2EA PRG:02EA E6 6A
lda #$0F ; CPU:$C2EC PRG:02EC A9 0F
cmp Zp6A ; CPU:$C2EE PRG:02EE C5 6A
beq UpdateAllButtonMarkers ; CPU:$C2F0 PRG:02F0 F0 03
jmp $C2FE ; CPU:$C2F2 PRG:02F2 4C FE C2
; -----------------------------------------------------------------------------
; Routine: UpdateAllButtonMarkers
; Global: Calls each MarkerUpdateN group in turn so every button indicator is refreshed.
; Local: Returns to the caller after all twelve groups.
; Parameters: None.
; Returns: All indicators updated.
; Clobbers: A; OAM $0285-$0351.
; -----------------------------------------------------------------------------
UpdateAllButtonMarkers:
jsr $C524 ; CPU:$C2F5 PRG:02F5 20 24 C5
jsr $C7D7 ; CPU:$C2F8 PRG:02F8 20 D7 C7
jsr $CA8A ; CPU:$C2FB PRG:02FB 20 8A CA
; -----------------------------------------------------------------------------
; Routine: CheckAnyButtonHeld
; Global: Tests the controller byte against each button mask and branches if any are held.
; Local: Branches to UpdateOamFromButtons when a button is active.
; Parameters: None.
; Returns: Z flag reflects the test.
; Clobbers: A.
; -----------------------------------------------------------------------------
CheckAnyButtonHeld:
lda #$00 ; CPU:$C2FE PRG:02FE A9 00
cmp Zp40 ; CPU:$C300 PRG:0300 C5 40
bne UpdateOamFromButtons ; CPU:$C302 PRG:0302 D0 11
cmp Zp41 ; CPU:$C304 PRG:0304 C5 41
bne UpdateOamFromButtons ; CPU:$C306 PRG:0306 D0 0D
cmp Zp43 ; CPU:$C308 PRG:0308 C5 43
bne UpdateOamFromButtons ; CPU:$C30A PRG:030A D0 09
cmp Zp44 ; CPU:$C30C PRG:030C C5 44
bne UpdateOamFromButtons ; CPU:$C30E PRG:030E D0 05
lda #$C0 ; CPU:$C310 PRG:0310 A9 C0
sta APUSTATUS ; CPU:$C312 PRG:0312 8D 15 40
; -----------------------------------------------------------------------------
; Routine: UpdateOamFromButtons
; Global: Writes OAM entries for whichever buttons mode 88 sees as held.
; Local: Returns to the mode-88 frame loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF.
; -----------------------------------------------------------------------------
UpdateOamFromButtons:
ldy #$00 ; CPU:$C315 PRG:0315 A0 00
ldx #$00 ; CPU:$C317 PRG:0317 A2 00
jsr $C361 ; CPU:$C319 PRG:0319 20 61 C3
ldy #$20 ; CPU:$C31C PRG:031C A0 20
inx ; CPU:$C31E PRG:031E E8
jsr $C361 ; CPU:$C31F PRG:031F 20 61 C3
ldy #$40 ; CPU:$C322 PRG:0322 A0 40
inx ; CPU:$C324 PRG:0324 E8
inx ; CPU:$C325 PRG:0325 E8
jsr $C361 ; CPU:$C326 PRG:0326 20 61 C3
ldy #$60 ; CPU:$C329 PRG:0329 A0 60
inx ; CPU:$C32B PRG:032B E8
jsr $C361 ; CPU:$C32C PRG:032C 20 61 C3
lda #$FF ; CPU:$C32F PRG:032F A9 FF
cmp Zp4E ; CPU:$C331 PRG:0331 C5 4E
bne IncrementFrameCounterAlt ; CPU:$C333 PRG:0333 D0 0F
cmp Zp4F ; CPU:$C335 PRG:0335 C5 4F
bne IncrementFrameCounterAlt ; CPU:$C337 PRG:0337 D0 0B
cmp Zp51 ; CPU:$C339 PRG:0339 C5 51
bne IncrementFrameCounterAlt ; CPU:$C33B PRG:033B D0 07
cmp Zp52 ; CPU:$C33D PRG:033D C5 52
bne IncrementFrameCounterAlt ; CPU:$C33F PRG:033F D0 03
jmp $C1A0 ; CPU:$C341 PRG:0341 4C A0 C1
; -----------------------------------------------------------------------------
; Routine: IncrementFrameCounterAlt
; Global: Mode-88 copy of the 16-bit frame counter increment.
; Local: Falls through to CheckFrameCounterLimitAlt.
; Parameters: None.
; Returns: Counter advanced.
; Clobbers: FrameCounterLo/Hi.
; -----------------------------------------------------------------------------
IncrementFrameCounterAlt:
inc Zp54 ; CPU:$C344 PRG:0344 E6 54
bne CheckFrameCounterLimitAlt ; CPU:$C346 PRG:0346 D0 02
inc Zp53 ; CPU:$C348 PRG:0348 E6 53
; -----------------------------------------------------------------------------
; Routine: CheckFrameCounterLimitAlt
; Global: Mode-88 copy of the frame-counter timeout test.
; Local: Branches onward or exits to InitTestScreen.
; Parameters: None.
; Returns: Z flag reflects the comparison.
; Clobbers: A.
; -----------------------------------------------------------------------------
CheckFrameCounterLimitAlt:
lda #$00 ; CPU:$C34A PRG:034A A9 00
cmp Zp54 ; CPU:$C34C PRG:034C C5 54
bne SetBurstWriteIndex ; CPU:$C34E PRG:034E D0 06
lda #$38 ; CPU:$C350 PRG:0350 A9 38
cmp Zp53 ; CPU:$C352 PRG:0352 C5 53
beq ExitToInitAlt ; CPU:$C354 PRG:0354 F0 08
; -----------------------------------------------------------------------------
; Routine: SetBurstWriteIndex
; Global: Stores the burst command index $22 so the next VRAM burst starts from the right entry.
; Local: Jumps back into the mode-88 frame loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A; VramBurstIndex.
; -----------------------------------------------------------------------------
SetBurstWriteIndex:
lda #$22 ; CPU:$C356 PRG:0356 A9 22
sta VramBurstIndex ; CPU:$C358 PRG:0358 8D 02 03
jmp $C2E4 ; CPU:$C35B PRG:035B 4C E4 C2
; -----------------------------------------------------------------------------
; Routine: ExitToInitAlt
; Global: Jumps back to InitTestScreen from the mode-88 loop.
; Local: Jumps; does not return.
; Parameters: None.
; Returns: Nothing.
; Clobbers: None.
; -----------------------------------------------------------------------------
ExitToInitAlt:
jmp $C055 ; CPU:$C35E PRG:035E 4C 55 C0
; -----------------------------------------------------------------------------
; Routine: DispatchButtonBits
; Global: Walks the eight bits of the controller byte and calls the matching handler for each one that is set, writing an OAM entry and triggering an APU write per pressed button.
; Local: Returns to FinishButtonDispatch once all eight bits are visited.
; Parameters: X = button index; Y = OAM offset.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF, $4015.
; -----------------------------------------------------------------------------
DispatchButtonBits:
lda Zp40,x ; CPU:$C361 PRG:0361 B5 40
pha ; CPU:$C363 PRG:0363 48
jsr $CAB8 ; CPU:$C364 PRG:0364 20 B8 CA
rol Zp40,x ; CPU:$C367 PRG:0367 36 40
bcc ButtonBit0_Test ; CPU:$C369 PRG:0369 90 0C
ror Zp40,x ; CPU:$C36B PRG:036B 76 40
rol Zp65,x ; CPU:$C36D PRG:036D 36 65
bcs ButtonBit1_Test ; CPU:$C36F PRG:036F B0 0F
inc Zp56,x ; CPU:$C371 PRG:0371 F6 56
sec ; CPU:$C373 PRG:0373 38
jmp $C380 ; CPU:$C374 PRG:0374 4C 80 C3
; -----------------------------------------------------------------------------
; Routine: ButtonBit0_Test
; Global: Tests controller bit 0 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit0_Test:
ror Zp40,x ; CPU:$C377 PRG:0377 76 40
rol Zp65,x ; CPU:$C379 PRG:0379 36 65
bcc ButtonBit1_Test ; CPU:$C37B PRG:037B 90 03
inc Zp56,x ; CPU:$C37D PRG:037D F6 56
clc ; CPU:$C37F PRG:037F 18
; -----------------------------------------------------------------------------
; Routine: ButtonBit1_Test
; Global: Tests controller bit 1 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit1_Test:
ror Zp65,x ; CPU:$C380 PRG:0380 76 65
rol Zp40,x ; CPU:$C382 PRG:0382 36 40
bcc ButtonBit2_Test ; CPU:$C384 PRG:0384 90 24
lda #$01 ; CPU:$C386 PRG:0386 A9 01
and APUSTATUS ; CPU:$C388 PRG:0388 2D 15 40
bne HandleButtonPress1 ; CPU:$C38B PRG:038B D0 0F
lda #$01 ; CPU:$C38D PRG:038D A9 01
sta APUSTATUS ; CPU:$C38F PRG:038F 8D 15 40
lda #$FD ; CPU:$C392 PRG:0392 A9 FD
sta APUPULSE1TIMERLO ; CPU:$C394 PRG:0394 8D 02 40
lda #$29 ; CPU:$C397 PRG:0397 A9 29
sta APUPULSE1TIMERHI ; CPU:$C399 PRG:0399 8D 03 40
; -----------------------------------------------------------------------------
; Routine: HandleButtonPress1
; Global: Handler for controller bit 1: writes an OAM tile and attribute entry for the pressed button and issues the matching APU write.
; Local: RTS once the OAM entry and APU write are done.
; Parameters: X = button index; Y = OAM offset.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF, $4015.
; -----------------------------------------------------------------------------
HandleButtonPress1:
lda #$02 ; CPU:$C39C PRG:039C A9 02
sta $0202,y ; CPU:$C39E PRG:039E 99 02 02
lda #$80 ; CPU:$C3A1 PRG:03A1 A9 80
ora Zp4E,x ; CPU:$C3A3 PRG:03A3 15 4E
sta Zp4E,x ; CPU:$C3A5 PRG:03A5 95 4E
jsr $CAB1 ; CPU:$C3A7 PRG:03A7 20 B1 CA
; -----------------------------------------------------------------------------
; Routine: ButtonBit2_Test
; Global: Tests controller bit 2 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit2_Test:
rol Zp40,x ; CPU:$C3AA PRG:03AA 36 40
bcc ButtonBit3_Test ; CPU:$C3AC PRG:03AC 90 0E
ror Zp40,x ; CPU:$C3AE PRG:03AE 76 40
rol Zp65,x ; CPU:$C3B0 PRG:03B0 36 65
rol Zp65,x ; CPU:$C3B2 PRG:03B2 36 65
bcs ButtonBit4_Test ; CPU:$C3B4 PRG:03B4 B0 11
inc Zp5B,x ; CPU:$C3B6 PRG:03B6 F6 5B
sec ; CPU:$C3B8 PRG:03B8 38
jmp $C3C7 ; CPU:$C3B9 PRG:03B9 4C C7 C3
; -----------------------------------------------------------------------------
; Routine: ButtonBit3_Test
; Global: Tests controller bit 3 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit3_Test:
ror Zp40,x ; CPU:$C3BC PRG:03BC 76 40
rol Zp65,x ; CPU:$C3BE PRG:03BE 36 65
rol Zp65,x ; CPU:$C3C0 PRG:03C0 36 65
bcc ButtonBit4_Test ; CPU:$C3C2 PRG:03C2 90 03
inc Zp5B,x ; CPU:$C3C4 PRG:03C4 F6 5B
clc ; CPU:$C3C6 PRG:03C6 18
; -----------------------------------------------------------------------------
; Routine: ButtonBit4_Test
; Global: Tests controller bit 4 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit4_Test:
ror Zp65,x ; CPU:$C3C7 PRG:03C7 76 65
ror Zp65,x ; CPU:$C3C9 PRG:03C9 76 65
rol Zp40,x ; CPU:$C3CB PRG:03CB 36 40
bcc ButtonBit5_Test ; CPU:$C3CD PRG:03CD 90 24
lda #$01 ; CPU:$C3CF PRG:03CF A9 01
and APUSTATUS ; CPU:$C3D1 PRG:03D1 2D 15 40
bne HandleButtonPress2 ; CPU:$C3D4 PRG:03D4 D0 0F
lda #$01 ; CPU:$C3D6 PRG:03D6 A9 01
sta APUSTATUS ; CPU:$C3D8 PRG:03D8 8D 15 40
lda #$C5 ; CPU:$C3DB PRG:03DB A9 C5
sta APUPULSE1TIMERLO ; CPU:$C3DD PRG:03DD 8D 02 40
lda #$29 ; CPU:$C3E0 PRG:03E0 A9 29
sta APUPULSE1TIMERHI ; CPU:$C3E2 PRG:03E2 8D 03 40
; -----------------------------------------------------------------------------
; Routine: HandleButtonPress2
; Global: Handler for controller bit 2: writes an OAM tile and attribute entry for the pressed button and issues the matching APU write.
; Local: RTS once the OAM entry and APU write are done.
; Parameters: X = button index; Y = OAM offset.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF, $4015.
; -----------------------------------------------------------------------------
HandleButtonPress2:
lda #$02 ; CPU:$C3E5 PRG:03E5 A9 02
sta $0206,y ; CPU:$C3E7 PRG:03E7 99 06 02
lda #$40 ; CPU:$C3EA PRG:03EA A9 40
ora Zp4E,x ; CPU:$C3EC PRG:03EC 15 4E
sta Zp4E,x ; CPU:$C3EE PRG:03EE 95 4E
jsr $CAB1 ; CPU:$C3F0 PRG:03F0 20 B1 CA
; -----------------------------------------------------------------------------
; Routine: ButtonBit5_Test
; Global: Tests controller bit 5 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit5_Test:
rol Zp40,x ; CPU:$C3F3 PRG:03F3 36 40
bcc ButtonBit6_Test ; CPU:$C3F5 PRG:03F5 90 24
lda #$01 ; CPU:$C3F7 PRG:03F7 A9 01
and APUSTATUS ; CPU:$C3F9 PRG:03F9 2D 15 40
bne HandleButtonPress3 ; CPU:$C3FC PRG:03FC D0 0F
lda #$01 ; CPU:$C3FE PRG:03FE A9 01
sta APUSTATUS ; CPU:$C400 PRG:0400 8D 15 40
lda #$7D ; CPU:$C403 PRG:0403 A9 7D
sta APUPULSE1TIMERLO ; CPU:$C405 PRG:0405 8D 02 40
lda #$29 ; CPU:$C408 PRG:0408 A9 29
sta APUPULSE1TIMERHI ; CPU:$C40A PRG:040A 8D 03 40
; -----------------------------------------------------------------------------
; Routine: HandleButtonPress3
; Global: Handler for controller bit 3: writes an OAM tile and attribute entry for the pressed button and issues the matching APU write.
; Local: RTS once the OAM entry and APU write are done.
; Parameters: X = button index; Y = OAM offset.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF, $4015.
; -----------------------------------------------------------------------------
HandleButtonPress3:
lda #$02 ; CPU:$C40D PRG:040D A9 02
sta $020E,y ; CPU:$C40F PRG:040F 99 0E 02
lda #$20 ; CPU:$C412 PRG:0412 A9 20
ora Zp4E,x ; CPU:$C414 PRG:0414 15 4E
sta Zp4E,x ; CPU:$C416 PRG:0416 95 4E
jsr $CAB1 ; CPU:$C418 PRG:0418 20 B1 CA
; -----------------------------------------------------------------------------
; Routine: ButtonBit6_Test
; Global: Tests controller bit 6 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit6_Test:
rol Zp40,x ; CPU:$C41B PRG:041B 36 40
bcc ButtonBit7_Test ; CPU:$C41D PRG:041D 90 10
ror Zp40,x ; CPU:$C41F PRG:041F 76 40
rol Zp65,x ; CPU:$C421 PRG:0421 36 65
rol Zp65,x ; CPU:$C423 PRG:0423 36 65
rol Zp65,x ; CPU:$C425 PRG:0425 36 65
bcs ButtonBit8_Test ; CPU:$C427 PRG:0427 B0 13
inc Zp60,x ; CPU:$C429 PRG:0429 F6 60
sec ; CPU:$C42B PRG:042B 38
jmp $C43C ; CPU:$C42C PRG:042C 4C 3C C4
; -----------------------------------------------------------------------------
; Routine: ButtonBit7_Test
; Global: Tests controller bit 7 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit7_Test:
ror Zp40,x ; CPU:$C42F PRG:042F 76 40
rol Zp65,x ; CPU:$C431 PRG:0431 36 65
rol Zp65,x ; CPU:$C433 PRG:0433 36 65
rol Zp65,x ; CPU:$C435 PRG:0435 36 65
bcc ButtonBit8_Test ; CPU:$C437 PRG:0437 90 03
inc Zp60,x ; CPU:$C439 PRG:0439 F6 60
clc ; CPU:$C43B PRG:043B 18
; -----------------------------------------------------------------------------
; Routine: ButtonBit8_Test
; Global: Tests controller bit 8 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit8_Test:
ror Zp65,x ; CPU:$C43C PRG:043C 76 65
ror Zp65,x ; CPU:$C43E PRG:043E 76 65
ror Zp65,x ; CPU:$C440 PRG:0440 76 65
rol Zp40,x ; CPU:$C442 PRG:0442 36 40
bcc ButtonBit9_Test ; CPU:$C444 PRG:0444 90 24
lda #$01 ; CPU:$C446 PRG:0446 A9 01
and APUSTATUS ; CPU:$C448 PRG:0448 2D 15 40
bne HandleButtonPress4 ; CPU:$C44B PRG:044B D0 0F
lda #$01 ; CPU:$C44D PRG:044D A9 01
sta APUSTATUS ; CPU:$C44F PRG:044F 8D 15 40
lda #$94 ; CPU:$C452 PRG:0452 A9 94
sta APUPULSE1TIMERLO ; CPU:$C454 PRG:0454 8D 02 40
lda #$29 ; CPU:$C457 PRG:0457 A9 29
sta APUPULSE1TIMERHI ; CPU:$C459 PRG:0459 8D 03 40
; -----------------------------------------------------------------------------
; Routine: HandleButtonPress4
; Global: Handler for controller bit 4: writes an OAM tile and attribute entry for the pressed button and issues the matching APU write.
; Local: RTS once the OAM entry and APU write are done.
; Parameters: X = button index; Y = OAM offset.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF, $4015.
; -----------------------------------------------------------------------------
HandleButtonPress4:
lda #$02 ; CPU:$C45C PRG:045C A9 02
sta $020A,y ; CPU:$C45E PRG:045E 99 0A 02
lda #$10 ; CPU:$C461 PRG:0461 A9 10
ora Zp4E,x ; CPU:$C463 PRG:0463 15 4E
sta Zp4E,x ; CPU:$C465 PRG:0465 95 4E
jsr $CAB1 ; CPU:$C467 PRG:0467 20 B1 CA
; -----------------------------------------------------------------------------
; Routine: ButtonBit9_Test
; Global: Tests controller bit 9 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit9_Test:
rol Zp40,x ; CPU:$C46A PRG:046A 36 40
bcc ButtonBit10_Test ; CPU:$C46C PRG:046C 90 24
lda #$01 ; CPU:$C46E PRG:046E A9 01
and APUSTATUS ; CPU:$C470 PRG:0470 2D 15 40
bne HandleButtonPress5 ; CPU:$C473 PRG:0473 D0 0F
lda #$01 ; CPU:$C475 PRG:0475 A9 01
sta APUSTATUS ; CPU:$C477 PRG:0477 8D 15 40
lda #$53 ; CPU:$C47A PRG:047A A9 53
sta APUPULSE1TIMERLO ; CPU:$C47C PRG:047C 8D 02 40
lda #$29 ; CPU:$C47F PRG:047F A9 29
sta APUPULSE1TIMERHI ; CPU:$C481 PRG:0481 8D 03 40
; -----------------------------------------------------------------------------
; Routine: HandleButtonPress5
; Global: Handler for controller bit 5: writes an OAM tile and attribute entry for the pressed button and issues the matching APU write.
; Local: RTS once the OAM entry and APU write are done.
; Parameters: X = button index; Y = OAM offset.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF, $4015.
; -----------------------------------------------------------------------------
HandleButtonPress5:
lda #$02 ; CPU:$C484 PRG:0484 A9 02
sta $0212,y ; CPU:$C486 PRG:0486 99 12 02
lda #$08 ; CPU:$C489 PRG:0489 A9 08
ora Zp4E,x ; CPU:$C48B PRG:048B 15 4E
sta Zp4E,x ; CPU:$C48D PRG:048D 95 4E
jsr $CAB1 ; CPU:$C48F PRG:048F 20 B1 CA
; -----------------------------------------------------------------------------
; Routine: ButtonBit10_Test
; Global: Tests controller bit 10 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit10_Test:
rol Zp40,x ; CPU:$C492 PRG:0492 36 40
bcc ButtonBit11_Test ; CPU:$C494 PRG:0494 90 24
lda #$01 ; CPU:$C496 PRG:0496 A9 01
and APUSTATUS ; CPU:$C498 PRG:0498 2D 15 40
bne HandleButtonPress6 ; CPU:$C49B PRG:049B D0 0F
lda #$01 ; CPU:$C49D PRG:049D A9 01
sta APUSTATUS ; CPU:$C49F PRG:049F 8D 15 40
lda #$2E ; CPU:$C4A2 PRG:04A2 A9 2E
sta APUPULSE1TIMERLO ; CPU:$C4A4 PRG:04A4 8D 02 40
lda #$29 ; CPU:$C4A7 PRG:04A7 A9 29
sta APUPULSE1TIMERHI ; CPU:$C4A9 PRG:04A9 8D 03 40
; -----------------------------------------------------------------------------
; Routine: HandleButtonPress6
; Global: Handler for controller bit 6: writes an OAM tile and attribute entry for the pressed button and issues the matching APU write.
; Local: RTS once the OAM entry and APU write are done.
; Parameters: X = button index; Y = OAM offset.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF, $4015.
; -----------------------------------------------------------------------------
HandleButtonPress6:
lda #$02 ; CPU:$C4AC PRG:04AC A9 02
sta $0216,y ; CPU:$C4AE PRG:04AE 99 16 02
lda #$04 ; CPU:$C4B1 PRG:04B1 A9 04
ora Zp4E,x ; CPU:$C4B3 PRG:04B3 15 4E
sta Zp4E,x ; CPU:$C4B5 PRG:04B5 95 4E
jsr $CAB1 ; CPU:$C4B7 PRG:04B7 20 B1 CA
; -----------------------------------------------------------------------------
; Routine: ButtonBit11_Test
; Global: Tests controller bit 11 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit11_Test:
rol Zp40,x ; CPU:$C4BA PRG:04BA 36 40
bcc ButtonBit12_Test ; CPU:$C4BC PRG:04BC 90 24
lda #$01 ; CPU:$C4BE PRG:04BE A9 01
and APUSTATUS ; CPU:$C4C0 PRG:04C0 2D 15 40
bne HandleButtonPress7 ; CPU:$C4C3 PRG:04C3 D0 0F
lda #$01 ; CPU:$C4C5 PRG:04C5 A9 01
sta APUSTATUS ; CPU:$C4C7 PRG:04C7 8D 15 40
lda #$0D ; CPU:$C4CA PRG:04CA A9 0D
sta APUPULSE1TIMERLO ; CPU:$C4CC PRG:04CC 8D 02 40
lda #$29 ; CPU:$C4CF PRG:04CF A9 29
sta APUPULSE1TIMERHI ; CPU:$C4D1 PRG:04D1 8D 03 40
; -----------------------------------------------------------------------------
; Routine: HandleButtonPress7
; Global: Handler for controller bit 7: writes an OAM tile and attribute entry for the pressed button and issues the matching APU write.
; Local: RTS once the OAM entry and APU write are done.
; Parameters: X = button index; Y = OAM offset.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF, $4015.
; -----------------------------------------------------------------------------
HandleButtonPress7:
lda #$02 ; CPU:$C4D4 PRG:04D4 A9 02
sta $021A,y ; CPU:$C4D6 PRG:04D6 99 1A 02
lda #$02 ; CPU:$C4D9 PRG:04D9 A9 02
ora Zp4E,x ; CPU:$C4DB PRG:04DB 15 4E
sta Zp4E,x ; CPU:$C4DD PRG:04DD 95 4E
jsr $CAB1 ; CPU:$C4DF PRG:04DF 20 B1 CA
; -----------------------------------------------------------------------------
; Routine: ButtonBit12_Test
; Global: Tests controller bit 12 of the button byte by rotating it through carry, and branches to the next bit when clear.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ButtonBit12_Test:
rol Zp40,x ; CPU:$C4E2 PRG:04E2 36 40
bcc FinishButtonDispatch ; CPU:$C4E4 PRG:04E4 90 24
lda #$01 ; CPU:$C4E6 PRG:04E6 A9 01
and APUSTATUS ; CPU:$C4E8 PRG:04E8 2D 15 40
bne HandleButtonPress8 ; CPU:$C4EB PRG:04EB D0 0F
lda #$01 ; CPU:$C4ED PRG:04ED A9 01
sta APUSTATUS ; CPU:$C4EF PRG:04EF 8D 15 40
lda #$FE ; CPU:$C4F2 PRG:04F2 A9 FE
sta APUPULSE1TIMERLO ; CPU:$C4F4 PRG:04F4 8D 02 40
lda #$28 ; CPU:$C4F7 PRG:04F7 A9 28
sta APUPULSE1TIMERHI ; CPU:$C4F9 PRG:04F9 8D 03 40
; -----------------------------------------------------------------------------
; Routine: HandleButtonPress8
; Global: Handler for controller bit 8: writes an OAM tile and attribute entry for the pressed button and issues the matching APU write.
; Local: RTS once the OAM entry and APU write are done.
; Parameters: X = button index; Y = OAM offset.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF, $4015.
; -----------------------------------------------------------------------------
HandleButtonPress8:
lda #$02 ; CPU:$C4FC PRG:04FC A9 02
sta $021E,y ; CPU:$C4FE PRG:04FE 99 1E 02
lda #$01 ; CPU:$C501 PRG:0501 A9 01
ora Zp4E,x ; CPU:$C503 PRG:0503 15 4E
sta Zp4E,x ; CPU:$C505 PRG:0505 95 4E
jsr $CAB1 ; CPU:$C507 PRG:0507 20 B1 CA
; -----------------------------------------------------------------------------
; Routine: FinishButtonDispatch
; Global: Stores the surviving button state back and masks the bits that have been consumed before returning.
; Local: RTS.
; Parameters: None.
; Returns: Button state updated.
; Clobbers: A, X; button state array.
; -----------------------------------------------------------------------------
FinishButtonDispatch:
pla ; CPU:$C50A PRG:050A 68
sta Zp40,x ; CPU:$C50B PRG:050B 95 40
lda #$0C ; CPU:$C50D PRG:050D A9 0C
and Zp40,x ; CPU:$C50F PRG:050F 35 40
cmp #$0C ; CPU:$C511 PRG:0511 C9 0C
beq CallPrepareButtonOam ; CPU:$C513 PRG:0513 F0 0B
lda #$03 ; CPU:$C515 PRG:0515 A9 03
and Zp40,x ; CPU:$C517 PRG:0517 35 40
cmp #$03 ; CPU:$C519 PRG:0519 C9 03
beq CallPrepareButtonOam ; CPU:$C51B PRG:051B F0 03
jmp $C523 ; CPU:$C51D PRG:051D 4C 23 C5
; -----------------------------------------------------------------------------
; Routine: CallPrepareButtonOam
; Global: Calls PrepareButtonOam and returns.
; Local: RTS.
; Parameters: None.
; Returns: OAM shadow primed.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
CallPrepareButtonOam:
jsr $C1EE ; CPU:$C520 PRG:0520 20 EE C1
; -----------------------------------------------------------------------------
; Routine: ReturnFromPrepareButtonOam
; Global: RTS.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: None.
; -----------------------------------------------------------------------------
ReturnFromPrepareButtonOam:
rts ; CPU:$C523 PRG:0523 60
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate1
; Global: Marker update group 1 for MarkerVar01. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate1:
lda Zp60 ; CPU:$C524 PRG:0524 A5 60
cmp #$04 ; CPU:$C526 PRG:0526 C9 04
bmi MarkerUpdate1_High ; CPU:$C528 PRG:0528 30 3A
lda Zp60 ; CPU:$C52A PRG:052A A5 60
clc ; CPU:$C52C PRG:052C 18
sbc #$04 ; CPU:$C52D PRG:052D E9 04
sta Zp60 ; CPU:$C52F PRG:052F 85 60
lda #$F4 ; CPU:$C531 PRG:0531 A9 F4
sta $028D ; CPU:$C533 PRG:0533 8D 8D 02
lda Zp60 ; CPU:$C536 PRG:0536 A5 60
cmp #$04 ; CPU:$C538 PRG:0538 C9 04
bmi MarkerUpdate1_Mid ; CPU:$C53A PRG:053A 30 3D
lda Zp60 ; CPU:$C53C PRG:053C A5 60
clc ; CPU:$C53E PRG:053E 18
sbc #$04 ; CPU:$C53F PRG:053F E9 04
sta Zp60 ; CPU:$C541 PRG:0541 85 60
lda #$D4 ; CPU:$C543 PRG:0543 A9 D4
sta $0289 ; CPU:$C545 PRG:0545 8D 89 02
lda Zp60 ; CPU:$C548 PRG:0548 A5 60
cmp #$04 ; CPU:$C54A PRG:054A C9 04
bmi MarkerUpdate1_Low ; CPU:$C54C PRG:054C 30 3D
lda Zp60 ; CPU:$C54E PRG:054E A5 60
clc ; CPU:$C550 PRG:0550 18
sbc #$04 ; CPU:$C551 PRG:0551 E9 04
sta Zp60 ; CPU:$C553 PRG:0553 85 60
lda #$D4 ; CPU:$C555 PRG:0555 A9 D4
sta $0285 ; CPU:$C557 PRG:0557 8D 85 02
lda #$E0 ; CPU:$C55A PRG:055A A9 E0
ora Zp60 ; CPU:$C55C PRG:055C 05 60
sta $0281 ; CPU:$C55E PRG:055E 8D 81 02
jmp $C597 ; CPU:$C561 PRG:0561 4C 97 C5
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate1_High
; Global: Marker update group 1 entry for the high variant: ORs $F0 into MarkerVar01 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate1_High:
lda #$F0 ; CPU:$C564 PRG:0564 A9 F0
ora Zp60 ; CPU:$C566 PRG:0566 05 60
sta $028D ; CPU:$C568 PRG:0568 8D 8D 02
lda #$30 ; CPU:$C56B PRG:056B A9 30
sta $0289 ; CPU:$C56D PRG:056D 8D 89 02
sta $0285 ; CPU:$C570 PRG:0570 8D 85 02
sta $0281 ; CPU:$C573 PRG:0573 8D 81 02
jmp $C597 ; CPU:$C576 PRG:0576 4C 97 C5
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate1_Mid
; Global: Marker update group 1 entry for the mid variant: ORs $D0 into MarkerVar01 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate1_Mid:
lda #$D0 ; CPU:$C579 PRG:0579 A9 D0
ora Zp60 ; CPU:$C57B PRG:057B 05 60
sta $0289 ; CPU:$C57D PRG:057D 8D 89 02
lda #$30 ; CPU:$C580 PRG:0580 A9 30
sta $0285 ; CPU:$C582 PRG:0582 8D 85 02
sta $0281 ; CPU:$C585 PRG:0585 8D 81 02
jmp $C597 ; CPU:$C588 PRG:0588 4C 97 C5
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate1_Low
; Global: Marker update group 1 entry for the low variant: ORs $D0 into MarkerVar01 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate1_Low:
lda #$D0 ; CPU:$C58B PRG:058B A9 D0
ora Zp60 ; CPU:$C58D PRG:058D 05 60
sta $0285 ; CPU:$C58F PRG:058F 8D 85 02
lda #$30 ; CPU:$C592 PRG:0592 A9 30
sta $0281 ; CPU:$C594 PRG:0594 8D 81 02
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate2
; Global: Marker update group 2 for MarkerVar02. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate2:
lda Zp5B ; CPU:$C597 PRG:0597 A5 5B
cmp #$04 ; CPU:$C599 PRG:0599 C9 04
bmi MarkerUpdate2_High ; CPU:$C59B PRG:059B 30 3A
lda Zp5B ; CPU:$C59D PRG:059D A5 5B
clc ; CPU:$C59F PRG:059F 18
sbc #$04 ; CPU:$C5A0 PRG:05A0 E9 04
sta Zp5B ; CPU:$C5A2 PRG:05A2 85 5B
lda #$F4 ; CPU:$C5A4 PRG:05A4 A9 F4
sta $029D ; CPU:$C5A6 PRG:05A6 8D 9D 02
lda Zp5B ; CPU:$C5A9 PRG:05A9 A5 5B
cmp #$04 ; CPU:$C5AB PRG:05AB C9 04
bmi MarkerUpdate2_Mid ; CPU:$C5AD PRG:05AD 30 3D
lda Zp5B ; CPU:$C5AF PRG:05AF A5 5B
clc ; CPU:$C5B1 PRG:05B1 18
sbc #$04 ; CPU:$C5B2 PRG:05B2 E9 04
sta Zp5B ; CPU:$C5B4 PRG:05B4 85 5B
lda #$D4 ; CPU:$C5B6 PRG:05B6 A9 D4
sta $0299 ; CPU:$C5B8 PRG:05B8 8D 99 02
lda Zp5B ; CPU:$C5BB PRG:05BB A5 5B
cmp #$04 ; CPU:$C5BD PRG:05BD C9 04
bmi MarkerUpdate2_Low ; CPU:$C5BF PRG:05BF 30 3D
lda Zp5B ; CPU:$C5C1 PRG:05C1 A5 5B
clc ; CPU:$C5C3 PRG:05C3 18
sbc #$04 ; CPU:$C5C4 PRG:05C4 E9 04
sta Zp5B ; CPU:$C5C6 PRG:05C6 85 5B
lda #$D4 ; CPU:$C5C8 PRG:05C8 A9 D4
sta $0295 ; CPU:$C5CA PRG:05CA 8D 95 02
lda #$E0 ; CPU:$C5CD PRG:05CD A9 E0
ora Zp5B ; CPU:$C5CF PRG:05CF 05 5B
sta $0291 ; CPU:$C5D1 PRG:05D1 8D 91 02
jmp $C60A ; CPU:$C5D4 PRG:05D4 4C 0A C6
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate2_High
; Global: Marker update group 2 entry for the high variant: ORs $F0 into MarkerVar02 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate2_High:
lda #$F0 ; CPU:$C5D7 PRG:05D7 A9 F0
ora Zp5B ; CPU:$C5D9 PRG:05D9 05 5B
sta $029D ; CPU:$C5DB PRG:05DB 8D 9D 02
lda #$30 ; CPU:$C5DE PRG:05DE A9 30
sta $0299 ; CPU:$C5E0 PRG:05E0 8D 99 02
sta $0295 ; CPU:$C5E3 PRG:05E3 8D 95 02
sta $0291 ; CPU:$C5E6 PRG:05E6 8D 91 02
jmp $C60A ; CPU:$C5E9 PRG:05E9 4C 0A C6
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate2_Mid
; Global: Marker update group 2 entry for the mid variant: ORs $D0 into MarkerVar02 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate2_Mid:
lda #$D0 ; CPU:$C5EC PRG:05EC A9 D0
ora Zp5B ; CPU:$C5EE PRG:05EE 05 5B
sta $0299 ; CPU:$C5F0 PRG:05F0 8D 99 02
lda #$30 ; CPU:$C5F3 PRG:05F3 A9 30
sta $0295 ; CPU:$C5F5 PRG:05F5 8D 95 02
sta $0291 ; CPU:$C5F8 PRG:05F8 8D 91 02
jmp $C60A ; CPU:$C5FB PRG:05FB 4C 0A C6
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate2_Low
; Global: Marker update group 2 entry for the low variant: ORs $D0 into MarkerVar02 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate2_Low:
lda #$D0 ; CPU:$C5FE PRG:05FE A9 D0
ora Zp5B ; CPU:$C600 PRG:0600 05 5B
sta $0295 ; CPU:$C602 PRG:0602 8D 95 02
lda #$30 ; CPU:$C605 PRG:0605 A9 30
sta $0291 ; CPU:$C607 PRG:0607 8D 91 02
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate3
; Global: Marker update group 3 for MarkerVar03. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate3:
lda Zp56 ; CPU:$C60A PRG:060A A5 56
cmp #$04 ; CPU:$C60C PRG:060C C9 04
bmi MarkerUpdate3_High ; CPU:$C60E PRG:060E 30 3A
lda Zp56 ; CPU:$C610 PRG:0610 A5 56
clc ; CPU:$C612 PRG:0612 18
sbc #$04 ; CPU:$C613 PRG:0613 E9 04
sta Zp56 ; CPU:$C615 PRG:0615 85 56
lda #$F4 ; CPU:$C617 PRG:0617 A9 F4
sta $02AD ; CPU:$C619 PRG:0619 8D AD 02
lda Zp56 ; CPU:$C61C PRG:061C A5 56
cmp #$04 ; CPU:$C61E PRG:061E C9 04
bmi MarkerUpdate3_Mid ; CPU:$C620 PRG:0620 30 3D
lda Zp56 ; CPU:$C622 PRG:0622 A5 56
clc ; CPU:$C624 PRG:0624 18
sbc #$04 ; CPU:$C625 PRG:0625 E9 04
sta Zp56 ; CPU:$C627 PRG:0627 85 56
lda #$D4 ; CPU:$C629 PRG:0629 A9 D4
sta $02A9 ; CPU:$C62B PRG:062B 8D A9 02
lda Zp56 ; CPU:$C62E PRG:062E A5 56
cmp #$04 ; CPU:$C630 PRG:0630 C9 04
bmi MarkerUpdate3_Low ; CPU:$C632 PRG:0632 30 3D
lda Zp56 ; CPU:$C634 PRG:0634 A5 56
clc ; CPU:$C636 PRG:0636 18
sbc #$04 ; CPU:$C637 PRG:0637 E9 04
sta Zp56 ; CPU:$C639 PRG:0639 85 56
lda #$D4 ; CPU:$C63B PRG:063B A9 D4
sta $02A5 ; CPU:$C63D PRG:063D 8D A5 02
lda #$E0 ; CPU:$C640 PRG:0640 A9 E0
ora Zp56 ; CPU:$C642 PRG:0642 05 56
sta $02A1 ; CPU:$C644 PRG:0644 8D A1 02
jmp $C67D ; CPU:$C647 PRG:0647 4C 7D C6
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate3_High
; Global: Marker update group 3 entry for the high variant: ORs $F0 into MarkerVar03 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate3_High:
lda #$F0 ; CPU:$C64A PRG:064A A9 F0
ora Zp56 ; CPU:$C64C PRG:064C 05 56
sta $02AD ; CPU:$C64E PRG:064E 8D AD 02
lda #$30 ; CPU:$C651 PRG:0651 A9 30
sta $02A9 ; CPU:$C653 PRG:0653 8D A9 02
sta $02A5 ; CPU:$C656 PRG:0656 8D A5 02
sta $02A1 ; CPU:$C659 PRG:0659 8D A1 02
jmp $C67D ; CPU:$C65C PRG:065C 4C 7D C6
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate3_Mid
; Global: Marker update group 3 entry for the mid variant: ORs $D0 into MarkerVar03 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate3_Mid:
lda #$D0 ; CPU:$C65F PRG:065F A9 D0
ora Zp56 ; CPU:$C661 PRG:0661 05 56
sta $02A9 ; CPU:$C663 PRG:0663 8D A9 02
lda #$30 ; CPU:$C666 PRG:0666 A9 30
sta $02A5 ; CPU:$C668 PRG:0668 8D A5 02
sta $02A1 ; CPU:$C66B PRG:066B 8D A1 02
jmp $C67D ; CPU:$C66E PRG:066E 4C 7D C6
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate3_Low
; Global: Marker update group 3 entry for the low variant: ORs $D0 into MarkerVar03 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate3_Low:
lda #$D0 ; CPU:$C671 PRG:0671 A9 D0
ora Zp56 ; CPU:$C673 PRG:0673 05 56
sta $02A5 ; CPU:$C675 PRG:0675 8D A5 02
lda #$30 ; CPU:$C678 PRG:0678 A9 30
sta $02A1 ; CPU:$C67A PRG:067A 8D A1 02
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate4
; Global: Marker update group 4 for MarkerVar04. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate4:
lda Zp61 ; CPU:$C67D PRG:067D A5 61
cmp #$04 ; CPU:$C67F PRG:067F C9 04
bmi MarkerUpdate4_High ; CPU:$C681 PRG:0681 30 3A
lda Zp61 ; CPU:$C683 PRG:0683 A5 61
clc ; CPU:$C685 PRG:0685 18
sbc #$04 ; CPU:$C686 PRG:0686 E9 04
sta Zp61 ; CPU:$C688 PRG:0688 85 61
lda #$F4 ; CPU:$C68A PRG:068A A9 F4
sta $02BD ; CPU:$C68C PRG:068C 8D BD 02
lda Zp61 ; CPU:$C68F PRG:068F A5 61
cmp #$04 ; CPU:$C691 PRG:0691 C9 04
bmi MarkerUpdate4_Mid ; CPU:$C693 PRG:0693 30 3D
lda Zp61 ; CPU:$C695 PRG:0695 A5 61
clc ; CPU:$C697 PRG:0697 18
sbc #$04 ; CPU:$C698 PRG:0698 E9 04
sta Zp61 ; CPU:$C69A PRG:069A 85 61
lda #$D4 ; CPU:$C69C PRG:069C A9 D4
sta $02B9 ; CPU:$C69E PRG:069E 8D B9 02
lda Zp61 ; CPU:$C6A1 PRG:06A1 A5 61
cmp #$04 ; CPU:$C6A3 PRG:06A3 C9 04
bmi MarkerUpdate4_Low ; CPU:$C6A5 PRG:06A5 30 3D
lda Zp61 ; CPU:$C6A7 PRG:06A7 A5 61
clc ; CPU:$C6A9 PRG:06A9 18
sbc #$04 ; CPU:$C6AA PRG:06AA E9 04
sta Zp61 ; CPU:$C6AC PRG:06AC 85 61
lda #$D4 ; CPU:$C6AE PRG:06AE A9 D4
sta $02B5 ; CPU:$C6B0 PRG:06B0 8D B5 02
lda #$E0 ; CPU:$C6B3 PRG:06B3 A9 E0
ora Zp61 ; CPU:$C6B5 PRG:06B5 05 61
sta $02B1 ; CPU:$C6B7 PRG:06B7 8D B1 02
jmp $C6F0 ; CPU:$C6BA PRG:06BA 4C F0 C6
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate4_High
; Global: Marker update group 4 entry for the high variant: ORs $F0 into MarkerVar04 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate4_High:
lda #$F0 ; CPU:$C6BD PRG:06BD A9 F0
ora Zp61 ; CPU:$C6BF PRG:06BF 05 61
sta $02BD ; CPU:$C6C1 PRG:06C1 8D BD 02
lda #$30 ; CPU:$C6C4 PRG:06C4 A9 30
sta $02B9 ; CPU:$C6C6 PRG:06C6 8D B9 02
sta $02B5 ; CPU:$C6C9 PRG:06C9 8D B5 02
sta $02B1 ; CPU:$C6CC PRG:06CC 8D B1 02
jmp $C6F0 ; CPU:$C6CF PRG:06CF 4C F0 C6
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate4_Mid
; Global: Marker update group 4 entry for the mid variant: ORs $D0 into MarkerVar04 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate4_Mid:
lda #$D0 ; CPU:$C6D2 PRG:06D2 A9 D0
ora Zp61 ; CPU:$C6D4 PRG:06D4 05 61
sta $02B9 ; CPU:$C6D6 PRG:06D6 8D B9 02
lda #$30 ; CPU:$C6D9 PRG:06D9 A9 30
sta $02B5 ; CPU:$C6DB PRG:06DB 8D B5 02
sta $02B1 ; CPU:$C6DE PRG:06DE 8D B1 02
jmp $C6F0 ; CPU:$C6E1 PRG:06E1 4C F0 C6
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate4_Low
; Global: Marker update group 4 entry for the low variant: ORs $D0 into MarkerVar04 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate4_Low:
lda #$D0 ; CPU:$C6E4 PRG:06E4 A9 D0
ora Zp61 ; CPU:$C6E6 PRG:06E6 05 61
sta $02B5 ; CPU:$C6E8 PRG:06E8 8D B5 02
lda #$30 ; CPU:$C6EB PRG:06EB A9 30
sta $02B1 ; CPU:$C6ED PRG:06ED 8D B1 02
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate5
; Global: Marker update group 5 for MarkerVar05. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate5:
lda Zp5C ; CPU:$C6F0 PRG:06F0 A5 5C
cmp #$04 ; CPU:$C6F2 PRG:06F2 C9 04
bmi MarkerUpdate5_High ; CPU:$C6F4 PRG:06F4 30 3A
lda Zp5C ; CPU:$C6F6 PRG:06F6 A5 5C
clc ; CPU:$C6F8 PRG:06F8 18
sbc #$04 ; CPU:$C6F9 PRG:06F9 E9 04
sta Zp5C ; CPU:$C6FB PRG:06FB 85 5C
lda #$F4 ; CPU:$C6FD PRG:06FD A9 F4
sta $02CD ; CPU:$C6FF PRG:06FF 8D CD 02
lda Zp5C ; CPU:$C702 PRG:0702 A5 5C
cmp #$04 ; CPU:$C704 PRG:0704 C9 04
bmi MarkerUpdate5_Mid ; CPU:$C706 PRG:0706 30 3D
lda Zp5C ; CPU:$C708 PRG:0708 A5 5C
clc ; CPU:$C70A PRG:070A 18
sbc #$04 ; CPU:$C70B PRG:070B E9 04
sta Zp5C ; CPU:$C70D PRG:070D 85 5C
lda #$D4 ; CPU:$C70F PRG:070F A9 D4
sta $02C9 ; CPU:$C711 PRG:0711 8D C9 02
lda Zp5C ; CPU:$C714 PRG:0714 A5 5C
cmp #$04 ; CPU:$C716 PRG:0716 C9 04
bmi MarkerUpdate5_Low ; CPU:$C718 PRG:0718 30 3D
lda Zp5C ; CPU:$C71A PRG:071A A5 5C
clc ; CPU:$C71C PRG:071C 18
sbc #$04 ; CPU:$C71D PRG:071D E9 04
sta Zp5C ; CPU:$C71F PRG:071F 85 5C
lda #$D4 ; CPU:$C721 PRG:0721 A9 D4
sta $02C5 ; CPU:$C723 PRG:0723 8D C5 02
lda #$E0 ; CPU:$C726 PRG:0726 A9 E0
ora Zp5C ; CPU:$C728 PRG:0728 05 5C
sta $02C1 ; CPU:$C72A PRG:072A 8D C1 02
jmp $C763 ; CPU:$C72D PRG:072D 4C 63 C7
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate5_High
; Global: Marker update group 5 entry for the high variant: ORs $F0 into MarkerVar05 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate5_High:
lda #$F0 ; CPU:$C730 PRG:0730 A9 F0
ora Zp5C ; CPU:$C732 PRG:0732 05 5C
sta $02CD ; CPU:$C734 PRG:0734 8D CD 02
lda #$30 ; CPU:$C737 PRG:0737 A9 30
sta $02C9 ; CPU:$C739 PRG:0739 8D C9 02
sta $02C5 ; CPU:$C73C PRG:073C 8D C5 02
sta $02C1 ; CPU:$C73F PRG:073F 8D C1 02
jmp $C763 ; CPU:$C742 PRG:0742 4C 63 C7
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate5_Mid
; Global: Marker update group 5 entry for the mid variant: ORs $D0 into MarkerVar05 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate5_Mid:
lda #$D0 ; CPU:$C745 PRG:0745 A9 D0
ora Zp5C ; CPU:$C747 PRG:0747 05 5C
sta $02C9 ; CPU:$C749 PRG:0749 8D C9 02
lda #$30 ; CPU:$C74C PRG:074C A9 30
sta $02C5 ; CPU:$C74E PRG:074E 8D C5 02
sta $02C1 ; CPU:$C751 PRG:0751 8D C1 02
jmp $C763 ; CPU:$C754 PRG:0754 4C 63 C7
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate5_Low
; Global: Marker update group 5 entry for the low variant: ORs $D0 into MarkerVar05 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate5_Low:
lda #$D0 ; CPU:$C757 PRG:0757 A9 D0
ora Zp5C ; CPU:$C759 PRG:0759 05 5C
sta $02C5 ; CPU:$C75B PRG:075B 8D C5 02
lda #$30 ; CPU:$C75E PRG:075E A9 30
sta $02C1 ; CPU:$C760 PRG:0760 8D C1 02
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate6
; Global: Marker update group 6 for MarkerVar06. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate6:
lda Zp57 ; CPU:$C763 PRG:0763 A5 57
cmp #$04 ; CPU:$C765 PRG:0765 C9 04
bmi MarkerUpdate6_High ; CPU:$C767 PRG:0767 30 3A
lda Zp57 ; CPU:$C769 PRG:0769 A5 57
clc ; CPU:$C76B PRG:076B 18
sbc #$04 ; CPU:$C76C PRG:076C E9 04
sta Zp57 ; CPU:$C76E PRG:076E 85 57
lda #$F4 ; CPU:$C770 PRG:0770 A9 F4
sta $02DD ; CPU:$C772 PRG:0772 8D DD 02
lda Zp57 ; CPU:$C775 PRG:0775 A5 57
cmp #$04 ; CPU:$C777 PRG:0777 C9 04
bmi MarkerUpdate6_Mid ; CPU:$C779 PRG:0779 30 3D
lda Zp57 ; CPU:$C77B PRG:077B A5 57
clc ; CPU:$C77D PRG:077D 18
sbc #$04 ; CPU:$C77E PRG:077E E9 04
sta Zp57 ; CPU:$C780 PRG:0780 85 57
lda #$D4 ; CPU:$C782 PRG:0782 A9 D4
sta $02D9 ; CPU:$C784 PRG:0784 8D D9 02
lda Zp57 ; CPU:$C787 PRG:0787 A5 57
cmp #$04 ; CPU:$C789 PRG:0789 C9 04
bmi MarkerUpdate6_Low ; CPU:$C78B PRG:078B 30 3D
lda Zp57 ; CPU:$C78D PRG:078D A5 57
clc ; CPU:$C78F PRG:078F 18
sbc #$04 ; CPU:$C790 PRG:0790 E9 04
sta Zp57 ; CPU:$C792 PRG:0792 85 57
lda #$D4 ; CPU:$C794 PRG:0794 A9 D4
sta $02D5 ; CPU:$C796 PRG:0796 8D D5 02
lda #$E0 ; CPU:$C799 PRG:0799 A9 E0
ora Zp57 ; CPU:$C79B PRG:079B 05 57
sta $02D1 ; CPU:$C79D PRG:079D 8D D1 02
jmp $C7D6 ; CPU:$C7A0 PRG:07A0 4C D6 C7
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate6_High
; Global: Marker update group 6 entry for the high variant: ORs $F0 into MarkerVar06 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate6_High:
lda #$F0 ; CPU:$C7A3 PRG:07A3 A9 F0
ora Zp57 ; CPU:$C7A5 PRG:07A5 05 57
sta $02DD ; CPU:$C7A7 PRG:07A7 8D DD 02
lda #$30 ; CPU:$C7AA PRG:07AA A9 30
sta $02D9 ; CPU:$C7AC PRG:07AC 8D D9 02
sta $02D5 ; CPU:$C7AF PRG:07AF 8D D5 02
sta $02D1 ; CPU:$C7B2 PRG:07B2 8D D1 02
jmp $C7D6 ; CPU:$C7B5 PRG:07B5 4C D6 C7
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate6_Mid
; Global: Marker update group 6 entry for the mid variant: ORs $D0 into MarkerVar06 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate6_Mid:
lda #$D0 ; CPU:$C7B8 PRG:07B8 A9 D0
ora Zp57 ; CPU:$C7BA PRG:07BA 05 57
sta $02D9 ; CPU:$C7BC PRG:07BC 8D D9 02
lda #$30 ; CPU:$C7BF PRG:07BF A9 30
sta $02D5 ; CPU:$C7C1 PRG:07C1 8D D5 02
sta $02D1 ; CPU:$C7C4 PRG:07C4 8D D1 02
jmp $C7D6 ; CPU:$C7C7 PRG:07C7 4C D6 C7
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate6_Low
; Global: Marker update group 6 entry for the low variant: ORs $D0 into MarkerVar06 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate6_Low:
lda #$D0 ; CPU:$C7CA PRG:07CA A9 D0
ora Zp57 ; CPU:$C7CC PRG:07CC 05 57
sta $02D5 ; CPU:$C7CE PRG:07CE 8D D5 02
lda #$30 ; CPU:$C7D1 PRG:07D1 A9 30
sta $02D1 ; CPU:$C7D3 PRG:07D3 8D D1 02
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate6_Return
; Global: End of marker update group 6. RTS.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate6_Return:
rts ; CPU:$C7D6 PRG:07D6 60
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate7
; Global: Marker update group 7 for MarkerVar07. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate7:
lda Zp63 ; CPU:$C7D7 PRG:07D7 A5 63
cmp #$04 ; CPU:$C7D9 PRG:07D9 C9 04
bmi MarkerUpdate7_High ; CPU:$C7DB PRG:07DB 30 3A
lda Zp63 ; CPU:$C7DD PRG:07DD A5 63
clc ; CPU:$C7DF PRG:07DF 18
sbc #$04 ; CPU:$C7E0 PRG:07E0 E9 04
sta Zp63 ; CPU:$C7E2 PRG:07E2 85 63
lda #$F4 ; CPU:$C7E4 PRG:07E4 A9 F4
sta $031D ; CPU:$C7E6 PRG:07E6 8D 1D 03
lda Zp63 ; CPU:$C7E9 PRG:07E9 A5 63
cmp #$04 ; CPU:$C7EB PRG:07EB C9 04
bmi MarkerUpdate7_Mid ; CPU:$C7ED PRG:07ED 30 3D
lda Zp63 ; CPU:$C7EF PRG:07EF A5 63
clc ; CPU:$C7F1 PRG:07F1 18
sbc #$04 ; CPU:$C7F2 PRG:07F2 E9 04
sta Zp63 ; CPU:$C7F4 PRG:07F4 85 63
lda #$D4 ; CPU:$C7F6 PRG:07F6 A9 D4
sta $0315 ; CPU:$C7F8 PRG:07F8 8D 15 03
lda Zp63 ; CPU:$C7FB PRG:07FB A5 63
cmp #$04 ; CPU:$C7FD PRG:07FD C9 04
bmi MarkerUpdate7_Low ; CPU:$C7FF PRG:07FF 30 3D
lda Zp63 ; CPU:$C801 PRG:0801 A5 63
clc ; CPU:$C803 PRG:0803 18
sbc #$04 ; CPU:$C804 PRG:0804 E9 04
sta Zp63 ; CPU:$C806 PRG:0806 85 63
lda #$D4 ; CPU:$C808 PRG:0808 A9 D4
sta $030D ; CPU:$C80A PRG:080A 8D 0D 03
lda #$E0 ; CPU:$C80D PRG:080D A9 E0
ora Zp63 ; CPU:$C80F PRG:080F 05 63
sta $0305 ; CPU:$C811 PRG:0811 8D 05 03
jmp $C84A ; CPU:$C814 PRG:0814 4C 4A C8
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate7_High
; Global: Marker update group 7 entry for the high variant: ORs $F0 into MarkerVar07 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate7_High:
lda #$F0 ; CPU:$C817 PRG:0817 A9 F0
ora Zp63 ; CPU:$C819 PRG:0819 05 63
sta $031D ; CPU:$C81B PRG:081B 8D 1D 03
lda #$30 ; CPU:$C81E PRG:081E A9 30
sta $0315 ; CPU:$C820 PRG:0820 8D 15 03
sta $030D ; CPU:$C823 PRG:0823 8D 0D 03
sta $0305 ; CPU:$C826 PRG:0826 8D 05 03
jmp $C84A ; CPU:$C829 PRG:0829 4C 4A C8
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate7_Mid
; Global: Marker update group 7 entry for the mid variant: ORs $D0 into MarkerVar07 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate7_Mid:
lda #$D0 ; CPU:$C82C PRG:082C A9 D0
ora Zp63 ; CPU:$C82E PRG:082E 05 63
sta $0315 ; CPU:$C830 PRG:0830 8D 15 03
lda #$30 ; CPU:$C833 PRG:0833 A9 30
sta $030D ; CPU:$C835 PRG:0835 8D 0D 03
sta $0305 ; CPU:$C838 PRG:0838 8D 05 03
jmp $C84A ; CPU:$C83B PRG:083B 4C 4A C8
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate7_Low
; Global: Marker update group 7 entry for the low variant: ORs $D0 into MarkerVar07 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate7_Low:
lda #$D0 ; CPU:$C83E PRG:083E A9 D0
ora Zp63 ; CPU:$C840 PRG:0840 05 63
sta $030D ; CPU:$C842 PRG:0842 8D 0D 03
lda #$30 ; CPU:$C845 PRG:0845 A9 30
sta $0305 ; CPU:$C847 PRG:0847 8D 05 03
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate8
; Global: Marker update group 8 for MarkerVar08. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate8:
lda Zp5E ; CPU:$C84A PRG:084A A5 5E
cmp #$04 ; CPU:$C84C PRG:084C C9 04
bmi MarkerUpdate8_High ; CPU:$C84E PRG:084E 30 3A
lda Zp5E ; CPU:$C850 PRG:0850 A5 5E
clc ; CPU:$C852 PRG:0852 18
sbc #$04 ; CPU:$C853 PRG:0853 E9 04
sta Zp5E ; CPU:$C855 PRG:0855 85 5E
lda #$F4 ; CPU:$C857 PRG:0857 A9 F4
sta $031F ; CPU:$C859 PRG:0859 8D 1F 03
lda Zp5E ; CPU:$C85C PRG:085C A5 5E
cmp #$04 ; CPU:$C85E PRG:085E C9 04
bmi MarkerUpdate8_Mid ; CPU:$C860 PRG:0860 30 3D
lda Zp5E ; CPU:$C862 PRG:0862 A5 5E
clc ; CPU:$C864 PRG:0864 18
sbc #$04 ; CPU:$C865 PRG:0865 E9 04
sta Zp5E ; CPU:$C867 PRG:0867 85 5E
lda #$D4 ; CPU:$C869 PRG:0869 A9 D4
sta $0317 ; CPU:$C86B PRG:086B 8D 17 03
lda Zp5E ; CPU:$C86E PRG:086E A5 5E
cmp #$04 ; CPU:$C870 PRG:0870 C9 04
bmi MarkerUpdate8_Low ; CPU:$C872 PRG:0872 30 3D
lda Zp5E ; CPU:$C874 PRG:0874 A5 5E
clc ; CPU:$C876 PRG:0876 18
sbc #$04 ; CPU:$C877 PRG:0877 E9 04
sta Zp5E ; CPU:$C879 PRG:0879 85 5E
lda #$D4 ; CPU:$C87B PRG:087B A9 D4
sta $030F ; CPU:$C87D PRG:087D 8D 0F 03
lda #$E0 ; CPU:$C880 PRG:0880 A9 E0
ora Zp5E ; CPU:$C882 PRG:0882 05 5E
sta $0307 ; CPU:$C884 PRG:0884 8D 07 03
jmp $C8BD ; CPU:$C887 PRG:0887 4C BD C8
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate8_High
; Global: Marker update group 8 entry for the high variant: ORs $F0 into MarkerVar08 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate8_High:
lda #$F0 ; CPU:$C88A PRG:088A A9 F0
ora Zp5E ; CPU:$C88C PRG:088C 05 5E
sta $031F ; CPU:$C88E PRG:088E 8D 1F 03
lda #$30 ; CPU:$C891 PRG:0891 A9 30
sta $0317 ; CPU:$C893 PRG:0893 8D 17 03
sta $030F ; CPU:$C896 PRG:0896 8D 0F 03
sta $0307 ; CPU:$C899 PRG:0899 8D 07 03
jmp $C8BD ; CPU:$C89C PRG:089C 4C BD C8
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate8_Mid
; Global: Marker update group 8 entry for the mid variant: ORs $D0 into MarkerVar08 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate8_Mid:
lda #$D0 ; CPU:$C89F PRG:089F A9 D0
ora Zp5E ; CPU:$C8A1 PRG:08A1 05 5E
sta $0317 ; CPU:$C8A3 PRG:08A3 8D 17 03
lda #$30 ; CPU:$C8A6 PRG:08A6 A9 30
sta $030F ; CPU:$C8A8 PRG:08A8 8D 0F 03
sta $0307 ; CPU:$C8AB PRG:08AB 8D 07 03
jmp $C8BD ; CPU:$C8AE PRG:08AE 4C BD C8
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate8_Low
; Global: Marker update group 8 entry for the low variant: ORs $D0 into MarkerVar08 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate8_Low:
lda #$D0 ; CPU:$C8B1 PRG:08B1 A9 D0
ora Zp5E ; CPU:$C8B3 PRG:08B3 05 5E
sta $030F ; CPU:$C8B5 PRG:08B5 8D 0F 03
lda #$30 ; CPU:$C8B8 PRG:08B8 A9 30
sta $0307 ; CPU:$C8BA PRG:08BA 8D 07 03
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate9
; Global: Marker update group 9 for MarkerVar09. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate9:
lda Zp59 ; CPU:$C8BD PRG:08BD A5 59
cmp #$04 ; CPU:$C8BF PRG:08BF C9 04
bmi MarkerUpdate9_High ; CPU:$C8C1 PRG:08C1 30 3A
lda Zp59 ; CPU:$C8C3 PRG:08C3 A5 59
clc ; CPU:$C8C5 PRG:08C5 18
sbc #$04 ; CPU:$C8C6 PRG:08C6 E9 04
sta Zp59 ; CPU:$C8C8 PRG:08C8 85 59
lda #$F4 ; CPU:$C8CA PRG:08CA A9 F4
sta $0321 ; CPU:$C8CC PRG:08CC 8D 21 03
lda Zp59 ; CPU:$C8CF PRG:08CF A5 59
cmp #$04 ; CPU:$C8D1 PRG:08D1 C9 04
bmi MarkerUpdate9_Mid ; CPU:$C8D3 PRG:08D3 30 3D
lda Zp59 ; CPU:$C8D5 PRG:08D5 A5 59
clc ; CPU:$C8D7 PRG:08D7 18
sbc #$04 ; CPU:$C8D8 PRG:08D8 E9 04
sta Zp59 ; CPU:$C8DA PRG:08DA 85 59
lda #$D4 ; CPU:$C8DC PRG:08DC A9 D4
sta $0319 ; CPU:$C8DE PRG:08DE 8D 19 03
lda Zp59 ; CPU:$C8E1 PRG:08E1 A5 59
cmp #$04 ; CPU:$C8E3 PRG:08E3 C9 04
bmi MarkerUpdate9_Low ; CPU:$C8E5 PRG:08E5 30 3D
lda Zp59 ; CPU:$C8E7 PRG:08E7 A5 59
clc ; CPU:$C8E9 PRG:08E9 18
sbc #$04 ; CPU:$C8EA PRG:08EA E9 04
sta Zp59 ; CPU:$C8EC PRG:08EC 85 59
lda #$D4 ; CPU:$C8EE PRG:08EE A9 D4
sta $0311 ; CPU:$C8F0 PRG:08F0 8D 11 03
lda #$E0 ; CPU:$C8F3 PRG:08F3 A9 E0
ora Zp59 ; CPU:$C8F5 PRG:08F5 05 59
sta $0309 ; CPU:$C8F7 PRG:08F7 8D 09 03
jmp $C930 ; CPU:$C8FA PRG:08FA 4C 30 C9
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate9_High
; Global: Marker update group 9 entry for the high variant: ORs $F0 into MarkerVar09 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate9_High:
lda #$F0 ; CPU:$C8FD PRG:08FD A9 F0
ora Zp59 ; CPU:$C8FF PRG:08FF 05 59
sta $0321 ; CPU:$C901 PRG:0901 8D 21 03
lda #$30 ; CPU:$C904 PRG:0904 A9 30
sta $0319 ; CPU:$C906 PRG:0906 8D 19 03
sta $0311 ; CPU:$C909 PRG:0909 8D 11 03
sta $0309 ; CPU:$C90C PRG:090C 8D 09 03
jmp $C930 ; CPU:$C90F PRG:090F 4C 30 C9
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate9_Mid
; Global: Marker update group 9 entry for the mid variant: ORs $D0 into MarkerVar09 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate9_Mid:
lda #$D0 ; CPU:$C912 PRG:0912 A9 D0
ora Zp59 ; CPU:$C914 PRG:0914 05 59
sta $0319 ; CPU:$C916 PRG:0916 8D 19 03
lda #$30 ; CPU:$C919 PRG:0919 A9 30
sta $0311 ; CPU:$C91B PRG:091B 8D 11 03
sta $0309 ; CPU:$C91E PRG:091E 8D 09 03
jmp $C930 ; CPU:$C921 PRG:0921 4C 30 C9
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate9_Low
; Global: Marker update group 9 entry for the low variant: ORs $D0 into MarkerVar09 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate9_Low:
lda #$D0 ; CPU:$C924 PRG:0924 A9 D0
ora Zp59 ; CPU:$C926 PRG:0926 05 59
sta $0311 ; CPU:$C928 PRG:0928 8D 11 03
lda #$30 ; CPU:$C92B PRG:092B A9 30
sta $0309 ; CPU:$C92D PRG:092D 8D 09 03
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate10
; Global: Marker update group 10 for MarkerVar10. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate10:
lda Zp64 ; CPU:$C930 PRG:0930 A5 64
cmp #$04 ; CPU:$C932 PRG:0932 C9 04
bmi MarkerUpdate10_High ; CPU:$C934 PRG:0934 30 3A
lda Zp64 ; CPU:$C936 PRG:0936 A5 64
clc ; CPU:$C938 PRG:0938 18
sbc #$04 ; CPU:$C939 PRG:0939 E9 04
sta Zp64 ; CPU:$C93B PRG:093B 85 64
lda #$F4 ; CPU:$C93D PRG:093D A9 F4
sta $034D ; CPU:$C93F PRG:093F 8D 4D 03
lda Zp64 ; CPU:$C942 PRG:0942 A5 64
cmp #$04 ; CPU:$C944 PRG:0944 C9 04
bmi MarkerUpdate10_Mid ; CPU:$C946 PRG:0946 30 3D
lda Zp64 ; CPU:$C948 PRG:0948 A5 64
clc ; CPU:$C94A PRG:094A 18
sbc #$04 ; CPU:$C94B PRG:094B E9 04
sta Zp64 ; CPU:$C94D PRG:094D 85 64
lda #$D4 ; CPU:$C94F PRG:094F A9 D4
sta $0345 ; CPU:$C951 PRG:0951 8D 45 03
lda Zp64 ; CPU:$C954 PRG:0954 A5 64
cmp #$04 ; CPU:$C956 PRG:0956 C9 04
bmi MarkerUpdate10_Low ; CPU:$C958 PRG:0958 30 3D
lda Zp64 ; CPU:$C95A PRG:095A A5 64
clc ; CPU:$C95C PRG:095C 18
sbc #$04 ; CPU:$C95D PRG:095D E9 04
sta Zp64 ; CPU:$C95F PRG:095F 85 64
lda #$D4 ; CPU:$C961 PRG:0961 A9 D4
sta $033D ; CPU:$C963 PRG:0963 8D 3D 03
lda #$E0 ; CPU:$C966 PRG:0966 A9 E0
ora Zp64 ; CPU:$C968 PRG:0968 05 64
sta $0335 ; CPU:$C96A PRG:096A 8D 35 03
jmp $C9A3 ; CPU:$C96D PRG:096D 4C A3 C9
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate10_High
; Global: Marker update group 10 entry for the high variant: ORs $F0 into MarkerVar10 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate10_High:
lda #$F0 ; CPU:$C970 PRG:0970 A9 F0
ora Zp64 ; CPU:$C972 PRG:0972 05 64
sta $034D ; CPU:$C974 PRG:0974 8D 4D 03
lda #$30 ; CPU:$C977 PRG:0977 A9 30
sta $0345 ; CPU:$C979 PRG:0979 8D 45 03
sta $033D ; CPU:$C97C PRG:097C 8D 3D 03
sta $0335 ; CPU:$C97F PRG:097F 8D 35 03
jmp $C9A3 ; CPU:$C982 PRG:0982 4C A3 C9
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate10_Mid
; Global: Marker update group 10 entry for the mid variant: ORs $D0 into MarkerVar10 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate10_Mid:
lda #$D0 ; CPU:$C985 PRG:0985 A9 D0
ora Zp64 ; CPU:$C987 PRG:0987 05 64
sta $0345 ; CPU:$C989 PRG:0989 8D 45 03
lda #$30 ; CPU:$C98C PRG:098C A9 30
sta $033D ; CPU:$C98E PRG:098E 8D 3D 03
sta $0335 ; CPU:$C991 PRG:0991 8D 35 03
jmp $C9A3 ; CPU:$C994 PRG:0994 4C A3 C9
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate10_Low
; Global: Marker update group 10 entry for the low variant: ORs $D0 into MarkerVar10 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate10_Low:
lda #$D0 ; CPU:$C997 PRG:0997 A9 D0
ora Zp64 ; CPU:$C999 PRG:0999 05 64
sta $033D ; CPU:$C99B PRG:099B 8D 3D 03
lda #$30 ; CPU:$C99E PRG:099E A9 30
sta $0335 ; CPU:$C9A0 PRG:09A0 8D 35 03
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate11
; Global: Marker update group 11 for MarkerVar11. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate11:
lda Zp5F ; CPU:$C9A3 PRG:09A3 A5 5F
cmp #$04 ; CPU:$C9A5 PRG:09A5 C9 04
bmi MarkerUpdate11_High ; CPU:$C9A7 PRG:09A7 30 3A
lda Zp5F ; CPU:$C9A9 PRG:09A9 A5 5F
clc ; CPU:$C9AB PRG:09AB 18
sbc #$04 ; CPU:$C9AC PRG:09AC E9 04
sta Zp5F ; CPU:$C9AE PRG:09AE 85 5F
lda #$F4 ; CPU:$C9B0 PRG:09B0 A9 F4
sta $034F ; CPU:$C9B2 PRG:09B2 8D 4F 03
lda Zp5F ; CPU:$C9B5 PRG:09B5 A5 5F
cmp #$04 ; CPU:$C9B7 PRG:09B7 C9 04
bmi MarkerUpdate11_Mid ; CPU:$C9B9 PRG:09B9 30 3D
lda Zp5F ; CPU:$C9BB PRG:09BB A5 5F
clc ; CPU:$C9BD PRG:09BD 18
sbc #$04 ; CPU:$C9BE PRG:09BE E9 04
sta Zp5F ; CPU:$C9C0 PRG:09C0 85 5F
lda #$D4 ; CPU:$C9C2 PRG:09C2 A9 D4
sta $0347 ; CPU:$C9C4 PRG:09C4 8D 47 03
lda Zp5F ; CPU:$C9C7 PRG:09C7 A5 5F
cmp #$04 ; CPU:$C9C9 PRG:09C9 C9 04
bmi MarkerUpdate11_Low ; CPU:$C9CB PRG:09CB 30 3D
lda Zp5F ; CPU:$C9CD PRG:09CD A5 5F
clc ; CPU:$C9CF PRG:09CF 18
sbc #$04 ; CPU:$C9D0 PRG:09D0 E9 04
sta Zp5F ; CPU:$C9D2 PRG:09D2 85 5F
lda #$D4 ; CPU:$C9D4 PRG:09D4 A9 D4
sta $033F ; CPU:$C9D6 PRG:09D6 8D 3F 03
lda #$E0 ; CPU:$C9D9 PRG:09D9 A9 E0
ora Zp5F ; CPU:$C9DB PRG:09DB 05 5F
sta $0337 ; CPU:$C9DD PRG:09DD 8D 37 03
jmp $CA16 ; CPU:$C9E0 PRG:09E0 4C 16 CA
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate11_High
; Global: Marker update group 11 entry for the high variant: ORs $F0 into MarkerVar11 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate11_High:
lda #$F0 ; CPU:$C9E3 PRG:09E3 A9 F0
ora Zp5F ; CPU:$C9E5 PRG:09E5 05 5F
sta $034F ; CPU:$C9E7 PRG:09E7 8D 4F 03
lda #$30 ; CPU:$C9EA PRG:09EA A9 30
sta $0347 ; CPU:$C9EC PRG:09EC 8D 47 03
sta $033F ; CPU:$C9EF PRG:09EF 8D 3F 03
sta $0337 ; CPU:$C9F2 PRG:09F2 8D 37 03
jmp $CA16 ; CPU:$C9F5 PRG:09F5 4C 16 CA
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate11_Mid
; Global: Marker update group 11 entry for the mid variant: ORs $D0 into MarkerVar11 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate11_Mid:
lda #$D0 ; CPU:$C9F8 PRG:09F8 A9 D0
ora Zp5F ; CPU:$C9FA PRG:09FA 05 5F
sta $0347 ; CPU:$C9FC PRG:09FC 8D 47 03
lda #$30 ; CPU:$C9FF PRG:09FF A9 30
sta $033F ; CPU:$CA01 PRG:0A01 8D 3F 03
sta $0337 ; CPU:$CA04 PRG:0A04 8D 37 03
jmp $CA16 ; CPU:$CA07 PRG:0A07 4C 16 CA
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate11_Low
; Global: Marker update group 11 entry for the low variant: ORs $D0 into MarkerVar11 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate11_Low:
lda #$D0 ; CPU:$CA0A PRG:0A0A A9 D0
ora Zp5F ; CPU:$CA0C PRG:0A0C 05 5F
sta $033F ; CPU:$CA0E PRG:0A0E 8D 3F 03
lda #$30 ; CPU:$CA11 PRG:0A11 A9 30
sta $0337 ; CPU:$CA13 PRG:0A13 8D 37 03
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate12
; Global: Marker update group 12 for MarkerVar12. Tests the variable against $04 and, when it is a button state, drives the matching OAM indicator slot.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate12:
lda Zp5A ; CPU:$CA16 PRG:0A16 A5 5A
cmp #$04 ; CPU:$CA18 PRG:0A18 C9 04
bmi MarkerUpdate12_High ; CPU:$CA1A PRG:0A1A 30 3A
lda Zp5A ; CPU:$CA1C PRG:0A1C A5 5A
clc ; CPU:$CA1E PRG:0A1E 18
sbc #$04 ; CPU:$CA1F PRG:0A1F E9 04
sta Zp5A ; CPU:$CA21 PRG:0A21 85 5A
lda #$F4 ; CPU:$CA23 PRG:0A23 A9 F4
sta $0351 ; CPU:$CA25 PRG:0A25 8D 51 03
lda Zp5A ; CPU:$CA28 PRG:0A28 A5 5A
cmp #$04 ; CPU:$CA2A PRG:0A2A C9 04
bmi MarkerUpdate12_Mid ; CPU:$CA2C PRG:0A2C 30 3D
lda Zp5A ; CPU:$CA2E PRG:0A2E A5 5A
clc ; CPU:$CA30 PRG:0A30 18
sbc #$04 ; CPU:$CA31 PRG:0A31 E9 04
sta Zp5A ; CPU:$CA33 PRG:0A33 85 5A
lda #$D4 ; CPU:$CA35 PRG:0A35 A9 D4
sta $0349 ; CPU:$CA37 PRG:0A37 8D 49 03
lda Zp5A ; CPU:$CA3A PRG:0A3A A5 5A
cmp #$04 ; CPU:$CA3C PRG:0A3C C9 04
bmi MarkerUpdate12_Low ; CPU:$CA3E PRG:0A3E 30 3D
lda Zp5A ; CPU:$CA40 PRG:0A40 A5 5A
clc ; CPU:$CA42 PRG:0A42 18
sbc #$04 ; CPU:$CA43 PRG:0A43 E9 04
sta Zp5A ; CPU:$CA45 PRG:0A45 85 5A
lda #$D4 ; CPU:$CA47 PRG:0A47 A9 D4
sta $0341 ; CPU:$CA49 PRG:0A49 8D 41 03
lda #$E0 ; CPU:$CA4C PRG:0A4C A9 E0
ora Zp5A ; CPU:$CA4E PRG:0A4E 05 5A
sta $0339 ; CPU:$CA50 PRG:0A50 8D 39 03
jmp $CA89 ; CPU:$CA53 PRG:0A53 4C 89 CA
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate12_High
; Global: Marker update group 12 entry for the high variant: ORs $F0 into MarkerVar12 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate12_High:
lda #$F0 ; CPU:$CA56 PRG:0A56 A9 F0
ora Zp5A ; CPU:$CA58 PRG:0A58 05 5A
sta $0351 ; CPU:$CA5A PRG:0A5A 8D 51 03
lda #$30 ; CPU:$CA5D PRG:0A5D A9 30
sta $0349 ; CPU:$CA5F PRG:0A5F 8D 49 03
sta $0341 ; CPU:$CA62 PRG:0A62 8D 41 03
sta $0339 ; CPU:$CA65 PRG:0A65 8D 39 03
jmp $CA89 ; CPU:$CA68 PRG:0A68 4C 89 CA
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate12_Mid
; Global: Marker update group 12 entry for the mid variant: ORs $D0 into MarkerVar12 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate12_Mid:
lda #$D0 ; CPU:$CA6B PRG:0A6B A9 D0
ora Zp5A ; CPU:$CA6D PRG:0A6D 05 5A
sta $0349 ; CPU:$CA6F PRG:0A6F 8D 49 03
lda #$30 ; CPU:$CA72 PRG:0A72 A9 30
sta $0341 ; CPU:$CA74 PRG:0A74 8D 41 03
sta $0339 ; CPU:$CA77 PRG:0A77 8D 39 03
jmp $CA89 ; CPU:$CA7A PRG:0A7A 4C 89 CA
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate12_Low
; Global: Marker update group 12 entry for the low variant: ORs $D0 into MarkerVar12 and writes the result to an OAM Y-coordinate slot, so a different indicator sprite lights.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate12_Low:
lda #$D0 ; CPU:$CA7D PRG:0A7D A9 D0
ora Zp5A ; CPU:$CA7F PRG:0A7F 05 5A
sta $0341 ; CPU:$CA81 PRG:0A81 8D 41 03
lda #$30 ; CPU:$CA84 PRG:0A84 A9 30
sta $0339 ; CPU:$CA86 PRG:0A86 8D 39 03
; -----------------------------------------------------------------------------
; Routine: MarkerUpdate12_Return
; Global: End of marker update group 12. RTS.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
MarkerUpdate12_Return:
rts ; CPU:$CA89 PRG:0A89 60
; -----------------------------------------------------------------------------
; Routine: ResetButtonMarkerState
; Global: Clears every per-button marker variable and primes ButtonHoldCounter with $FF. This is the reset for a whole marker update pass, not a single marker.
; Local: Falls through to its caller.
; Parameters: None.
; Returns: All marker state cleared.
; Clobbers: A; MarkerVar01-MarkerVar12, ButtonHoldCounter.
; -----------------------------------------------------------------------------
ResetButtonMarkerState:
lda #$FF ; CPU:$CA8A PRG:0A8A A9 FF
sta Zp6A ; CPU:$CA8C PRG:0A8C 85 6A
lda #$00 ; CPU:$CA8E PRG:0A8E A9 00
sta Zp60 ; CPU:$CA90 PRG:0A90 85 60
sta Zp5B ; CPU:$CA92 PRG:0A92 85 5B
sta Zp56 ; CPU:$CA94 PRG:0A94 85 56
sta Zp61 ; CPU:$CA96 PRG:0A96 85 61
sta Zp5C ; CPU:$CA98 PRG:0A98 85 5C
sta Zp57 ; CPU:$CA9A PRG:0A9A 85 57
sta Zp63 ; CPU:$CA9C PRG:0A9C 85 63
sta Zp5E ; CPU:$CA9E PRG:0A9E 85 5E
sta Zp59 ; CPU:$CAA0 PRG:0AA0 85 59
sta Zp64 ; CPU:$CAA2 PRG:0AA2 85 64
sta Zp5F ; CPU:$CAA4 PRG:0AA4 85 5F
sta Zp5A ; CPU:$CAA6 PRG:0AA6 85 5A
sta Zp65 ; CPU:$CAA8 PRG:0AA8 85 65
sta Zp66 ; CPU:$CAAA PRG:0AAA 85 66
sta Zp68 ; CPU:$CAAC PRG:0AAC 85 68
sta Zp69 ; CPU:$CAAE PRG:0AAE 85 69
rts ; CPU:$CAB0 PRG:0AB0 60
; -----------------------------------------------------------------------------
; Routine: ResetButtonTimers
; Global: Clears both bytes of the frame counter at the start of a marker update pass.
; Local: Falls through to the caller.
; Parameters: None.
; Returns: Counter cleared.
; Clobbers: A; FrameCounterLo/Hi.
; -----------------------------------------------------------------------------
ResetButtonTimers:
lda #$00 ; CPU:$CAB1 PRG:0AB1 A9 00
sta Zp53 ; CPU:$CAB3 PRG:0AB3 85 53
sta Zp54 ; CPU:$CAB5 PRG:0AB5 85 54
rts ; CPU:$CAB7 PRG:0AB7 60
; -----------------------------------------------------------------------------
; Routine: ShiftButtonBit0
; Global: Button-scan entry for bit 0: rotates one bit out of the button state array and records whether it was set.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ShiftButtonBit0:
rol Zp4E,x ; CPU:$CAB8 PRG:0AB8 36 4E
bcc ShiftButtonBit1 ; CPU:$CABA PRG:0ABA 90 05
lda #$00 ; CPU:$CABC PRG:0ABC A9 00
sta $0202,y ; CPU:$CABE PRG:0ABE 99 02 02
; -----------------------------------------------------------------------------
; Routine: ShiftButtonBit1
; Global: Button-scan entry for bit 1: rotates one bit out of the button state array and records whether it was set.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ShiftButtonBit1:
rol Zp4E,x ; CPU:$CAC1 PRG:0AC1 36 4E
bcc ShiftButtonBit2 ; CPU:$CAC3 PRG:0AC3 90 05
lda #$00 ; CPU:$CAC5 PRG:0AC5 A9 00
sta $0206,y ; CPU:$CAC7 PRG:0AC7 99 06 02
; -----------------------------------------------------------------------------
; Routine: ShiftButtonBit2
; Global: Button-scan entry for bit 2: rotates one bit out of the button state array and records whether it was set.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ShiftButtonBit2:
rol Zp4E,x ; CPU:$CACA PRG:0ACA 36 4E
bcc ShiftButtonBit3 ; CPU:$CACC PRG:0ACC 90 05
lda #$00 ; CPU:$CACE PRG:0ACE A9 00
sta $020E,y ; CPU:$CAD0 PRG:0AD0 99 0E 02
; -----------------------------------------------------------------------------
; Routine: ShiftButtonBit3
; Global: Button-scan entry for bit 3: rotates one bit out of the button state array and records whether it was set.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ShiftButtonBit3:
rol Zp4E,x ; CPU:$CAD3 PRG:0AD3 36 4E
bcc ShiftButtonBit4 ; CPU:$CAD5 PRG:0AD5 90 05
lda #$00 ; CPU:$CAD7 PRG:0AD7 A9 00
sta $020A,y ; CPU:$CAD9 PRG:0AD9 99 0A 02
; -----------------------------------------------------------------------------
; Routine: ShiftButtonBit4
; Global: Button-scan entry for bit 4: rotates one bit out of the button state array and records whether it was set.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ShiftButtonBit4:
rol Zp4E,x ; CPU:$CADC PRG:0ADC 36 4E
bcc ShiftButtonBit5 ; CPU:$CADE PRG:0ADE 90 05
lda #$00 ; CPU:$CAE0 PRG:0AE0 A9 00
sta $0212,y ; CPU:$CAE2 PRG:0AE2 99 12 02
; -----------------------------------------------------------------------------
; Routine: ShiftButtonBit5
; Global: Button-scan entry for bit 5: rotates one bit out of the button state array and records whether it was set.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ShiftButtonBit5:
rol Zp4E,x ; CPU:$CAE5 PRG:0AE5 36 4E
bcc ShiftButtonBit6 ; CPU:$CAE7 PRG:0AE7 90 05
lda #$00 ; CPU:$CAE9 PRG:0AE9 A9 00
sta $0216,y ; CPU:$CAEB PRG:0AEB 99 16 02
; -----------------------------------------------------------------------------
; Routine: ShiftButtonBit6
; Global: Button-scan entry for bit 6: rotates one bit out of the button state array and records whether it was set.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ShiftButtonBit6:
rol Zp4E,x ; CPU:$CAEE PRG:0AEE 36 4E
bcc ShiftButtonBit7 ; CPU:$CAF0 PRG:0AF0 90 05
lda #$00 ; CPU:$CAF2 PRG:0AF2 A9 00
sta $021A,y ; CPU:$CAF4 PRG:0AF4 99 1A 02
; -----------------------------------------------------------------------------
; Routine: ShiftButtonBit7
; Global: Button-scan entry for bit 7: rotates one bit out of the button state array and records whether it was set.
; Local: Branches onward, or RTS where the family ends.
; Parameters: X = index where the family is indexed.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ShiftButtonBit7:
rol Zp4E,x ; CPU:$CAF7 PRG:0AF7 36 4E
bcc ShiftButtonBit8Done ; CPU:$CAF9 PRG:0AF9 90 05
lda #$00 ; CPU:$CAFB PRG:0AFB A9 00
sta $021E,y ; CPU:$CAFD PRG:0AFD 99 1E 02
; -----------------------------------------------------------------------------
; Routine: ShiftButtonBit8Done
; Global: Final entry of the eight-step button scan.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
ShiftButtonBit8Done:
rol Zp4E,x ; CPU:$CB00 PRG:0B00 36 4E
rts ; CPU:$CB02 PRG:0B02 60
; -----------------------------------------------------------------------------
; Routine: InitTestScreen70
; Global: Sets up the mode-70 screen: writes an $EE pattern into $6000, clears RAM and primes the OAM from its own ROM table.
; Local: Falls into the mode-70 frame loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y; $6000, $0000-$05FF, $0200-$02FF.
; -----------------------------------------------------------------------------
InitTestScreen70:
jsr PpuMaskSetup ; CPU:$CB03 PRG:0B03 20 2F CD
ldx #$00 ; CPU:$CB06 PRG:0B06 A2 00
lda #$EE ; CPU:$CB08 PRG:0B08 A9 EE
; -----------------------------------------------------------------------------
; Routine: WriteRamPattern70Loop
; Global: Mode-70 copy of the $6000 pattern writer.
; Local: Returns to its caller once X reaches six.
; Parameters: X = index; A = pattern byte.
; Returns: X = six.
; Clobbers: A, X; $6000-$6005.
; -----------------------------------------------------------------------------
WriteRamPattern70Loop:
sta $6000,x ; CPU:$CB0A PRG:0B0A 9D 00 60
inx ; CPU:$CB0D PRG:0B0D E8
cpx #$06 ; CPU:$CB0E PRG:0B0E E0 06
bne WriteRamPattern70Loop ; CPU:$CB10 PRG:0B10 D0 F8
lda #$00 ; CPU:$CB12 PRG:0B12 A9 00
ldx #$00 ; CPU:$CB14 PRG:0B14 A2 00
; -----------------------------------------------------------------------------
; Routine: ClearRamPass4Loop
; Global: Fourth RAM-clearing pass, used by mode 70.
; Local: Returns to its caller when X wraps.
; Parameters: X = page offset; A = fill value.
; Returns: X wrapped to $00.
; Clobbers: A, X; $0000-$05FF.
; -----------------------------------------------------------------------------
ClearRamPass4Loop:
sta VramPtrLo,x ; CPU:$CB16 PRG:0B16 95 00
sta $0100,x ; CPU:$CB18 PRG:0B18 9D 00 01
lda #$F4 ; CPU:$CB1B PRG:0B1B A9 F4
sta $0200,x ; CPU:$CB1D PRG:0B1D 9D 00 02
lda #$00 ; CPU:$CB20 PRG:0B20 A9 00
sta $0300,x ; CPU:$CB22 PRG:0B22 9D 00 03
sta $0400,x ; CPU:$CB25 PRG:0B25 9D 00 04
sta $0500,x ; CPU:$CB28 PRG:0B28 9D 00 05
sta $0600,x ; CPU:$CB2B PRG:0B2B 9D 00 06
inx ; CPU:$CB2E PRG:0B2E E8
bne ClearRamPass4Loop ; CPU:$CB2F PRG:0B2F D0 E5
lda #$10 ; CPU:$CB31 PRG:0B31 A9 10
sta PPUCTRL ; CPU:$CB33 PRG:0B33 8D 00 20
sta PpuCtrlShadow ; CPU:$CB36 PRG:0B36 85 EF
lda #$00 ; CPU:$CB38 PRG:0B38 A9 00
sta PPUMASK ; CPU:$CB3A PRG:0B3A 8D 01 20
sta PpuMaskShadow ; CPU:$CB3D PRG:0B3D 85 EE
lda #$20 ; CPU:$CB3F PRG:0B3F A9 20
ldx #$24 ; CPU:$CB41 PRG:0B41 A2 24
ldy #$00 ; CPU:$CB43 PRG:0B43 A0 00
jsr $CDEE ; CPU:$CB45 PRG:0B45 20 EE CD
jsr $CD3F ; CPU:$CB48 PRG:0B48 20 3F CD
asl ZpCF ; CPU:$CB4B PRG:0B4B 06 CF
jsr $CE3C ; CPU:$CB4D PRG:0B4D 20 3C CE
jsr $CD3F ; CPU:$CB50 PRG:0B50 20 3F CD
.byte $63, $D0 ; CPU:$CB53 PRG:0B53 63 D0 -- rra (ZpD0,x) (undocumented; ca65 cannot encode)
jsr $CE3C ; CPU:$CB55 PRG:0B55 20 3C CE
jsr $C174 ; CPU:$CB58 PRG:0B58 20 74 C1
ldx #$DF ; CPU:$CB5B PRG:0B5B A2 DF
; -----------------------------------------------------------------------------
; Routine: CopyOamFromTable70
; Global: Mode-70 copy of the ROM sprite table upload.
; Local: Falls through when X reaches zero.
; Parameters: X = index.
; Returns: X wrapped to $00.
; Clobbers: A, X; $0200-$02FF.
; -----------------------------------------------------------------------------
CopyOamFromTable70:
lda $D5C4,x ; CPU:$CB5D PRG:0B5D BD C4 D5
sta $0200,x ; CPU:$CB60 PRG:0B60 9D 00 02
dex ; CPU:$CB63 PRG:0B63 CA
bne CopyOamFromTable70 ; CPU:$CB64 PRG:0B64 D0 F7
lda $D5C4,x ; CPU:$CB66 PRG:0B66 BD C4 D5
sta $0200,x ; CPU:$CB69 PRG:0B69 9D 00 02
lda #$FF ; CPU:$CB6C PRG:0B6C A9 FF
sta Zp6A ; CPU:$CB6E PRG:0B6E 85 6A
lda #$00 ; CPU:$CB70 PRG:0B70 A9 00
sta Zp4E ; CPU:$CB72 PRG:0B72 85 4E
sta Zp4F ; CPU:$CB74 PRG:0B74 85 4F
sta Zp51 ; CPU:$CB76 PRG:0B76 85 51
sta Zp52 ; CPU:$CB78 PRG:0B78 85 52
sta Zp54 ; CPU:$CB7A PRG:0B7A 85 54
sta Zp53 ; CPU:$CB7C PRG:0B7C 85 53
sta Zp60 ; CPU:$CB7E PRG:0B7E 85 60
sta Zp5B ; CPU:$CB80 PRG:0B80 85 5B
sta Zp56 ; CPU:$CB82 PRG:0B82 85 56
sta Zp61 ; CPU:$CB84 PRG:0B84 85 61
sta Zp5C ; CPU:$CB86 PRG:0B86 85 5C
sta Zp57 ; CPU:$CB88 PRG:0B88 85 57
sta Zp65 ; CPU:$CB8A PRG:0B8A 85 65
sta Zp66 ; CPU:$CB8C PRG:0B8C 85 66
sta Zp68 ; CPU:$CB8E PRG:0B8E 85 68
sta Zp69 ; CPU:$CB90 PRG:0B90 85 69
lda #$BF ; CPU:$CB92 PRG:0B92 A9 BF
sta APUPULSE1CTRL ; CPU:$CB94 PRG:0B94 8D 00 40
jsr $CD39 ; CPU:$CB97 PRG:0B97 20 39 CD
; -----------------------------------------------------------------------------
; Routine: MainLoopTestMode70
; Global: Frame loop for mode 70: waits for vblank, samples the controller through the alternate path, and advances the hold counter.
; Local: Loops forever, one iteration per frame.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y; ButtonHoldCounter.
; -----------------------------------------------------------------------------
MainLoopTestMode70:
jsr $CCE2 ; CPU:$CB9A PRG:0B9A 20 E2 CC
jsr $CBF8 ; CPU:$CB9D PRG:0B9D 20 F8 CB
inc Zp6A ; CPU:$CBA0 PRG:0BA0 E6 6A
lda #$0F ; CPU:$CBA2 PRG:0BA2 A9 0F
cmp Zp6A ; CPU:$CBA4 PRG:0BA4 C5 6A
beq UpdateMarkersAndTimers70 ; CPU:$CBA6 PRG:0BA6 F0 03
jmp $CBB1 ; CPU:$CBA8 PRG:0BA8 4C B1 CB
; -----------------------------------------------------------------------------
; Routine: UpdateMarkersAndTimers70
; Global: Refreshes the button markers and the hold timers for mode 70.
; Local: Returns to the mode-70 frame loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
UpdateMarkersAndTimers70:
jsr $C524 ; CPU:$CBAB PRG:0BAB 20 24 C5
jsr $CA8A ; CPU:$CBAE PRG:0BAE 20 8A CA
; -----------------------------------------------------------------------------
; Routine: CheckButtonsTestMode70
; Global: Tests the controller byte for any button held in mode 70.
; Local: Branches to UpdateOamTestMode70 when one is.
; Parameters: None.
; Returns: Z flag reflects the test.
; Clobbers: A.
; -----------------------------------------------------------------------------
CheckButtonsTestMode70:
lda #$00 ; CPU:$CBB1 PRG:0BB1 A9 00
cmp Zp40 ; CPU:$CBB3 PRG:0BB3 C5 40
bne UpdateOamTestMode70 ; CPU:$CBB5 PRG:0BB5 D0 09
cmp Zp41 ; CPU:$CBB7 PRG:0BB7 C5 41
bne UpdateOamTestMode70 ; CPU:$CBB9 PRG:0BB9 D0 05
lda #$00 ; CPU:$CBBB PRG:0BBB A9 00
sta APUSTATUS ; CPU:$CBBD PRG:0BBD 8D 15 40
; -----------------------------------------------------------------------------
; Routine: UpdateOamTestMode70
; Global: Updates the OAM entries for mode 70 from the current button state.
; Local: Returns to the mode-70 frame loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y; $0200-$02FF.
; -----------------------------------------------------------------------------
UpdateOamTestMode70:
ldy #$00 ; CPU:$CBC0 PRG:0BC0 A0 00
ldx #$00 ; CPU:$CBC2 PRG:0BC2 A2 00
jsr $CC11 ; CPU:$CBC4 PRG:0BC4 20 11 CC
jsr $C361 ; CPU:$CBC7 PRG:0BC7 20 61 C3
ldy #$20 ; CPU:$CBCA PRG:0BCA A0 20
inx ; CPU:$CBCC PRG:0BCC E8
jsr $CC11 ; CPU:$CBCD PRG:0BCD 20 11 CC
jsr $C361 ; CPU:$CBD0 PRG:0BD0 20 61 C3
lda #$FF ; CPU:$CBD3 PRG:0BD3 A9 FF
cmp Zp4E ; CPU:$CBD5 PRG:0BD5 C5 4E
bne IncrementFrameCounter70 ; CPU:$CBD7 PRG:0BD7 D0 07
cmp Zp4F ; CPU:$CBD9 PRG:0BD9 C5 4F
bne IncrementFrameCounter70 ; CPU:$CBDB PRG:0BDB D0 03
jmp $C1A0 ; CPU:$CBDD PRG:0BDD 4C A0 C1
; -----------------------------------------------------------------------------
; Routine: IncrementFrameCounter70
; Global: Mode-70 copy of the 16-bit frame counter increment.
; Local: Falls through to CheckFrameCounterLimit70.
; Parameters: None.
; Returns: Counter advanced.
; Clobbers: FrameCounterLo/Hi.
; -----------------------------------------------------------------------------
IncrementFrameCounter70:
inc Zp54 ; CPU:$CBE0 PRG:0BE0 E6 54
bne CheckFrameCounterLimit70 ; CPU:$CBE2 PRG:0BE2 D0 02
inc Zp53 ; CPU:$CBE4 PRG:0BE4 E6 53
; -----------------------------------------------------------------------------
; Routine: CheckFrameCounterLimit70
; Global: Mode-70 copy of the frame-counter timeout test.
; Local: Branches to ContinueTestMode70 or ExitToInit70.
; Parameters: None.
; Returns: Z flag reflects the comparison.
; Clobbers: A.
; -----------------------------------------------------------------------------
CheckFrameCounterLimit70:
lda #$00 ; CPU:$CBE6 PRG:0BE6 A9 00
cmp Zp54 ; CPU:$CBE8 PRG:0BE8 C5 54
bne ContinueTestMode70 ; CPU:$CBEA PRG:0BEA D0 06
lda #$38 ; CPU:$CBEC PRG:0BEC A9 38
cmp Zp53 ; CPU:$CBEE PRG:0BEE C5 53
beq ExitToInit70 ; CPU:$CBF0 PRG:0BF0 F0 03
; -----------------------------------------------------------------------------
; Routine: ContinueTestMode70
; Global: Jumps back to the top of the mode-70 frame loop.
; Local: Jumps; does not return.
; Parameters: None.
; Returns: Nothing.
; Clobbers: None.
; -----------------------------------------------------------------------------
ContinueTestMode70:
jmp $CB9A ; CPU:$CBF2 PRG:0BF2 4C 9A CB
; -----------------------------------------------------------------------------
; Routine: ExitToInit70
; Global: Jumps back to InitTestScreen from mode 70.
; Local: Jumps; does not return.
; Parameters: None.
; Returns: Nothing.
; Clobbers: None.
; -----------------------------------------------------------------------------
ExitToInit70:
jmp $C055 ; CPU:$CBF5 PRG:0BF5 4C 55 C0
; -----------------------------------------------------------------------------
; Routine: LatchControllerStrobe
; Global: Strobes the controller port: writes $01 to JOY1 to latch, then $00 to release, which is the standard NES pad handshake.
; Local: Falls into the eight-bit read loop.
; Parameters: None.
; Returns: Controller shift register latched.
; Clobbers: A, X; JOY1.
; -----------------------------------------------------------------------------
LatchControllerStrobe:
ldx #$01 ; CPU:$CBF8 PRG:0BF8 A2 01
stx JOY1 ; CPU:$CBFA PRG:0BFA 8E 16 40
dex ; CPU:$CBFD PRG:0BFD CA
stx JOY1 ; CPU:$CBFE PRG:0BFE 8E 16 40
inx ; CPU:$CC01 PRG:0C01 E8
; -----------------------------------------------------------------------------
; Routine: ReadControllerBitsInit
; Global: Sets the loop counter to eight reads before collecting the controller byte.
; Local: Falls into ReadControllerBitsLoop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, Y.
; -----------------------------------------------------------------------------
ReadControllerBitsInit:
ldy #$08 ; CPU:$CC02 PRG:0C02 A0 08
; -----------------------------------------------------------------------------
; Routine: ReadControllerBitsLoop
; Global: Reads JOY1 eight times, shifting each bit into the button array with `lsr a / rol Zp40,x` so A arrives in bit 0.
; Local: Loops Y down from eight, then returns.
; Parameters: Y = remaining reads; X = button index.
; Returns: Eight bits collected.
; Clobbers: A, X, Y; P1Buttons.
; -----------------------------------------------------------------------------
ReadControllerBitsLoop:
lda JOY1,x ; CPU:$CC04 PRG:0C04 BD 16 40
lsr a ; CPU:$CC07 PRG:0C07 4A
rol Zp40,x ; CPU:$CC08 PRG:0C08 36 40
dey ; CPU:$CC0A PRG:0C0A 88
bne ReadControllerBitsLoop ; CPU:$CC0B PRG:0C0B D0 F7
dex ; CPU:$CC0D PRG:0C0D CA
beq ReadControllerBitsInit ; CPU:$CC0E PRG:0C0E F0 F2
rts ; CPU:$CC10 PRG:0C10 60
; -----------------------------------------------------------------------------
; Routine: ReadControllerBitSingle
; Global: Reads a single controller bit and branches on it, used where only one input matters.
; Local: Branches on the bit; both paths return to the caller.
; Parameters: None.
; Returns: Carry holds the bit.
; Clobbers: A, carry; JOY1.
; -----------------------------------------------------------------------------
ReadControllerBitSingle:
lda JOY1,x ; CPU:$CC11 PRG:0C11 BD 16 40
lsr a ; CPU:$CC14 PRG:0C14 4A
bcc WriteOamFromButtonState ; CPU:$CC15 PRG:0C15 90 01
rts ; CPU:$CC17 PRG:0C17 60
; -----------------------------------------------------------------------------
; Routine: WriteOamFromButtonState
; Global: Writes tile index $03 to the tile byte of the four button-state sprite entries at $0202/$0206/$020A/$020E, so the on-screen buttons light up.
; Local: Falls through to the attribute writes that follow.
; Parameters: Y = OAM offset stride.
; Returns: Nothing.
; Clobbers: A; $0202, $0206, $020A, $020E.
; -----------------------------------------------------------------------------
WriteOamFromButtonState:
lda #$03 ; CPU:$CC18 PRG:0C18 A9 03
sta $0202,y ; CPU:$CC1A PRG:0C1A 99 02 02
sta $0206,y ; CPU:$CC1D PRG:0C1D 99 06 02
sta $020A,y ; CPU:$CC20 PRG:0C20 99 0A 02
sta $020E,y ; CPU:$CC23 PRG:0C23 99 0E 02
sta $0212,y ; CPU:$CC26 PRG:0C26 99 12 02
sta $0216,y ; CPU:$CC29 PRG:0C29 99 16 02
sta $021A,y ; CPU:$CC2C PRG:0C2C 99 1A 02
sta $021E,y ; CPU:$CC2F PRG:0C2F 99 1E 02
lda #$00 ; CPU:$CC32 PRG:0C32 A9 00
sta Zp40,x ; CPU:$CC34 PRG:0C34 95 40
sta Zp56,x ; CPU:$CC36 PRG:0C36 95 56
sta Zp5B,x ; CPU:$CC38 PRG:0C38 95 5B
sta Zp60,x ; CPU:$CC3A PRG:0C3A 95 60
sta Zp65,x ; CPU:$CC3C PRG:0C3C 95 65
sta Zp4E,x ; CPU:$CC3E PRG:0C3E 95 4E
txa ; CPU:$CC40 PRG:0C40 8A
pha ; CPU:$CC41 PRG:0C41 48
ldx #$1F ; CPU:$CC42 PRG:0C42 A2 1F
lda #$F4 ; CPU:$CC44 PRG:0C44 A9 F4
; -----------------------------------------------------------------------------
; Routine: CopyOamShadowLoop
; Global: Descending store into the OAM shadow at $02E0, one byte per X value, then restores the caller's X from the stack.
; Local: Falls through when X goes negative; RTS to the caller.
; Parameters: X = descending index; A = byte to store.
; Returns: X restored from the stack.
; Clobbers: A, X; $02E0-$02FF; stack via pha/pla.
; -----------------------------------------------------------------------------
CopyOamShadowLoop:
sta $02E0,x ; CPU:$CC46 PRG:0C46 9D E0 02
dex ; CPU:$CC49 PRG:0C49 CA
bpl CopyOamShadowLoop ; CPU:$CC4A PRG:0C4A 10 FA
pla ; CPU:$CC4C PRG:0C4C 68
tax ; CPU:$CC4D PRG:0C4D AA
rts ; CPU:$CC4E PRG:0C4E 60
; -----------------------------------------------------------------------------
; Routine: LatchControllerStrobeAlt
; Global: Second strobe sequence, used by the alternate read paths. Identical protocol to LatchControllerStrobe.
; Local: Falls into its read loop.
; Parameters: None.
; Returns: Controller shift register latched.
; Clobbers: A, X; JOY1.
; -----------------------------------------------------------------------------
LatchControllerStrobeAlt:
ldx #$01 ; CPU:$CC4F PRG:0C4F A2 01
stx JOY1 ; CPU:$CC51 PRG:0C51 8E 16 40
dex ; CPU:$CC54 PRG:0C54 CA
stx JOY1 ; CPU:$CC55 PRG:0C55 8E 16 40
inx ; CPU:$CC58 PRG:0C58 E8
; -----------------------------------------------------------------------------
; Routine: PollExpansionPortInit
; Global: Prepares the expansion-port probe.
; Local: Falls into PollExpansionPortLoop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, Y.
; -----------------------------------------------------------------------------
PollExpansionPortInit:
ldy #$08 ; CPU:$CC59 PRG:0C59 A0 08
; -----------------------------------------------------------------------------
; Routine: PollExpansionPortLoop
; Global: Reads the expansion port and tests bits 0-1 against $01. On this cartridge nothing consumes the result, so the branch is always the same way; the read is present but inert.
; Local: Loops eight times, then returns.
; Parameters: Y = remaining reads.
; Returns: Nothing consumed.
; Clobbers: A, Y; JOY2.
; -----------------------------------------------------------------------------
PollExpansionPortLoop:
lda JOY1,x ; CPU:$CC5B PRG:0C5B BD 16 40
and #$03 ; CPU:$CC5E PRG:0C5E 29 03
cmp #$01 ; CPU:$CC60 PRG:0C60 C9 01
rol Zp40,x ; CPU:$CC62 PRG:0C62 36 40
dey ; CPU:$CC64 PRG:0C64 88
bne PollExpansionPortLoop ; CPU:$CC65 PRG:0C65 D0 F4
dex ; CPU:$CC67 PRG:0C67 CA
beq PollExpansionPortInit ; CPU:$CC68 PRG:0C68 F0 EF
ldx #$01 ; CPU:$CC6A PRG:0C6A A2 01
; -----------------------------------------------------------------------------
; Routine: ReadControllerBitsAltInit
; Global: Sets the loop counter for the alternate controller read path.
; Local: Falls into ReadControllerBitsAltLoop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, Y.
; -----------------------------------------------------------------------------
ReadControllerBitsAltInit:
ldy #$08 ; CPU:$CC6C PRG:0C6C A0 08
; -----------------------------------------------------------------------------
; Routine: ReadControllerBitsAltLoop
; Global: Alternate eight-bit read, shifting into the second button array at $47.
; Local: Loops Y down from eight, then returns.
; Parameters: Y = remaining reads.
; Returns: Eight bits collected.
; Clobbers: A, X, Y; P1ButtonsAlt.
; -----------------------------------------------------------------------------
ReadControllerBitsAltLoop:
lda JOY1,x ; CPU:$CC6E PRG:0C6E BD 16 40
lsr a ; CPU:$CC71 PRG:0C71 4A
rol Zp47,x ; CPU:$CC72 PRG:0C72 36 47
lsr a ; CPU:$CC74 PRG:0C74 4A
rol Zp45,x ; CPU:$CC75 PRG:0C75 36 45
dey ; CPU:$CC77 PRG:0C77 88
bne ReadControllerBitsAltLoop ; CPU:$CC78 PRG:0C78 D0 F4
dex ; CPU:$CC7A PRG:0C7A CA
beq ReadControllerBitsAltInit ; CPU:$CC7B PRG:0C7B F0 EF
ldx #$01 ; CPU:$CC7D PRG:0C7D A2 01
; -----------------------------------------------------------------------------
; Routine: ReadControllerBitsAlt2Init
; Global: Sets the loop counter for the third controller read path.
; Local: Falls into ReadControllerBitsAlt2Loop.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, Y.
; -----------------------------------------------------------------------------
ReadControllerBitsAlt2Init:
ldy #$08 ; CPU:$CC7F PRG:0C7F A0 08
; -----------------------------------------------------------------------------
; Routine: ReadControllerBitsAlt2Loop
; Global: Third eight-bit read, shifting into the array at $4B that the direction checks later examine.
; Local: Loops Y down from eight, then returns.
; Parameters: Y = remaining reads.
; Returns: Eight bits collected.
; Clobbers: A, X, Y; P2Buttons.
; -----------------------------------------------------------------------------
ReadControllerBitsAlt2Loop:
lda JOY1,x ; CPU:$CC81 PRG:0C81 BD 16 40
lsr a ; CPU:$CC84 PRG:0C84 4A
rol Zp4B,x ; CPU:$CC85 PRG:0C85 36 4B
lsr a ; CPU:$CC87 PRG:0C87 4A
rol Zp49,x ; CPU:$CC88 PRG:0C88 36 49
dey ; CPU:$CC8A PRG:0C8A 88
bne ReadControllerBitsAlt2Loop ; CPU:$CC8B PRG:0C8B D0 F4
dex ; CPU:$CC8D PRG:0C8D CA
beq ReadControllerBitsAlt2Init ; CPU:$CC8E PRG:0C8E F0 EF
lda #$00 ; CPU:$CC90 PRG:0C90 A9 00
sta Zp4D ; CPU:$CC92 PRG:0C92 85 4D
lda Zp49 ; CPU:$CC94 PRG:0C94 A5 49
cmp #$20 ; CPU:$CC96 PRG:0C96 C9 20
bne CheckStickUp ; CPU:$CC98 PRG:0C98 D0 06
lda #$80 ; CPU:$CC9A PRG:0C9A A9 80
ora Zp4D ; CPU:$CC9C PRG:0C9C 05 4D
sta Zp4D ; CPU:$CC9E PRG:0C9E 85 4D
; -----------------------------------------------------------------------------
; Routine: CheckStickUp
; Global: Compares the accumulated direction byte against $10 and records the result when the d-pad is being held up.
; Local: Falls through to CheckStickDown.
; Parameters: None.
; Returns: Direction state updated.
; Clobbers: A; PrevStickState.
; -----------------------------------------------------------------------------
CheckStickUp:
lda Zp4A ; CPU:$CCA0 PRG:0CA0 A5 4A
cmp #$10 ; CPU:$CCA2 PRG:0CA2 C9 10
bne CheckStickDown ; CPU:$CCA4 PRG:0CA4 D0 06
lda #$40 ; CPU:$CCA6 PRG:0CA6 A9 40
ora Zp4D ; CPU:$CCA8 PRG:0CA8 05 4D
sta Zp4D ; CPU:$CCAA PRG:0CAA 85 4D
; -----------------------------------------------------------------------------
; Routine: CheckStickDown
; Global: Compares against $20 for the down direction.
; Local: Falls through to CheckStickLeft.
; Parameters: None.
; Returns: Direction state updated.
; Clobbers: A.
; -----------------------------------------------------------------------------
CheckStickDown:
lda Zp4B ; CPU:$CCAC PRG:0CAC A5 4B
cmp #$10 ; CPU:$CCAE PRG:0CAE C9 10
bne CheckStickLeft ; CPU:$CCB0 PRG:0CB0 D0 06
lda #$20 ; CPU:$CCB2 PRG:0CB2 A9 20
ora Zp4D ; CPU:$CCB4 PRG:0CB4 05 4D
sta Zp4D ; CPU:$CCB6 PRG:0CB6 85 4D
; -----------------------------------------------------------------------------
; Routine: CheckStickLeft
; Global: Compares against $C0 for the left direction.
; Local: Falls through to CheckStickRight.
; Parameters: None.
; Returns: Direction state updated.
; Clobbers: A.
; -----------------------------------------------------------------------------
CheckStickLeft:
lda Zp4C ; CPU:$CCB8 PRG:0CB8 A5 4C
cmp #$20 ; CPU:$CCBA PRG:0CBA C9 20
bne CheckStickRight ; CPU:$CCBC PRG:0CBC D0 06
lda #$10 ; CPU:$CCBE PRG:0CBE A9 10
ora Zp4D ; CPU:$CCC0 PRG:0CC0 05 4D
sta Zp4D ; CPU:$CCC2 PRG:0CC2 85 4D
; -----------------------------------------------------------------------------
; Routine: CheckStickRight
; Global: Compares against $C0 for the right direction.
; Local: Falls through to LatchPreviousStickState.
; Parameters: None.
; Returns: Direction state updated.
; Clobbers: A.
; -----------------------------------------------------------------------------
CheckStickRight:
lda Zp4D ; CPU:$CCC4 PRG:0CC4 A5 4D
cmp #$C0 ; CPU:$CCC6 PRG:0CC6 C9 C0
bne CheckStickDiagonal ; CPU:$CCC8 PRG:0CC8 D0 0A
ldx #$02 ; CPU:$CCCA PRG:0CCA A2 02
; -----------------------------------------------------------------------------
; Routine: LatchPreviousStickState
; Global: Copies the current direction accumulators into the previous-state array so the next frame can detect edges.
; Local: Falls through when X reaches its limit.
; Parameters: X = direction index.
; Returns: Previous state updated.
; Clobbers: X; PrevStickState.
; -----------------------------------------------------------------------------
LatchPreviousStickState:
lda Zp44,x ; CPU:$CCCC PRG:0CCC B5 44
sta Zp42,x ; CPU:$CCCE PRG:0CCE 95 42
dex ; CPU:$CCD0 PRG:0CD0 CA
bne LatchPreviousStickState ; CPU:$CCD1 PRG:0CD1 D0 F9
rts ; CPU:$CCD3 PRG:0CD3 60
; -----------------------------------------------------------------------------
; Routine: CheckStickDiagonal
; Global: Tests for a combined diagonal before the previous state is latched.
; Local: Falls through to LatchPreviousDiagonalState.
; Parameters: None.
; Returns: Diagonal state updated.
; Clobbers: A, X.
; -----------------------------------------------------------------------------
CheckStickDiagonal:
cmp #$30 ; CPU:$CCD4 PRG:0CD4 C9 30
bne ReturnFromStickDecode ; CPU:$CCD6 PRG:0CD6 D0 09
ldx #$02 ; CPU:$CCD8 PRG:0CD8 A2 02
; -----------------------------------------------------------------------------
; Routine: LatchPreviousDiagonalState
; Global: Latches the diagonal accumulators into the previous-state array.
; Local: Returns to the caller via ReturnFromStickDecode.
; Parameters: X = direction index.
; Returns: Previous diagonal state updated.
; Clobbers: X; PrevStickState.
; -----------------------------------------------------------------------------
LatchPreviousDiagonalState:
lda Zp46,x ; CPU:$CCDA PRG:0CDA B5 46
sta Zp42,x ; CPU:$CCDC PRG:0CDC 95 42
dex ; CPU:$CCDE PRG:0CDE CA
bne LatchPreviousDiagonalState ; CPU:$CCDF PRG:0CDF D0 F9
; -----------------------------------------------------------------------------
; Routine: ReturnFromStickDecode
; Global: Returns from the direction decode with A holding the decoded value.
; Local: RTS.
; Parameters: None.
; Returns: A = decoded direction.
; Clobbers: A.
; -----------------------------------------------------------------------------
ReturnFromStickDecode:
rts ; CPU:$CCE1 PRG:0CE1 60
; -----------------------------------------------------------------------------
; Routine: WaitForVblank
; Global: Waits for vblank, preserves A, and reads the PPUCTRL shadow in preparation for VRAM access.
; Local: Returns once vblank has been seen.
; Parameters: None.
; Returns: A preserved; vblank flag consumed.
; Clobbers: stack via pha/pla; PPUSTATUS.
; -----------------------------------------------------------------------------
WaitForVblank:
pha ; CPU:$CCE2 PRG:0CE2 48
lda PPUSTATUS ; CPU:$CCE3 PRG:0CE3 AD 02 20
lda PpuCtrlShadow ; CPU:$CCE6 PRG:0CE6 A5 EF
ora #$80 ; CPU:$CCE8 PRG:0CE8 09 80
sta PpuCtrlShadow ; CPU:$CCEA PRG:0CEA 85 EF
sta PPUCTRL ; CPU:$CCEC PRG:0CEC 8D 00 20
sta ZpE0 ; CPU:$CCEF PRG:0CEF 85 E0
pla ; CPU:$CCF1 PRG:0CF1 68
; -----------------------------------------------------------------------------
; Routine: WaitForNmiComplete
; Global: Spins until the NMI handler clears NmiInProgressFlag, so VRAM writes never race the handler.
; Local: RTS once the flag clears.
; Parameters: None.
; Returns: Nothing.
; Clobbers: $E0.
; -----------------------------------------------------------------------------
WaitForNmiComplete:
bit ZpE0 ; CPU:$CCF2 PRG:0CF2 24 E0
bmi WaitForNmiComplete ; CPU:$CCF4 PRG:0CF4 30 FC
rts ; CPU:$CCF6 PRG:0CF6 60
; -----------------------------------------------------------------------------
; Routine: NmiHandler
; Global: Non-maskable interrupt entry. Saves registers, runs the per-frame PPU work (scroll latch, PPUCTRL and mask setup, OAM DMA) and the VRAM writer, then restores registers and returns.
; Local: Never returns normally; exits through RTI.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y, P; PPU and OAM; VRAM shadow.
; -----------------------------------------------------------------------------
NmiHandler:
pha ; CPU:$CCF7 PRG:0CF7 48
txa ; CPU:$CCF8 PRG:0CF8 8A
pha ; CPU:$CCF9 PRG:0CF9 48
tya ; CPU:$CCFA PRG:0CFA 98
pha ; CPU:$CCFB PRG:0CFB 48
jsr $CD17 ; CPU:$CCFC PRG:0CFC 20 17 CD
jsr $CD24 ; CPU:$CCFF PRG:0CFF 20 24 CD
lda $0300 ; CPU:$CD02 PRG:0D02 AD 00 03
beq NmiContinue ; CPU:$CD05 PRG:0D05 F0 03
jsr $CE4F ; CPU:$CD07 PRG:0D07 20 4F CE
; -----------------------------------------------------------------------------
; Routine: NmiContinue
; Global: Second half of the NMI body, reached after the register save.
; Local: Falls through into the PPU setup calls.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y.
; -----------------------------------------------------------------------------
NmiContinue:
jsr $CE3C ; CPU:$CD0A PRG:0D0A 20 3C CE
lda #$00 ; CPU:$CD0D PRG:0D0D A9 00
sta ZpE0 ; CPU:$CD0F PRG:0D0F 85 E0
pla ; CPU:$CD11 PRG:0D11 68
tay ; CPU:$CD12 PRG:0D12 A8
pla ; CPU:$CD13 PRG:0D13 68
tax ; CPU:$CD14 PRG:0D14 AA
pla ; CPU:$CD15 PRG:0D15 68
rti ; CPU:$CD16 PRG:0D16 40
; -----------------------------------------------------------------------------
; Routine: PpuCtrlSetup
; Global: Reads PPUSTATUS to clear the vblank latch and masks bit 7 out of the PPUCTRL shadow before it is written back.
; Local: Returns to the NMI body.
; Parameters: None.
; Returns: PpuCtrlShadow updated with bit 7 clear.
; Clobbers: A; PPUSTATUS, PpuCtrlShadow.
; -----------------------------------------------------------------------------
PpuCtrlSetup:
lda PPUSTATUS ; CPU:$CD17 PRG:0D17 AD 02 20
lda PpuCtrlShadow ; CPU:$CD1A PRG:0D1A A5 EF
and #$7F ; CPU:$CD1C PRG:0D1C 29 7F
sta PpuCtrlShadow ; CPU:$CD1E PRG:0D1E 85 EF
sta PPUCTRL ; CPU:$CD20 PRG:0D20 8D 00 20
rts ; CPU:$CD23 PRG:0D23 60
; -----------------------------------------------------------------------------
; Routine: OamDmaSetup
; Global: Points the PPU OAM address at $0200 and starts the 256-byte sprite DMA.
; Local: Returns to the NMI body once the transfer is issued.
; Parameters: None.
; Returns: OAM DMA issued.
; Clobbers: A; OAMADDR, $4014.
; -----------------------------------------------------------------------------
OamDmaSetup:
lda #$00 ; CPU:$CD24 PRG:0D24 A9 00
sta OAMADDR ; CPU:$CD26 PRG:0D26 8D 03 20
lda #$02 ; CPU:$CD29 PRG:0D29 A9 02
sta OAMDMA ; CPU:$CD2B PRG:0D2B 8D 14 40
rts ; CPU:$CD2E PRG:0D2E 60
; -----------------------------------------------------------------------------
; Routine: PpuMaskSetup
; Global: Masks bits 5 and 3 out of the PPUMASK shadow and writes the result to both the shadow and PPUMASK.
; Local: Falls through to WritePpuMask.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A; PPUMASK, PpuMaskShadow.
; -----------------------------------------------------------------------------
PpuMaskSetup:
lda PpuMaskShadow ; CPU:$CD2F PRG:0D2F A5 EE
and #$E7 ; CPU:$CD31 PRG:0D31 29 E7
; -----------------------------------------------------------------------------
; Routine: WritePpuMask
; Global: Writes the prepared PPUMASK value to both the shadow and the hardware register, then returns.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A; PPUMASK, PpuMaskShadow.
; -----------------------------------------------------------------------------
WritePpuMask:
sta PpuMaskShadow ; CPU:$CD33 PRG:0D33 85 EE
sta PPUMASK ; CPU:$CD35 PRG:0D35 8D 01 20
rts ; CPU:$CD38 PRG:0D38 60
; -----------------------------------------------------------------------------
; Routine: EnableSpritesAndBackground
; Global: Sets bits 4 and 3 in the PPUMASK shadow to turn sprites and background back on, then shares WritePpuMask's store-and-return tail.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A; PPUMASK, PpuMaskShadow.
; -----------------------------------------------------------------------------
EnableSpritesAndBackground:
lda PpuMaskShadow ; CPU:$CD39 PRG:0D39 A5 EE
ora #$18 ; CPU:$CD3B PRG:0D3B 09 18
bne WritePpuMask ; CPU:$CD3D PRG:0D3D D0 F4
; -----------------------------------------------------------------------------
; Routine: VramPtrWrite
; Global: Top of the indirect VRAM writer. First runs RetAddrUpdate so the caller's return address drives the dispatch, then reads the next byte from the operation stream.
; Local: Falls into VramPtrTableRead; the two are called as a pair.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y; VRAM pointer.
; -----------------------------------------------------------------------------
VramPtrWrite:
jsr RetAddrUpdate ; CPU:$CD3F PRG:0D3F 20 C8 CD
jmp VramPtrTableRead ; CPU:$CD42 PRG:0D42 4C 99 CD
; -----------------------------------------------------------------------------
; Routine: VramWriteLoop
; Global: Sets the PPU address for the current VRAM command by writing the high byte and low byte to PPUADDR in two steps, pulling each from the stream.
; Local: Loops over the stream bytes, then falls through.
; Parameters: Y = stream index.
; Returns: PPU address latched.
; Clobbers: A, Y; PPUADDR; stack via pha/pla.
; -----------------------------------------------------------------------------
VramWriteLoop:
pha ; CPU:$CD45 PRG:0D45 48
sta PPUADDR ; CPU:$CD46 PRG:0D46 8D 06 20
iny ; CPU:$CD49 PRG:0D49 C8
lda (VramPtrLo),y ; CPU:$CD4A PRG:0D4A B1 00
sta PPUADDR ; CPU:$CD4C PRG:0D4C 8D 06 20
iny ; CPU:$CD4F PRG:0D4F C8
lda (VramPtrLo),y ; CPU:$CD50 PRG:0D50 B1 00
asl a ; CPU:$CD52 PRG:0D52 0A
pha ; CPU:$CD53 PRG:0D53 48
lda PpuCtrlShadow ; CPU:$CD54 PRG:0D54 A5 EF
ora #$04 ; CPU:$CD56 PRG:0D56 09 04
bcs WritePpuCtrlFromShadow ; CPU:$CD58 PRG:0D58 B0 02
and #$FB ; CPU:$CD5A PRG:0D5A 29 FB
; -----------------------------------------------------------------------------
; Routine: WritePpuCtrlFromShadow
; Global: Writes A to PPUCTRL and stores the same value back into the shadow, so the shadow and the hardware register never disagree.
; Local: Falls through to the flag save that the dispatch stream needs.
; Parameters: A = PPUCTRL value.
; Returns: Nothing.
; Clobbers: A; PPUCTRL, PpuCtrlShadow; stack via asl/php.
; -----------------------------------------------------------------------------
WritePpuCtrlFromShadow:
sta PPUCTRL ; CPU:$CD5C PRG:0D5C 8D 00 20
sta PpuCtrlShadow ; CPU:$CD5F PRG:0D5F 85 EF
pla ; CPU:$CD61 PRG:0D61 68
asl a ; CPU:$CD62 PRG:0D62 0A
php ; CPU:$CD63 PRG:0D63 08
bcc ReturnFromVramPtrWrite ; CPU:$CD64 PRG:0D64 90 03
ora #$02 ; CPU:$CD66 PRG:0D66 09 02
iny ; CPU:$CD68 PRG:0D68 C8
; -----------------------------------------------------------------------------
; Routine: ReturnFromVramPtrWrite
; Global: Restores the flags the dispatch stream saved, then normalises carry: it clears carry and branches when the restored result was non-zero, and sets carry otherwise. Carry is the stream's 'long command' selector.
; Local: Branches to ComputeVramByteCount or falls through with carry set.
; Parameters: None.
; Returns: Carry set per the restored flags.
; Clobbers: P; stack via plp.
; -----------------------------------------------------------------------------
ReturnFromVramPtrWrite:
plp ; CPU:$CD69 PRG:0D69 28
clc ; CPU:$CD6A PRG:0D6A 18
bne ComputeVramByteCount ; CPU:$CD6B PRG:0D6B D0 01
sec ; CPU:$CD6D PRG:0D6D 38
; -----------------------------------------------------------------------------
; Routine: ComputeVramByteCount
; Global: Derives the write length from the command byte using two rotations, giving the count of following data bytes.
; Local: Falls through to AdvanceVramReadIndex.
; Parameters: A = command byte.
; Returns: X = byte count.
; Clobbers: A, X.
; -----------------------------------------------------------------------------
ComputeVramByteCount:
ror a ; CPU:$CD6E PRG:0D6E 6A
lsr a ; CPU:$CD6F PRG:0D6F 4A
tax ; CPU:$CD70 PRG:0D70 AA
; -----------------------------------------------------------------------------
; Routine: AdvanceVramReadIndex
; Global: Steps the stream read index, honouring a carry-flag adjustment for the long-command form.
; Local: Falls through to WriteVramStreamByte.
; Parameters: Carry selects the index step.
; Returns: Stream index advanced.
; Clobbers: Y, carry.
; -----------------------------------------------------------------------------
AdvanceVramReadIndex:
bcs WriteVramStreamByte ; CPU:$CD71 PRG:0D71 B0 01
iny ; CPU:$CD73 PRG:0D73 C8
; -----------------------------------------------------------------------------
; Routine: WriteVramStreamByte
; Global: Copies one byte per iteration from the stream, indexed indirectly through the VRAM pointer, straight into PPUDATA.
; Local: Loops until X reaches zero, then falls through.
; Parameters: X = remaining bytes.
; Returns: Nothing.
; Clobbers: A, X, Y; PPUDATA.
; -----------------------------------------------------------------------------
WriteVramStreamByte:
lda (VramPtrLo),y ; CPU:$CD74 PRG:0D74 B1 00
sta PPUDATA ; CPU:$CD76 PRG:0D76 8D 07 20
dex ; CPU:$CD79 PRG:0D79 CA
bne AdvanceVramReadIndex ; CPU:$CD7A PRG:0D7A D0 F5
pla ; CPU:$CD7C PRG:0D7C 68
cmp #$3F ; CPU:$CD7D PRG:0D7D C9 3F
bne AdvanceVramPointerByY ; CPU:$CD7F PRG:0D7F D0 0C
sta PPUADDR ; CPU:$CD81 PRG:0D81 8D 06 20
stx PPUADDR ; CPU:$CD84 PRG:0D84 8E 06 20
stx PPUADDR ; CPU:$CD87 PRG:0D87 8E 06 20
stx PPUADDR ; CPU:$CD8A PRG:0D8A 8E 06 20
; -----------------------------------------------------------------------------
; Routine: AdvanceVramPointerByY
; Global: Adds the stream offset to the VRAM pointer before the next command.
; Local: Falls through to the next command dispatch.
; Parameters: Y = offset.
; Returns: Pointer advanced.
; Clobbers: A, Y; VramPtrLo/Hi.
; -----------------------------------------------------------------------------
AdvanceVramPointerByY:
sec ; CPU:$CD8D PRG:0D8D 38
tya ; CPU:$CD8E PRG:0D8E 98
adc VramPtrLo ; CPU:$CD8F PRG:0D8F 65 00
sta VramPtrLo ; CPU:$CD91 PRG:0D91 85 00
lda #$00 ; CPU:$CD93 PRG:0D93 A9 00
adc Zp01 ; CPU:$CD95 PRG:0D95 65 01
sta Zp01 ; CPU:$CD97 PRG:0D97 85 01
; -----------------------------------------------------------------------------
; Routine: VramPtrTableRead
; Global: Reads the next opcode byte from the operation stream indexed by the VRAM pointer.
; Local: Branches to HandleJmpOpcode or HandlePpuCtrlOpcode by opcode value.
; Parameters: None.
; Returns: A = opcode byte.
; Clobbers: A, X, Y; VramPtrLo/Hi.
; -----------------------------------------------------------------------------
VramPtrTableRead:
ldx PPUSTATUS ; CPU:$CD99 PRG:0D99 AE 02 20
ldy #$00 ; CPU:$CD9C PRG:0D9C A0 00
lda (VramPtrLo),y ; CPU:$CD9E PRG:0D9E B1 00
bpl HandlePpuCtrlOpcode ; CPU:$CDA0 PRG:0DA0 10 01
rts ; CPU:$CDA2 PRG:0DA2 60
; -----------------------------------------------------------------------------
; Routine: HandlePpuCtrlOpcode
; Global: Recognises the stream opcode $60 and performs the deferred PPUCTRL write it introduces.
; Local: Falls through to the shared VRAM write path.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A; PpuCtrlShadow, PPUCTRL.
; -----------------------------------------------------------------------------
HandlePpuCtrlOpcode:
cmp #$60 ; CPU:$CDA3 PRG:0DA3 C9 60
bne HandleJmpOpcode ; CPU:$CDA5 PRG:0DA5 D0 0A
pla ; CPU:$CDA7 PRG:0DA7 68
sta Zp01 ; CPU:$CDA8 PRG:0DA8 85 01
pla ; CPU:$CDAA PRG:0DAA 68
sta VramPtrLo ; CPU:$CDAB PRG:0DAB 85 00
ldy #$02 ; CPU:$CDAD PRG:0DAD A0 02
bne AdvanceVramPointerByY ; CPU:$CDAF PRG:0DAF D0 DC
; -----------------------------------------------------------------------------
; Routine: HandleJmpOpcode
; Global: Recognises the stream opcode $4C and rewrites the dispatch pointer so the stream can jump within itself.
; Local: Falls through to the shared VRAM write path.
; Parameters: None.
; Returns: Dispatch pointer updated.
; Clobbers: A, X, Y; VramPtrLo/Hi.
; -----------------------------------------------------------------------------
HandleJmpOpcode:
cmp #$4C ; CPU:$CDB1 PRG:0DB1 C9 4C
bne VramWriteLoop ; CPU:$CDB3 PRG:0DB3 D0 90
lda VramPtrLo ; CPU:$CDB5 PRG:0DB5 A5 00
pha ; CPU:$CDB7 PRG:0DB7 48
lda Zp01 ; CPU:$CDB8 PRG:0DB8 A5 01
pha ; CPU:$CDBA PRG:0DBA 48
iny ; CPU:$CDBB PRG:0DBB C8
lda (VramPtrLo),y ; CPU:$CDBC PRG:0DBC B1 00
tax ; CPU:$CDBE PRG:0DBE AA
iny ; CPU:$CDBF PRG:0DBF C8
lda (VramPtrLo),y ; CPU:$CDC0 PRG:0DC0 B1 00
sta Zp01 ; CPU:$CDC2 PRG:0DC2 85 01
stx VramPtrLo ; CPU:$CDC4 PRG:0DC4 86 00
bcs VramPtrTableRead ; CPU:$CDC6 PRG:0DC6 B0 D1
; -----------------------------------------------------------------------------
; Routine: RetAddrUpdate
; Global: Pulls the caller's return address off the CPU stack and uses it as a program counter for the VRAM command stream. This is the runtime dispatch that a purely static tracer cannot follow, and the reason the operation handlers look unreachable.
; Local: Jumps into the stream; each handler eventually returns here.
; Parameters: None.
; Returns: Return address rewritten from the stream.
; Clobbers: A, X, Y, stack; RetAddrTempLo/Hi.
; -----------------------------------------------------------------------------
RetAddrUpdate:
tsx ; CPU:$CDC8 PRG:0DC8 BA
lda $0103,x ; CPU:$CDC9 PRG:0DC9 BD 03 01
sta Zp05 ; CPU:$CDCC PRG:0DCC 85 05
lda $0104,x ; CPU:$CDCE PRG:0DCE BD 04 01
sta Zp06 ; CPU:$CDD1 PRG:0DD1 85 06
ldy #$01 ; CPU:$CDD3 PRG:0DD3 A0 01
lda (Zp05),y ; CPU:$CDD5 PRG:0DD5 B1 05
sta VramPtrLo ; CPU:$CDD7 PRG:0DD7 85 00
iny ; CPU:$CDD9 PRG:0DD9 C8
lda (Zp05),y ; CPU:$CDDA PRG:0DDA B1 05
sta Zp01 ; CPU:$CDDC PRG:0DDC 85 01
clc ; CPU:$CDDE PRG:0DDE 18
lda #$02 ; CPU:$CDDF PRG:0DDF A9 02
adc Zp05 ; CPU:$CDE1 PRG:0DE1 65 05
sta $0103,x ; CPU:$CDE3 PRG:0DE3 9D 03 01
lda #$00 ; CPU:$CDE6 PRG:0DE6 A9 00
adc Zp06 ; CPU:$CDE8 PRG:0DE8 65 06
sta $0104,x ; CPU:$CDEA PRG:0DEA 9D 04 01
rts ; CPU:$CDED PRG:0DED 60
; -----------------------------------------------------------------------------
; Routine: VramWrite
; Global: Direct VRAM writer used by the burst path: sets the pointer, length and destination registers from its arguments.
; Local: Falls into VramWriteSetup.
; Parameters: A, X, Y = pointer, length, destination.
; Returns: Nothing.
; Clobbers: A, X, Y; VramPtrLo/Hi.
; -----------------------------------------------------------------------------
VramWrite:
sta VramPtrLo ; CPU:$CDEE PRG:0DEE 85 00
stx Zp01 ; CPU:$CDF0 PRG:0DF0 86 01
sty Zp02 ; CPU:$CDF2 PRG:0DF2 84 02
lda PPUSTATUS ; CPU:$CDF4 PRG:0DF4 AD 02 20
lda PpuCtrlShadow ; CPU:$CDF7 PRG:0DF7 A5 EF
and #$FB ; CPU:$CDF9 PRG:0DF9 29 FB
sta PPUCTRL ; CPU:$CDFB PRG:0DFB 8D 00 20
sta PpuCtrlShadow ; CPU:$CDFE PRG:0DFE 85 EF
lda VramPtrLo ; CPU:$CE00 PRG:0E00 A5 00
sta PPUADDR ; CPU:$CE02 PRG:0E02 8D 06 20
ldy #$00 ; CPU:$CE05 PRG:0E05 A0 00
sty PPUADDR ; CPU:$CE07 PRG:0E07 8C 06 20
ldx #$04 ; CPU:$CE0A PRG:0E0A A2 04
cmp #$20 ; CPU:$CE0C PRG:0E0C C9 20
bcs VramWriteSetup ; CPU:$CE0E PRG:0E0E B0 02
ldx Zp02 ; CPU:$CE10 PRG:0E10 A6 02
; -----------------------------------------------------------------------------
; Routine: VramWriteSetup
; Global: Prepares the length counter for a direct VRAM write.
; Local: Falls into WriteVramZeroFill or WriteVramByteStream by length.
; Parameters: None.
; Returns: Length loaded.
; Clobbers: A, Y; VramOpLength.
; -----------------------------------------------------------------------------
VramWriteSetup:
ldy #$00 ; CPU:$CE12 PRG:0E12 A0 00
lda Zp01 ; CPU:$CE14 PRG:0E14 A5 01
; -----------------------------------------------------------------------------
; Routine: WriteVramZeroFill
; Global: Writes a run of $00 bytes to PPUDATA until the length counter expires.
; Local: Falls through when Y reaches zero.
; Parameters: Y = remaining bytes.
; Returns: Nothing.
; Clobbers: Y; PPUDATA.
; -----------------------------------------------------------------------------
WriteVramZeroFill:
sta PPUDATA ; CPU:$CE16 PRG:0E16 8D 07 20
dey ; CPU:$CE19 PRG:0E19 88
bne WriteVramZeroFill ; CPU:$CE1A PRG:0E1A D0 FA
dex ; CPU:$CE1C PRG:0E1C CA
bne WriteVramZeroFill ; CPU:$CE1D PRG:0E1D D0 F7
ldy Zp02 ; CPU:$CE1F PRG:0E1F A4 02
lda VramPtrLo ; CPU:$CE21 PRG:0E21 A5 00
cmp #$20 ; CPU:$CE23 PRG:0E23 C9 20
bcc VramWriteDone ; CPU:$CE25 PRG:0E25 90 12
adc #$02 ; CPU:$CE27 PRG:0E27 69 02
sta PPUADDR ; CPU:$CE29 PRG:0E29 8D 06 20
lda #$C0 ; CPU:$CE2C PRG:0E2C A9 C0
sta PPUADDR ; CPU:$CE2E PRG:0E2E 8D 06 20
ldx #$40 ; CPU:$CE31 PRG:0E31 A2 40
; -----------------------------------------------------------------------------
; Routine: WriteVramByteStream
; Global: Writes a run of bytes to PPUDATA, one per X iteration.
; Local: Falls through when X reaches zero.
; Parameters: X = remaining bytes.
; Returns: Nothing.
; Clobbers: A, X; PPUDATA.
; -----------------------------------------------------------------------------
WriteVramByteStream:
sty PPUDATA ; CPU:$CE33 PRG:0E33 8C 07 20
dex ; CPU:$CE36 PRG:0E36 CA
bne WriteVramByteStream ; CPU:$CE37 PRG:0E37 D0 FA
; -----------------------------------------------------------------------------
; Routine: VramWriteDone
; Global: Restores the VRAM pointer high byte and returns from a direct write.
; Local: RTS.
; Parameters: None.
; Returns: A = final pointer value.
; Clobbers: A, X.
; -----------------------------------------------------------------------------
VramWriteDone:
ldx VramPtrHi ; CPU:$CE39 PRG:0E39 A6 01
rts ; CPU:$CE3B PRG:0E3B 60
; -----------------------------------------------------------------------------
; Routine: PpuScrollLatch
; Global: Writes the latched scroll X and Y values to PPUSCROLL in the correct order.
; Local: Returns to the NMI body.
; Parameters: None.
; Returns: Scroll latched.
; Clobbers: A; PPUSTATUS, PPUSCROLL.
; -----------------------------------------------------------------------------
PpuScrollLatch:
lda PPUSTATUS ; CPU:$CE3C PRG:0E3C AD 02 20
lda PpuScrollXInit ; CPU:$CE3F PRG:0E3F A5 ED
sta PPUSCROLL ; CPU:$CE41 PRG:0E41 8D 05 20
lda ZpEC ; CPU:$CE44 PRG:0E44 A5 EC
sta PPUSCROLL ; CPU:$CE46 PRG:0E46 8D 05 20
lda PpuCtrlShadow ; CPU:$CE49 PRG:0E49 A5 EF
sta PPUCTRL ; CPU:$CE4B PRG:0E4B 8D 00 20
rts ; CPU:$CE4E PRG:0E4E 60
; -----------------------------------------------------------------------------
; Routine: VramBurstWrite
; Global: Burst writer: clears bit 2 of the PPUCTRL shadow so VRAM stays accessible, then walks the command list at VramBurstIndex.
; Local: Falls into VramBurstWriteChunk.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A; PPUCTRL, PpuCtrlShadow.
; -----------------------------------------------------------------------------
VramBurstWrite:
lda PpuCtrlShadow ; CPU:$CE4F PRG:0E4F A5 EF
and #$FB ; CPU:$CE51 PRG:0E51 29 FB
sta PPUCTRL ; CPU:$CE53 PRG:0E53 8D 00 20
sta PpuCtrlShadow ; CPU:$CE56 PRG:0E56 85 EF
ldx PPUSTATUS ; CPU:$CE58 PRG:0E58 AE 02 20
ldy #$00 ; CPU:$CE5B PRG:0E5B A0 00
beq VramBurstNextCommand ; CPU:$CE5D PRG:0E5D F0 2B
; -----------------------------------------------------------------------------
; Routine: VramBurstWriteChunk
; Global: Writes one chunk of the burst stream to PPUDATA.
; Local: Falls through to VramBurstWriteNext.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, Y; PPUADDR, PPUDATA.
; -----------------------------------------------------------------------------
VramBurstWriteChunk:
pha ; CPU:$CE5F PRG:0E5F 48
sta PPUADDR ; CPU:$CE60 PRG:0E60 8D 06 20
iny ; CPU:$CE63 PRG:0E63 C8
lda VramBurstIndex,y ; CPU:$CE64 PRG:0E64 B9 02 03
sta PPUADDR ; CPU:$CE67 PRG:0E67 8D 06 20
iny ; CPU:$CE6A PRG:0E6A C8
ldx VramBurstIndex,y ; CPU:$CE6B PRG:0E6B BE 02 03
; -----------------------------------------------------------------------------
; Routine: VramBurstWriteNext
; Global: Advances to the next burst entry and tests its sign bit to decide between another chunk and the end of the list.
; Local: Branches to VramBurstSkipRun or VramBurstNextCommand.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, Y; VramBurstIndex.
; -----------------------------------------------------------------------------
VramBurstWriteNext:
iny ; CPU:$CE6E PRG:0E6E C8
lda VramBurstIndex,y ; CPU:$CE6F PRG:0E6F B9 02 03
sta PPUDATA ; CPU:$CE72 PRG:0E72 8D 07 20
dex ; CPU:$CE75 PRG:0E75 CA
bne VramBurstWriteNext ; CPU:$CE76 PRG:0E76 D0 F6
pla ; CPU:$CE78 PRG:0E78 68
cmp #$3F ; CPU:$CE79 PRG:0E79 C9 3F
bne VramBurstSkipRun ; CPU:$CE7B PRG:0E7B D0 0C
sta PPUADDR ; CPU:$CE7D PRG:0E7D 8D 06 20
stx PPUADDR ; CPU:$CE80 PRG:0E80 8E 06 20
stx PPUADDR ; CPU:$CE83 PRG:0E83 8E 06 20
stx PPUADDR ; CPU:$CE86 PRG:0E86 8E 06 20
; -----------------------------------------------------------------------------
; Routine: VramBurstSkipRun
; Global: Skips a run of burst entries without writing them.
; Local: Falls into VramBurstWriteChunk once the skip is done.
; Parameters: None.
; Returns: Nothing.
; Clobbers: Y; VramBurstIndex.
; -----------------------------------------------------------------------------
VramBurstSkipRun:
iny ; CPU:$CE89 PRG:0E89 C8
; -----------------------------------------------------------------------------
; Routine: VramBurstNextCommand
; Global: Fetches the next burst command byte and tests its sign to branch between a write and a skip.
; Local: Branches to VramBurstSkipRun or VramBurstWriteChunk.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, Y; VramBurstIndex.
; -----------------------------------------------------------------------------
VramBurstNextCommand:
lda VramBurstIndex,y ; CPU:$CE8A PRG:0E8A B9 02 03
bpl VramBurstWriteChunk ; CPU:$CE8D PRG:0E8D 10 D0
sta VramBurstIndex ; CPU:$CE8F PRG:0E8F 8D 02 03
lda #$00 ; CPU:$CE92 PRG:0E92 A9 00
sta $0301 ; CPU:$CE94 PRG:0E94 8D 01 03
rts ; CPU:$CE97 PRG:0E97 60
; -----------------------------------------------------------------------------
; Routine: DispatchVramOp
; Global: Entry point for a VRAM command: saves the arguments, runs RetAddrUpdate to bind the stream, and begins executing the command.
; Local: Jumps into the command stream; returns via VramOpReturn.
; Parameters: A, X = command arguments.
; Returns: Nothing.
; Clobbers: A, X, Y; RetAddrTempLo/Hi, VramOpResult.
; -----------------------------------------------------------------------------
DispatchVramOp:
sta Zp03 ; CPU:$CE98 PRG:0E98 85 03
stx Zp02 ; CPU:$CE9A PRG:0E9A 86 02
jsr RetAddrUpdate ; CPU:$CE9C PRG:0E9C 20 C8 CD
ldy #$00 ; CPU:$CE9F PRG:0E9F A0 00
lda (VramPtrLo),y ; CPU:$CEA1 PRG:0EA1 B1 00
and #$0F ; CPU:$CEA3 PRG:0EA3 29 0F
sta Zp04 ; CPU:$CEA5 PRG:0EA5 85 04
lda (VramPtrLo),y ; CPU:$CEA7 PRG:0EA7 B1 00
lsr a ; CPU:$CEA9 PRG:0EA9 4A
lsr a ; CPU:$CEAA PRG:0EAA 4A
lsr a ; CPU:$CEAB PRG:0EAB 4A
lsr a ; CPU:$CEAC PRG:0EAC 4A
sta Zp05 ; CPU:$CEAD PRG:0EAD 85 05
ldx $0301 ; CPU:$CEAF PRG:0EAF AE 01 03
; -----------------------------------------------------------------------------
; Routine: StoreVramOpResult
; Global: Stores the VRAM operation's result and its length into the burst command table at VramBurstIndex, indexed by X, running the length check between the two stores.
; Local: Returns to the caller via VramOpReturn.
; Parameters: X = table index.
; Returns: Burst table updated.
; Clobbers: A, X; VramBurstIndex, VramOpResult, VramOpLength.
; -----------------------------------------------------------------------------
StoreVramOpResult:
lda Zp03 ; CPU:$CEB2 PRG:0EB2 A5 03
sta VramBurstIndex,x ; CPU:$CEB4 PRG:0EB4 9D 02 03
jsr $CEF3 ; CPU:$CEB7 PRG:0EB7 20 F3 CE
lda Zp02 ; CPU:$CEBA PRG:0EBA A5 02
sta VramBurstIndex,x ; CPU:$CEBC PRG:0EBC 9D 02 03
jsr $CEF3 ; CPU:$CEBF PRG:0EBF 20 F3 CE
lda Zp04 ; CPU:$CEC2 PRG:0EC2 A5 04
sta Zp06 ; CPU:$CEC4 PRG:0EC4 85 06
sta VramBurstIndex,x ; CPU:$CEC6 PRG:0EC6 9D 02 03
; -----------------------------------------------------------------------------
; Routine: VramOpDataStream
; Global: Walks the VRAM operation data stream one byte at a time.
; Local: Falls through when the stream is exhausted.
; Parameters: Y = stream index.
; Returns: Nothing.
; Clobbers: A, Y.
; -----------------------------------------------------------------------------
VramOpDataStream:
jsr $CEF3 ; CPU:$CEC9 PRG:0EC9 20 F3 CE
iny ; CPU:$CECC PRG:0ECC C8
lda (VramPtrLo),y ; CPU:$CECD PRG:0ECD B1 00
sta VramBurstIndex,x ; CPU:$CECF PRG:0ECF 9D 02 03
dec Zp06 ; CPU:$CED2 PRG:0ED2 C6 06
bne VramOpDataStream ; CPU:$CED4 PRG:0ED4 D0 F3
jsr $CEF3 ; CPU:$CED6 PRG:0ED6 20 F3 CE
stx $0301 ; CPU:$CED9 PRG:0ED9 8E 01 03
clc ; CPU:$CEDC PRG:0EDC 18
lda #$20 ; CPU:$CEDD PRG:0EDD A9 20
adc Zp02 ; CPU:$CEDF PRG:0EDF 65 02
sta Zp02 ; CPU:$CEE1 PRG:0EE1 85 02
lda #$00 ; CPU:$CEE3 PRG:0EE3 A9 00
adc Zp03 ; CPU:$CEE5 PRG:0EE5 65 03
sta Zp03 ; CPU:$CEE7 PRG:0EE7 85 03
dec Zp05 ; CPU:$CEE9 PRG:0EE9 C6 05
bne StoreVramOpResult ; CPU:$CEEB PRG:0EEB D0 C5
lda #$FF ; CPU:$CEED PRG:0EED A9 FF
sta VramBurstIndex,x ; CPU:$CEEF PRG:0EEF 9D 02 03
rts ; CPU:$CEF2 PRG:0EF2 60
; -----------------------------------------------------------------------------
; Routine: VramOpLengthCheck
; Global: Checks the accumulated operation length against the limit at $0300 before continuing.
; Local: Branches to VramOpReturn when the limit is reached.
; Parameters: None.
; Returns: Carry reflects the comparison.
; Clobbers: X, carry; $0300.
; -----------------------------------------------------------------------------
VramOpLengthCheck:
inx ; CPU:$CEF3 PRG:0EF3 E8
cpx $0300 ; CPU:$CEF4 PRG:0EF4 EC 00 03
bcc VramOpReturn ; CPU:$CEF7 PRG:0EF7 90 0C
ldx $0301 ; CPU:$CEF9 PRG:0EF9 AE 01 03
lda #$FF ; CPU:$CEFC PRG:0EFC A9 FF
sta VramBurstIndex,x ; CPU:$CEFE PRG:0EFE 9D 02 03
pla ; CPU:$CF01 PRG:0F01 68
pla ; CPU:$CF02 PRG:0F02 68
lda #$01 ; CPU:$CF03 PRG:0F03 A9 01
; -----------------------------------------------------------------------------
; Routine: VramOpReturn
; Global: Restores the saved dispatch state and returns from a VRAM operation.
; Local: RTS.
; Parameters: None.
; Returns: Nothing.
; Clobbers: A, X, Y; stack.
; -----------------------------------------------------------------------------
VramOpReturn:
rts ; CPU:$CF05 PRG:0F05 60
; ---- data region $CF06-$FFFF (12538 bytes) ----
; Split into named sub-blocks based on structural boundaries.
;
; Sub-block map:
; $CF06-$CF28 VramCommandStream1 VRAM command stream start - PPU addr/data pairs read by VramWriteLoop
; $CF29-$CF29 VramStream1Terminator FF terminator byte ending first command stream
; $CF2A-$CF3F VramCommandInlineCode Inline code after jsr $CE98 - lax $20D4, nop $C1,X, $61 padding
; $CF40-$D061 VramCommandBlock2 VRAM command/data block - PPU writes and OAM attribute patterns
; $D062-$D062 VramStream2Terminator FF terminator byte ending second command stream
; $D063-$D1F3 VramCommandBlock3 VRAM command/data block - continues command stream patterns
; $D1F4-$D1F4 VramStream3Terminator FF terminator byte ending third command stream
; $D1F5-$D4AD VramCommandBlock4 Largest VRAM command/data block - 697 bytes of command stream
; $D4AE-$D4AE OamTableStreamTerminator FF terminator byte before OAM gap data
; $D4AF-$D4E1 OamTableGap Gap data before OAM table at $D4E3
; $D4E2-$D4E2 OamTable1Terminator FF terminator byte before OAM table group 1
; $D4E3-$D5C2 OamTableGroups1 OAM table groups 1-7 (CopyOamFromTable reads $D4E3) - 7x32 byte tables
; $D5C3-$D5C3 OamTableStream2Terminator FF terminator byte before second OAM table group
; $D5C4-$D603 OamTableGroups2 OAM table groups 1-2 (CopyOamFromTable70 reads $D5C4) - 2x32 byte tables
; $D604-$D643 OamSpritePadding 64 bytes of $F4 sprite off-screen padding
; $D644-$D6A3 OamTableGroups3 OAM table groups 3-5 - 3x32 byte tables before sprite template
; $D6A4-$D6A4 SpriteTableTerminator FF terminator byte before sprite template table
; $D6A5-$D6C4 SpriteTemplateTable 32-byte sprite template (CopySpriteTemplateTable reads $D6A5) - 8x4 Y/tile/attr/X
; $D6C5-$D6E4 ButtonOamTemplateTable 32-byte button OAM template (PrepareButtonOam reads $D6C5) - 8x4 Y/tile/attr/X
; $D6E5-$FFF9 RomPadding 10517 bytes of $FF ROM padding
; $FFFA-$FFFF ResetVectors Reset/NMI/IRQ vectors - 6 bytes
;
VramCommandStream1:
; VRAM command stream start - PPU addr/data pairs read by VramWriteLoop
; ---- $CF06-$CF28 (35 bytes) ----
.byte $3F, $00, $20, $0F, $16, $00, $30, $0F, $1A, $2A, $30, $0F, $1A, $00, $30, $0F ; CPU:$CF06 PRG:0F06 3F 00 20 0F 16 00 30 0F 1A 2A 30 0F 1A 00 30 0F
.byte $30, $00, $30, $0F, $16, $00, $30, $0F, $1A, $2A, $30, $0F, $1A, $00, $30, $0F ; CPU:$CF16 PRG:0F16 30 00 30 0F 16 00 30 0F 1A 2A 30 0F 1A 00 30 0F
.byte $30, $00, $30 ; CPU:$CF26 PRG:0F26 30 00 30
VramStream1Terminator:
; FF terminator byte ending first command stream
; ---- $CF29-$CF29 (1 bytes) ----
.byte $FF ; CPU:$CF29 PRG:0F29 FF
VramCommandInlineCode:
; Inline code after jsr $CE98 - lax $20D4, nop $C1,X, $61 padding
; ---- $CF2A-$CF3F (22 bytes) ----
.byte $20, $A2, $1C, $60, $61, $61, $61, $61, $61, $61, $61, $61, $61, $61, $61, $61 ; CPU:$CF2A PRG:0F2A 20 A2 1C 60 61 61 61 61 61 61 61 61 61 61 61 61
.byte $61, $61, $61, $61, $61, $61 ; CPU:$CF3A PRG:0F3A 61 61 61 61 61 61
VramCommandBlock2:
; VRAM command/data block - PPU writes and OAM attribute patterns
; ---- $CF40-$D061 (290 bytes) ----
.byte $61, $61, $61, $61, $61, $61, $61, $61, $66, $20, $C2, $1C, $64, $70, $71, $72 ; CPU:$CF40 PRG:0F40 61 61 61 61 61 61 61 61 66 20 C2 1C 64 70 71 72
.byte $73, $74, $75, $76, $77, $78, $79, $7A, $7B, $24, $7D, $7E, $7F, $A0, $A1, $A2 ; CPU:$CF50 PRG:0F50 73 74 75 76 77 78 79 7A 7B 24 7D 7E 7F A0 A1 A2
.byte $A3, $A4, $A5, $A6, $A7, $A8, $A9, $67, $20, $E2, $1C, $64, $80, $81, $82, $83 ; CPU:$CF60 PRG:0F60 A3 A4 A5 A6 A7 A8 A9 67 20 E2 1C 64 80 81 82 83
.byte $84, $85, $86, $87, $88, $89, $8A, $8B, $24, $8D, $8E, $8F, $B0, $B1, $24, $B3 ; CPU:$CF70 PRG:0F70 84 85 86 87 88 89 8A 8B 24 8D 8E 8F B0 B1 24 B3
.byte $B4, $B5, $B6, $B7, $B8, $B9, $67, $21, $02, $1C, $64, $90, $91, $92, $93, $94 ; CPU:$CF80 PRG:0F80 B4 B5 B6 B7 B8 B9 67 21 02 1C 64 90 91 92 93 94
.byte $95, $96, $97, $98, $99, $9A, $9B, $9C, $9D, $9E, $9F, $C0, $C1, $24, $C3, $C4 ; CPU:$CF90 PRG:0F90 95 96 97 98 99 9A 9B 9C 9D 9E 9F C0 C1 24 C3 C4
.byte $C5, $C6, $C7, $C8, $C9, $67, $21, $22, $1C, $62, $63, $63, $63, $63, $63, $63 ; CPU:$CFA0 PRG:0FA0 C5 C6 C7 C8 C9 67 21 22 1C 62 63 63 63 63 63 63
.byte $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63 ; CPU:$CFB0 PRG:0FB0 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63
.byte $63, $63, $63, $63, $65, $21, $C5, $18, $01, $24, $17, $18, $1B, $16, $0A, $15 ; CPU:$CFC0 PRG:0FC0 63 63 63 63 65 21 C5 18 01 24 17 18 1B 16 0A 15
.byte $24, $0C, $18, $17, $1D, $1B, $18, $15, $15, $0E, $1B, $24, $1D, $0E, $1C, $1D ; CPU:$CFD0 PRG:0FD0 24 0C 18 17 1D 1B 18 15 15 0E 1B 24 1D 0E 1C 1D
.byte $22, $25, $18, $02, $24, $04, $24, $19, $15, $0A, $22, $24, $0C, $18, $17, $1D ; CPU:$CFE0 PRG:0FE0 22 25 18 02 24 04 24 19 15 0A 22 24 0C 18 17 1D
.byte $1B, $18, $15, $15, $0E, $1B, $24, $1D, $0E, $1C, $1D, $22, $85, $18, $03, $24 ; CPU:$CFF0 PRG:0FF0 1B 18 15 15 0E 1B 24 1D 0E 1C 1D 22 85 18 03 24
.byte $1B, $0E, $1D, $1E, $1B, $17, $24, $1D, $18, $24, $16, $0A, $12, $17, $24, $16 ; CPU:$D000 PRG:1000 1B 0E 1D 1E 1B 17 24 1D 18 24 16 0A 12 17 24 16
.byte $0E, $17, $1E, $24, $24, $24, $23, $C0, $10, $00, $00, $00, $00, $00, $00, $00 ; CPU:$D010 PRG:1010 0E 17 1E 24 24 24 23 C0 10 00 00 00 00 00 00 00
.byte $00, $44, $55, $55, $55, $55, $55, $55, $11, $23, $D0, $10, $04, $05, $05, $05 ; CPU:$D020 PRG:1020 00 44 55 55 55 55 55 55 11 23 D0 10 04 05 05 05
.byte $05, $05, $05, $01, $00, $00, $00, $00, $00, $00, $00, $00, $23, $E0, $10, $00 ; CPU:$D030 PRG:1030 05 05 05 01 00 00 00 00 00 00 00 00 23 E0 10 00
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $23 ; CPU:$D040 PRG:1040 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 23
.byte $F0, $10, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; CPU:$D050 PRG:1050 F0 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00
.byte $00, $00 ; CPU:$D060 PRG:1060 00 00
VramStream2Terminator:
; FF terminator byte ending second command stream
; ---- $D062-$D062 (1 bytes) ----
.byte $FF ; CPU:$D062 PRG:1062 FF
VramCommandBlock3:
; VRAM command/data block - continues command stream patterns
; ---- $D063-$D1F3 (401 bytes) ----
.byte $20, $62, $1A, $1D, $1E, $1B, $0B, $18, $24, $1C, $24, $0B, $24, $0A, $24, $24 ; CPU:$D063 PRG:1063 20 62 1A 1D 1E 1B 0B 18 24 1C 24 0B 24 0A 24 24
.byte $02, $24, $19, $15, $0A, $22, $0E, $1B, $24, $1D, $0E, $1C, $1D, $20, $8F, $0D ; CPU:$D073 PRG:1073 02 24 19 15 0A 22 0E 1B 24 1D 0E 1C 1D 20 8F 0D
.byte $40, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $20, $AF, $0D ; CPU:$D083 PRG:1083 40 42 42 42 42 42 42 42 42 42 42 42 41 20 AF 0D
.byte $47, $24, $24, $24, $24, $24, $01, $24, $28, $29, $2A, $2B, $46, $20, $CF, $0D ; CPU:$D093 PRG:1093 47 24 24 24 24 24 01 24 28 29 2A 2B 46 20 CF 0D
.byte $47, $24, $4A, $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $20, $EF, $0D ; CPU:$D0A3 PRG:10A3 47 24 4A 24 24 24 24 24 24 24 24 24 46 20 EF 0D
.byte $47, $24, $24, $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $21, $0F, $0D ; CPU:$D0B3 PRG:10B3 47 24 24 24 24 24 26 24 24 24 26 24 46 21 0F 0D
.byte $44, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $21, $4F, $0D ; CPU:$D0C3 PRG:10C3 44 43 43 43 43 43 43 43 43 43 43 43 45 21 4F 0D
.byte $40, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $21, $6F, $0D ; CPU:$D0D3 PRG:10D3 40 42 42 42 42 42 42 42 42 42 42 42 41 21 6F 0D
.byte $47, $24, $24, $24, $24, $24, $02, $24, $28, $29, $2A, $2B, $46, $21, $8F, $0D ; CPU:$D0E3 PRG:10E3 47 24 24 24 24 24 02 24 28 29 2A 2B 46 21 8F 0D
.byte $47, $24, $4A, $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $21, $AF, $0D ; CPU:$D0F3 PRG:10F3 47 24 4A 24 24 24 24 24 24 24 24 24 46 21 AF 0D
.byte $47, $24, $24, $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $21, $CF, $0D ; CPU:$D103 PRG:1103 47 24 24 24 24 24 26 24 24 24 26 24 46 21 CF 0D
.byte $44, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $20, $A6, $01 ; CPU:$D113 PRG:1113 44 43 43 43 43 43 43 43 43 43 43 43 45 20 A6 01
.byte $D1, $21, $06, $01, $2C, $21, $66, $01, $D1, $21, $C6, $01, $2C, $20, $87, $07 ; CPU:$D123 PRG:1123 D1 21 06 01 2C 21 66 01 D1 21 C6 01 2C 20 87 07
.byte $58, $53, $5A, $53, $5A, $53, $57, $20, $A7, $07, $50, $24, $54, $24, $54, $24 ; CPU:$D133 PRG:1133 58 53 5A 53 5A 53 57 20 A7 07 50 24 54 24 54 24
.byte $51, $20, $C7, $07, $50, $24, $54, $24, $54, $24, $51, $20, $E7, $07, $50, $24 ; CPU:$D143 PRG:1143 51 20 C7 07 50 24 54 24 54 24 51 20 E7 07 50 24
.byte $54, $24, $54, $24, $51, $21, $07, $07, $50, $24, $54, $24, $54, $24, $51, $21 ; CPU:$D153 PRG:1153 54 24 54 24 51 21 07 07 50 24 54 24 54 24 51 21
.byte $27, $07, $56, $52, $59, $52, $59, $52, $55, $21, $47, $07, $58, $53, $5A, $53 ; CPU:$D163 PRG:1163 27 07 56 52 59 52 59 52 55 21 47 07 58 53 5A 53
.byte $5A, $53, $57, $21, $67, $07, $50, $24, $54, $24, $54, $24, $51, $21, $87, $07 ; CPU:$D173 PRG:1173 5A 53 57 21 67 07 50 24 54 24 54 24 51 21 87 07
.byte $50, $24, $54, $24, $54, $24, $51, $21, $A7, $07, $50, $24, $54, $24, $54, $24 ; CPU:$D183 PRG:1183 50 24 54 24 54 24 51 21 A7 07 50 24 54 24 54 24
.byte $51, $21, $C7, $07, $50, $24, $54, $24, $54, $24, $51, $21, $E7, $07, $56, $52 ; CPU:$D193 PRG:1193 51 21 C7 07 50 24 54 24 54 24 51 21 E7 07 56 52
.byte $59, $52, $59, $52, $55, $23, $C0, $10, $40, $50, $50, $50, $50, $50, $50, $00 ; CPU:$D1A3 PRG:11A3 59 52 59 52 55 23 C0 10 40 50 50 50 50 50 50 00
.byte $00, $00, $00, $00, $00, $03, $00, $00, $23, $D0, $10, $00, $00, $00, $00, $00 ; CPU:$D1B3 PRG:11B3 00 00 00 00 00 03 00 00 23 D0 10 00 00 00 00 00
.byte $30, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $23, $E0, $10, $00, $00 ; CPU:$D1C3 PRG:11C3 30 00 00 00 00 00 00 00 00 00 00 23 E0 10 00 00
.byte $00, $00, $00, $03, $00, $00, $00, $00, $00, $00, $00, $30, $00, $00, $23, $F0 ; CPU:$D1D3 PRG:11D3 00 00 00 03 00 00 00 00 00 00 00 30 00 00 23 F0
.byte $10, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; CPU:$D1E3 PRG:11E3 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
.byte $00 ; CPU:$D1F3 PRG:11F3 00
VramStream3Terminator:
; FF terminator byte ending third command stream
; ---- $D1F4-$D1F4 (1 bytes) ----
.byte $FF ; CPU:$D1F4 PRG:11F4 FF
VramCommandBlock4:
; Largest VRAM command/data block - 697 bytes of command stream
; ---- $D1F5-$D4AD (697 bytes) ----
.byte $20, $62, $1A, $1D, $1E, $1B, $0B, $18, $24, $1C, $24, $0B, $24, $0A, $24, $24 ; CPU:$D1F5 PRG:11F5 20 62 1A 1D 1E 1B 0B 18 24 1C 24 0B 24 0A 24 24
.byte $04, $24, $19, $15, $0A, $22, $0E, $1B, $24, $1D, $0E, $1C, $1D, $20, $8F, $0D ; CPU:$D205 PRG:1205 04 24 19 15 0A 22 0E 1B 24 1D 0E 1C 1D 20 8F 0D
.byte $40, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $20, $AF, $0D ; CPU:$D215 PRG:1215 40 42 42 42 42 42 42 42 42 42 42 42 41 20 AF 0D
.byte $47, $24, $24, $24, $24, $24, $01, $24, $28, $29, $2A, $2B, $46, $20, $CF, $0D ; CPU:$D225 PRG:1225 47 24 24 24 24 24 01 24 28 29 2A 2B 46 20 CF 0D
.byte $47, $24, $4A, $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $20, $EF, $0D ; CPU:$D235 PRG:1235 47 24 4A 24 24 24 24 24 24 24 24 24 46 20 EF 0D
.byte $47, $24, $24, $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $21, $0F, $0D ; CPU:$D245 PRG:1245 47 24 24 24 24 24 26 24 24 24 26 24 46 21 0F 0D
.byte $44, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $21, $4F, $0D ; CPU:$D255 PRG:1255 44 43 43 43 43 43 43 43 43 43 43 43 45 21 4F 0D
.byte $40, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $21, $6F, $0D ; CPU:$D265 PRG:1265 40 42 42 42 42 42 42 42 42 42 42 42 41 21 6F 0D
.byte $47, $24, $24, $24, $24, $24, $02, $24, $28, $29, $2A, $2B, $46, $21, $8F, $0D ; CPU:$D275 PRG:1275 47 24 24 24 24 24 02 24 28 29 2A 2B 46 21 8F 0D
.byte $47, $24, $4A, $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $21, $AF, $0D ; CPU:$D285 PRG:1285 47 24 4A 24 24 24 24 24 24 24 24 24 46 21 AF 0D
.byte $47, $24, $24, $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $21, $CF, $0D ; CPU:$D295 PRG:1295 47 24 24 24 24 24 26 24 24 24 26 24 46 21 CF 0D
.byte $44, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $22, $0F, $0D ; CPU:$D2A5 PRG:12A5 44 43 43 43 43 43 43 43 43 43 43 43 45 22 0F 0D
.byte $40, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $22, $2F, $0D ; CPU:$D2B5 PRG:12B5 40 42 42 42 42 42 42 42 42 42 42 42 41 22 2F 0D
.byte $47, $24, $24, $24, $24, $24, $03, $24, $28, $29, $2A, $2B, $46, $22, $4F, $0D ; CPU:$D2C5 PRG:12C5 47 24 24 24 24 24 03 24 28 29 2A 2B 46 22 4F 0D
.byte $47, $24, $4A, $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $22, $6F, $0D ; CPU:$D2D5 PRG:12D5 47 24 4A 24 24 24 24 24 24 24 24 24 46 22 6F 0D
.byte $47, $24, $24, $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $22, $8F, $0D ; CPU:$D2E5 PRG:12E5 47 24 24 24 24 24 26 24 24 24 26 24 46 22 8F 0D
.byte $44, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $22, $CF, $0D ; CPU:$D2F5 PRG:12F5 44 43 43 43 43 43 43 43 43 43 43 43 45 22 CF 0D
.byte $40, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $22, $EF, $0D ; CPU:$D305 PRG:1305 40 42 42 42 42 42 42 42 42 42 42 42 41 22 EF 0D
.byte $47, $24, $24, $24, $24, $24, $04, $24, $28, $29, $2A, $2B, $46, $23, $0F, $0D ; CPU:$D315 PRG:1315 47 24 24 24 24 24 04 24 28 29 2A 2B 46 23 0F 0D
.byte $47, $24, $4A, $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $23, $2F, $0D ; CPU:$D325 PRG:1325 47 24 4A 24 24 24 24 24 24 24 24 24 46 23 2F 0D
.byte $47, $24, $24, $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $23, $4F, $0D ; CPU:$D335 PRG:1335 47 24 24 24 24 24 26 24 24 24 26 24 46 23 4F 0D
.byte $44, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $20, $A6, $01 ; CPU:$D345 PRG:1345 44 43 43 43 43 43 43 43 43 43 43 43 45 20 A6 01
.byte $D1, $21, $06, $01, $2C, $21, $66, $01, $D1, $21, $C6, $01, $2C, $22, $26, $01 ; CPU:$D355 PRG:1355 D1 21 06 01 2C 21 66 01 D1 21 C6 01 2C 22 26 01
.byte $D1, $22, $86, $01, $2C, $22, $E6, $01, $D1, $23, $46, $01, $2C, $20, $87, $07 ; CPU:$D365 PRG:1365 D1 22 86 01 2C 22 E6 01 D1 23 46 01 2C 20 87 07
.byte $58, $53, $5A, $53, $5A, $53, $57, $20, $A7, $07, $50, $24, $54, $24, $54, $24 ; CPU:$D375 PRG:1375 58 53 5A 53 5A 53 57 20 A7 07 50 24 54 24 54 24
.byte $51, $20, $C7, $07, $50, $24, $54, $24, $54, $24, $51, $20, $E7, $07, $50, $24 ; CPU:$D385 PRG:1385 51 20 C7 07 50 24 54 24 54 24 51 20 E7 07 50 24
.byte $54, $24, $54, $24, $51, $21, $07, $07, $50, $24, $54, $24, $54, $24, $51, $21 ; CPU:$D395 PRG:1395 54 24 54 24 51 21 07 07 50 24 54 24 54 24 51 21
.byte $27, $07, $56, $52, $59, $52, $59, $52, $55, $21, $47, $07, $58, $53, $5A, $53 ; CPU:$D3A5 PRG:13A5 27 07 56 52 59 52 59 52 55 21 47 07 58 53 5A 53
.byte $5A, $53, $57, $21, $67, $07, $50, $24, $54, $24, $54, $24, $51, $21, $87, $07 ; CPU:$D3B5 PRG:13B5 5A 53 57 21 67 07 50 24 54 24 54 24 51 21 87 07
.byte $50, $24, $54, $24, $54, $24, $51, $21, $A7, $07, $50, $24, $54, $24, $54, $24 ; CPU:$D3C5 PRG:13C5 50 24 54 24 54 24 51 21 A7 07 50 24 54 24 54 24
.byte $51, $21, $C7, $07, $50, $24, $54, $24, $54, $24, $51, $21, $E7, $07, $56, $52 ; CPU:$D3D5 PRG:13D5 51 21 C7 07 50 24 54 24 54 24 51 21 E7 07 56 52
.byte $59, $52, $59, $52, $55, $22, $07, $07, $58, $53, $5A, $53, $5A, $53, $57, $22 ; CPU:$D3E5 PRG:13E5 59 52 59 52 55 22 07 07 58 53 5A 53 5A 53 57 22
.byte $27, $07, $50, $24, $54, $24, $54, $24, $51, $22, $47, $07, $50, $24, $54, $24 ; CPU:$D3F5 PRG:13F5 27 07 50 24 54 24 54 24 51 22 47 07 50 24 54 24
.byte $54, $24, $51, $22, $67, $07, $50, $24, $54, $24, $54, $24, $51, $22, $87, $07 ; CPU:$D405 PRG:1405 54 24 51 22 67 07 50 24 54 24 54 24 51 22 87 07
.byte $50, $24, $54, $24, $54, $24, $51, $22, $A7, $07, $56, $52, $59, $52, $59, $52 ; CPU:$D415 PRG:1415 50 24 54 24 54 24 51 22 A7 07 56 52 59 52 59 52
.byte $55, $22, $C7, $07, $58, $53, $5A, $53, $5A, $53, $57, $22, $E7, $07, $50, $24 ; CPU:$D425 PRG:1425 55 22 C7 07 58 53 5A 53 5A 53 57 22 E7 07 50 24
.byte $54, $24, $54, $24, $51, $23, $07, $07, $50, $24, $54, $24, $54, $24, $51, $23 ; CPU:$D435 PRG:1435 54 24 54 24 51 23 07 07 50 24 54 24 54 24 51 23
.byte $27, $07, $50, $24, $54, $24, $54, $24, $51, $23, $47, $07, $50, $24, $54, $24 ; CPU:$D445 PRG:1445 27 07 50 24 54 24 54 24 51 23 47 07 50 24 54 24
.byte $54, $24, $51, $23, $67, $07, $56, $52, $59, $52, $59, $52, $55, $23, $C0, $10 ; CPU:$D455 PRG:1455 54 24 51 23 67 07 56 52 59 52 59 52 55 23 C0 10
.byte $40, $50, $50, $50, $50, $50, $50, $00, $00, $00, $00, $00, $00, $03, $00, $00 ; CPU:$D465 PRG:1465 40 50 50 50 50 50 50 00 00 00 00 00 00 03 00 00
.byte $23, $D0, $10, $00, $00, $00, $00, $00, $30, $00, $00, $00, $00, $00, $00, $00 ; CPU:$D475 PRG:1475 23 D0 10 00 00 00 00 00 30 00 00 00 00 00 00 00
.byte $00, $00, $00, $23, $E0, $10, $00, $00, $00, $00, $00, $03, $00, $00, $00, $00 ; CPU:$D485 PRG:1485 00 00 00 23 E0 10 00 00 00 00 00 03 00 00 00 00
.byte $00, $00, $00, $30, $00, $00, $23, $F0, $10, $00, $00, $00, $00, $00, $00, $00 ; CPU:$D495 PRG:1495 00 00 00 30 00 00 23 F0 10 00 00 00 00 00 00 00
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00 ; CPU:$D4A5 PRG:14A5 00 00 00 00 00 00 00 00 00
OamTableStreamTerminator:
; FF terminator byte before OAM gap data
; ---- $D4AE-$D4AE (1 bytes) ----
.byte $FF ; CPU:$D4AE PRG:14AE FF
OamTableGap:
; Gap data before OAM table at $D4E3
; ---- $D4AF-$D4E1 (51 bytes) ----
.byte $A5, $24, $54, $24, $54, $24, $24, $54, $24, $54, $24, $24, $54, $24, $54, $24 ; CPU:$D4AF PRG:14AF A5 24 54 24 54 24 24 54 24 54 24 24 54 24 54 24
.byte $24, $54, $24, $54, $24, $52, $59, $52, $59, $52, $53, $5A, $53, $5A, $53, $24 ; CPU:$D4BF PRG:14BF 24 54 24 54 24 52 59 52 59 52 53 5A 53 5A 53 24
.byte $54, $24, $54, $24, $24, $54, $24, $54, $24, $24, $54, $24, $54, $24, $24, $54 ; CPU:$D4CF PRG:14CF 54 24 54 24 24 54 24 54 24 24 54 24 54 24 24 54
.byte $24, $54, $24 ; CPU:$D4DF PRG:14DF 24 54 24
OamTable1Terminator:
; FF terminator byte before OAM table group 1
; ---- $D4E2-$D4E2 (1 bytes) ----
.byte $FF ; CPU:$D4E2 PRG:14E2 FF
OamTableGroups1:
; OAM table groups 1-7 (CopyOamFromTable reads $D4E3) - 7x32 byte tables
; ---- $D4E3-$D5C2 (224 bytes) ----
.byte $37, $4D, $03, $D0, $37, $4D, $03, $C0, $37, $4E, $03, $B0, $37, $4E, $03, $A0 ; CPU:$D4E3 PRG:14E3 37 4D 03 D0 37 4D 03 C0 37 4E 03 B0 37 4E 03 A0
.byte $27, $48, $03, $88, $37, $4C, $03, $88, $2F, $49, $03, $80, $2F, $4B, $03, $90 ; CPU:$D4F3 PRG:14F3 27 48 03 88 37 4C 03 88 2F 49 03 80 2F 4B 03 90
.byte $67, $4D, $03, $D0, $67, $4D, $03, $C0, $67, $4E, $03, $B0, $67, $4E, $03, $A0 ; CPU:$D503 PRG:1503 67 4D 03 D0 67 4D 03 C0 67 4E 03 B0 67 4E 03 A0
.byte $57, $48, $03, $88, $67, $4C, $03, $88, $5F, $49, $03, $80, $5F, $4B, $03, $90 ; CPU:$D513 PRG:1513 57 48 03 88 67 4C 03 88 5F 49 03 80 5F 4B 03 90
.byte $97, $4D, $03, $D0, $97, $4D, $03, $C0, $97, $4E, $03, $B0, $97, $4E, $03, $A0 ; CPU:$D523 PRG:1523 97 4D 03 D0 97 4D 03 C0 97 4E 03 B0 97 4E 03 A0
.byte $87, $48, $03, $88, $97, $4C, $03, $88, $8F, $49, $03, $80, $8F, $4B, $03, $90 ; CPU:$D533 PRG:1533 87 48 03 88 97 4C 03 88 8F 49 03 80 8F 4B 03 90
.byte $C7, $4D, $03, $D0, $C7, $4D, $03, $C0, $C7, $4E, $03, $B0, $C7, $4E, $03, $A0 ; CPU:$D543 PRG:1543 C7 4D 03 D0 C7 4D 03 C0 C7 4E 03 B0 C7 4E 03 A0
.byte $B7, $48, $03, $88, $C7, $4C, $03, $88, $BF, $49, $03, $80, $BF, $4B, $03, $90 ; CPU:$D553 PRG:1553 B7 48 03 88 C7 4C 03 88 BF 49 03 80 BF 4B 03 90
.byte $27, $30, $00, $40, $2F, $30, $00, $40, $37, $30, $00, $40, $3F, $30, $00, $40 ; CPU:$D563 PRG:1563 27 30 00 40 2F 30 00 40 37 30 00 40 3F 30 00 40
.byte $27, $30, $00, $50, $2F, $30, $00, $50, $37, $30, $00, $50, $3F, $30, $00, $50 ; CPU:$D573 PRG:1573 27 30 00 50 2F 30 00 50 37 30 00 50 3F 30 00 50
.byte $27, $30, $00, $60, $2F, $30, $00, $60, $37, $30, $00, $60, $3F, $30, $00, $60 ; CPU:$D583 PRG:1583 27 30 00 60 2F 30 00 60 37 30 00 60 3F 30 00 60
.byte $57, $30, $00, $40, $5F, $30, $00, $40, $67, $30, $00, $40, $6F, $30, $00, $40 ; CPU:$D593 PRG:1593 57 30 00 40 5F 30 00 40 67 30 00 40 6F 30 00 40
.byte $57, $30, $00, $50, $5F, $30, $00, $50, $67, $30, $00, $50, $6F, $30, $00, $50 ; CPU:$D5A3 PRG:15A3 57 30 00 50 5F 30 00 50 67 30 00 50 6F 30 00 50
.byte $57, $30, $00, $60, $5F, $30, $00, $60, $67, $30, $00, $60, $6F, $30, $00, $60 ; CPU:$D5B3 PRG:15B3 57 30 00 60 5F 30 00 60 67 30 00 60 6F 30 00 60
OamTableStream2Terminator:
; FF terminator byte before second OAM table group
; ---- $D5C3-$D5C3 (1 bytes) ----
.byte $FF ; CPU:$D5C3 PRG:15C3 FF
OamTableGroups2:
; OAM table groups 1-2 (CopyOamFromTable70 reads $D5C4) - 2x32 byte tables
; ---- $D5C4-$D603 (64 bytes) ----
.byte $37, $4D, $03, $D0, $37, $4D, $03, $C0, $37, $4E, $03, $B0, $37, $4E, $03, $A0 ; CPU:$D5C4 PRG:15C4 37 4D 03 D0 37 4D 03 C0 37 4E 03 B0 37 4E 03 A0
.byte $27, $48, $03, $88, $37, $4C, $03, $88, $2F, $49, $03, $80, $2F, $4B, $03, $90 ; CPU:$D5D4 PRG:15D4 27 48 03 88 37 4C 03 88 2F 49 03 80 2F 4B 03 90
.byte $67, $4D, $03, $D0, $67, $4D, $03, $C0, $67, $4E, $03, $B0, $67, $4E, $03, $A0 ; CPU:$D5E4 PRG:15E4 67 4D 03 D0 67 4D 03 C0 67 4E 03 B0 67 4E 03 A0
.byte $57, $48, $03, $88, $67, $4C, $03, $88, $5F, $49, $03, $80, $5F, $4B, $03, $90 ; CPU:$D5F4 PRG:15F4 57 48 03 88 67 4C 03 88 5F 49 03 80 5F 4B 03 90
OamSpritePadding:
; 64 bytes of $F4 sprite off-screen padding
; ---- $D604-$D643 (64 bytes) ----
.byte $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4 ; CPU:$D604 PRG:1604 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4
.byte $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4 ; CPU:$D614 PRG:1614 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4
.byte $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4 ; CPU:$D624 PRG:1624 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4
.byte $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4 ; CPU:$D634 PRG:1634 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4
OamTableGroups3:
; OAM table groups 3-5 - 3x32 byte tables before sprite template
; ---- $D644-$D6A3 (96 bytes) ----
.byte $27, $30, $00, $40, $2F, $30, $00, $40, $37, $30, $00, $40, $3F, $30, $00, $40 ; CPU:$D644 PRG:1644 27 30 00 40 2F 30 00 40 37 30 00 40 3F 30 00 40
.byte $27, $30, $00, $50, $2F, $30, $00, $50, $37, $30, $00, $50, $3F, $30, $00, $50 ; CPU:$D654 PRG:1654 27 30 00 50 2F 30 00 50 37 30 00 50 3F 30 00 50
.byte $27, $30, $00, $60, $2F, $30, $00, $60, $37, $30, $00, $60, $3F, $30, $00, $60 ; CPU:$D664 PRG:1664 27 30 00 60 2F 30 00 60 37 30 00 60 3F 30 00 60
.byte $57, $30, $00, $40, $5F, $30, $00, $40, $67, $30, $00, $40, $6F, $30, $00, $40 ; CPU:$D674 PRG:1674 57 30 00 40 5F 30 00 40 67 30 00 40 6F 30 00 40
.byte $57, $30, $00, $50, $5F, $30, $00, $50, $67, $30, $00, $50, $6F, $30, $00, $50 ; CPU:$D684 PRG:1684 57 30 00 50 5F 30 00 50 67 30 00 50 6F 30 00 50
.byte $57, $30, $00, $60, $5F, $30, $00, $60, $67, $30, $00, $60, $6F, $30, $00, $60 ; CPU:$D694 PRG:1694 57 30 00 60 5F 30 00 60 67 30 00 60 6F 30 00 60
SpriteTableTerminator:
; FF terminator byte before sprite template table
; ---- $D6A4-$D6A4 (1 bytes) ----
.byte $FF ; CPU:$D6A4 PRG:16A4 FF
SpriteTemplateTable:
; 32-byte sprite template (CopySpriteTemplateTable reads $D6A5) - 8x4 Y/tile/attr/X
; ---- $D6A5-$D6C4 (32 bytes) ----
.byte $79, $1D, $00, $18, $79, $0E, $00, $20, $79, $1C, $00, $28, $79, $1D, $00, $30 ; CPU:$D6A5 PRG:16A5 79 1D 00 18 79 0E 00 20 79 1C 00 28 79 1D 00 30
.byte $79, $18, $00, $40, $79, $1F, $00, $48, $79, $0E, $00, $50, $79, $1B, $00, $58 ; CPU:$D6B5 PRG:16B5 79 18 00 40 79 1F 00 48 79 0E 00 50 79 1B 00 58
ButtonOamTemplateTable:
; 32-byte button OAM template (PrepareButtonOam reads $D6C5) - 8x4 Y/tile/attr/X
; ---- $D6C5-$D6E4 (32 bytes) ----
.byte $79, $0C, $00, $18, $79, $18, $00, $20, $79, $17, $00, $28, $79, $1D, $00, $30 ; CPU:$D6C5 PRG:16C5 79 0C 00 18 79 18 00 20 79 17 00 28 79 1D 00 30
.byte $79, $0B, $00, $40, $79, $0A, $00, $48, $79, $0D, $00, $50, $79, $24, $00, $58 ; CPU:$D6D5 PRG:16D5 79 0B 00 40 79 0A 00 48 79 0D 00 50 79 24 00 58
RomPadding:
; 10517 bytes of $FF ROM padding
; ---- $D6E5-$FFF9 (10517 bytes) ----
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D6E5 PRG:16E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D6F5 PRG:16F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D705 PRG:1705 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D715 PRG:1715 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D725 PRG:1725 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D735 PRG:1735 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D745 PRG:1745 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D755 PRG:1755 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D765 PRG:1765 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D775 PRG:1775 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D785 PRG:1785 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D795 PRG:1795 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7A5 PRG:17A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7B5 PRG:17B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7C5 PRG:17C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7D5 PRG:17D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7E5 PRG:17E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7F5 PRG:17F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D805 PRG:1805 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D815 PRG:1815 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D825 PRG:1825 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D835 PRG:1835 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D845 PRG:1845 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D855 PRG:1855 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D865 PRG:1865 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D875 PRG:1875 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D885 PRG:1885 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D895 PRG:1895 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8A5 PRG:18A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8B5 PRG:18B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8C5 PRG:18C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8D5 PRG:18D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8E5 PRG:18E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8F5 PRG:18F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D905 PRG:1905 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D915 PRG:1915 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D925 PRG:1925 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D935 PRG:1935 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D945 PRG:1945 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D955 PRG:1955 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D965 PRG:1965 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D975 PRG:1975 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D985 PRG:1985 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D995 PRG:1995 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9A5 PRG:19A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9B5 PRG:19B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9C5 PRG:19C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9D5 PRG:19D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9E5 PRG:19E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9F5 PRG:19F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA05 PRG:1A05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA15 PRG:1A15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA25 PRG:1A25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA35 PRG:1A35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA45 PRG:1A45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA55 PRG:1A55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA65 PRG:1A65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA75 PRG:1A75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA85 PRG:1A85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA95 PRG:1A95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAA5 PRG:1AA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAB5 PRG:1AB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAC5 PRG:1AC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAD5 PRG:1AD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAE5 PRG:1AE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAF5 PRG:1AF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB05 PRG:1B05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB15 PRG:1B15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB25 PRG:1B25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB35 PRG:1B35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB45 PRG:1B45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB55 PRG:1B55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB65 PRG:1B65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB75 PRG:1B75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB85 PRG:1B85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB95 PRG:1B95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBA5 PRG:1BA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBB5 PRG:1BB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBC5 PRG:1BC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBD5 PRG:1BD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBE5 PRG:1BE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBF5 PRG:1BF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC05 PRG:1C05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC15 PRG:1C15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC25 PRG:1C25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC35 PRG:1C35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC45 PRG:1C45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC55 PRG:1C55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC65 PRG:1C65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC75 PRG:1C75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC85 PRG:1C85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC95 PRG:1C95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCA5 PRG:1CA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCB5 PRG:1CB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCC5 PRG:1CC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCD5 PRG:1CD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCE5 PRG:1CE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCF5 PRG:1CF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD05 PRG:1D05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD15 PRG:1D15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD25 PRG:1D25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD35 PRG:1D35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD45 PRG:1D45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD55 PRG:1D55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD65 PRG:1D65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD75 PRG:1D75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD85 PRG:1D85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD95 PRG:1D95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDA5 PRG:1DA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDB5 PRG:1DB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDC5 PRG:1DC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDD5 PRG:1DD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDE5 PRG:1DE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDF5 PRG:1DF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE05 PRG:1E05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE15 PRG:1E15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE25 PRG:1E25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE35 PRG:1E35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE45 PRG:1E45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE55 PRG:1E55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE65 PRG:1E65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE75 PRG:1E75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE85 PRG:1E85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE95 PRG:1E95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DEA5 PRG:1EA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DEB5 PRG:1EB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DEC5 PRG:1EC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DED5 PRG:1ED5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DEE5 PRG:1EE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DEF5 PRG:1EF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF05 PRG:1F05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF15 PRG:1F15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF25 PRG:1F25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF35 PRG:1F35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF45 PRG:1F45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF55 PRG:1F55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF65 PRG:1F65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF75 PRG:1F75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF85 PRG:1F85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF95 PRG:1F95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFA5 PRG:1FA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFB5 PRG:1FB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFC5 PRG:1FC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFD5 PRG:1FD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFE5 PRG:1FE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFF5 PRG:1FF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E005 PRG:2005 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E015 PRG:2015 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E025 PRG:2025 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E035 PRG:2035 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E045 PRG:2045 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E055 PRG:2055 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E065 PRG:2065 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E075 PRG:2075 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E085 PRG:2085 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E095 PRG:2095 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0A5 PRG:20A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0B5 PRG:20B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0C5 PRG:20C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0D5 PRG:20D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0E5 PRG:20E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0F5 PRG:20F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E105 PRG:2105 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E115 PRG:2115 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E125 PRG:2125 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E135 PRG:2135 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E145 PRG:2145 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E155 PRG:2155 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E165 PRG:2165 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E175 PRG:2175 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E185 PRG:2185 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E195 PRG:2195 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1A5 PRG:21A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1B5 PRG:21B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1C5 PRG:21C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1D5 PRG:21D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1E5 PRG:21E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1F5 PRG:21F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E205 PRG:2205 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E215 PRG:2215 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E225 PRG:2225 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E235 PRG:2235 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E245 PRG:2245 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E255 PRG:2255 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E265 PRG:2265 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E275 PRG:2275 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E285 PRG:2285 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E295 PRG:2295 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2A5 PRG:22A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2B5 PRG:22B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2C5 PRG:22C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2D5 PRG:22D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2E5 PRG:22E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2F5 PRG:22F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E305 PRG:2305 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E315 PRG:2315 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E325 PRG:2325 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E335 PRG:2335 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E345 PRG:2345 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E355 PRG:2355 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E365 PRG:2365 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E375 PRG:2375 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E385 PRG:2385 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E395 PRG:2395 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3A5 PRG:23A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3B5 PRG:23B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3C5 PRG:23C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3D5 PRG:23D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3E5 PRG:23E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3F5 PRG:23F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E405 PRG:2405 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E415 PRG:2415 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E425 PRG:2425 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E435 PRG:2435 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E445 PRG:2445 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E455 PRG:2455 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E465 PRG:2465 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E475 PRG:2475 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E485 PRG:2485 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E495 PRG:2495 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4A5 PRG:24A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4B5 PRG:24B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4C5 PRG:24C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4D5 PRG:24D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4E5 PRG:24E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4F5 PRG:24F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E505 PRG:2505 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E515 PRG:2515 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E525 PRG:2525 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E535 PRG:2535 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E545 PRG:2545 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E555 PRG:2555 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E565 PRG:2565 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E575 PRG:2575 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E585 PRG:2585 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E595 PRG:2595 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5A5 PRG:25A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5B5 PRG:25B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5C5 PRG:25C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5D5 PRG:25D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5E5 PRG:25E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5F5 PRG:25F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E605 PRG:2605 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E615 PRG:2615 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E625 PRG:2625 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E635 PRG:2635 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E645 PRG:2645 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E655 PRG:2655 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E665 PRG:2665 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E675 PRG:2675 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E685 PRG:2685 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E695 PRG:2695 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6A5 PRG:26A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6B5 PRG:26B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6C5 PRG:26C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6D5 PRG:26D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6E5 PRG:26E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6F5 PRG:26F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E705 PRG:2705 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E715 PRG:2715 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E725 PRG:2725 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E735 PRG:2735 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E745 PRG:2745 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E755 PRG:2755 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E765 PRG:2765 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E775 PRG:2775 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E785 PRG:2785 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E795 PRG:2795 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7A5 PRG:27A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7B5 PRG:27B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7C5 PRG:27C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7D5 PRG:27D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7E5 PRG:27E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7F5 PRG:27F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E805 PRG:2805 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E815 PRG:2815 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E825 PRG:2825 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E835 PRG:2835 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E845 PRG:2845 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E855 PRG:2855 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E865 PRG:2865 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E875 PRG:2875 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E885 PRG:2885 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E895 PRG:2895 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8A5 PRG:28A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8B5 PRG:28B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8C5 PRG:28C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8D5 PRG:28D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8E5 PRG:28E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8F5 PRG:28F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E905 PRG:2905 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E915 PRG:2915 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E925 PRG:2925 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E935 PRG:2935 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E945 PRG:2945 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E955 PRG:2955 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E965 PRG:2965 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E975 PRG:2975 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E985 PRG:2985 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E995 PRG:2995 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9A5 PRG:29A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9B5 PRG:29B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9C5 PRG:29C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9D5 PRG:29D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9E5 PRG:29E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9F5 PRG:29F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA05 PRG:2A05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA15 PRG:2A15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA25 PRG:2A25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA35 PRG:2A35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA45 PRG:2A45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA55 PRG:2A55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA65 PRG:2A65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA75 PRG:2A75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA85 PRG:2A85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA95 PRG:2A95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAA5 PRG:2AA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAB5 PRG:2AB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAC5 PRG:2AC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAD5 PRG:2AD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAE5 PRG:2AE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAF5 PRG:2AF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB05 PRG:2B05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB15 PRG:2B15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB25 PRG:2B25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB35 PRG:2B35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB45 PRG:2B45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB55 PRG:2B55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB65 PRG:2B65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB75 PRG:2B75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB85 PRG:2B85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB95 PRG:2B95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBA5 PRG:2BA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBB5 PRG:2BB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBC5 PRG:2BC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBD5 PRG:2BD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBE5 PRG:2BE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBF5 PRG:2BF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC05 PRG:2C05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC15 PRG:2C15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC25 PRG:2C25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC35 PRG:2C35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC45 PRG:2C45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC55 PRG:2C55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC65 PRG:2C65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC75 PRG:2C75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC85 PRG:2C85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC95 PRG:2C95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECA5 PRG:2CA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECB5 PRG:2CB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECC5 PRG:2CC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECD5 PRG:2CD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECE5 PRG:2CE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECF5 PRG:2CF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED05 PRG:2D05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED15 PRG:2D15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED25 PRG:2D25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED35 PRG:2D35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED45 PRG:2D45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED55 PRG:2D55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED65 PRG:2D65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED75 PRG:2D75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED85 PRG:2D85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED95 PRG:2D95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDA5 PRG:2DA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDB5 PRG:2DB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDC5 PRG:2DC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDD5 PRG:2DD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDE5 PRG:2DE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDF5 PRG:2DF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE05 PRG:2E05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE15 PRG:2E15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE25 PRG:2E25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE35 PRG:2E35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE45 PRG:2E45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE55 PRG:2E55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE65 PRG:2E65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE75 PRG:2E75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE85 PRG:2E85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE95 PRG:2E95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EEA5 PRG:2EA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EEB5 PRG:2EB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EEC5 PRG:2EC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EED5 PRG:2ED5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EEE5 PRG:2EE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EEF5 PRG:2EF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF05 PRG:2F05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF15 PRG:2F15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF25 PRG:2F25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF35 PRG:2F35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF45 PRG:2F45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF55 PRG:2F55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF65 PRG:2F65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF75 PRG:2F75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF85 PRG:2F85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF95 PRG:2F95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFA5 PRG:2FA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFB5 PRG:2FB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFC5 PRG:2FC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFD5 PRG:2FD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFE5 PRG:2FE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFF5 PRG:2FF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F005 PRG:3005 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F015 PRG:3015 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F025 PRG:3025 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F035 PRG:3035 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F045 PRG:3045 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F055 PRG:3055 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F065 PRG:3065 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F075 PRG:3075 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F085 PRG:3085 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F095 PRG:3095 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0A5 PRG:30A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0B5 PRG:30B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0C5 PRG:30C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0D5 PRG:30D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0E5 PRG:30E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0F5 PRG:30F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F105 PRG:3105 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F115 PRG:3115 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F125 PRG:3125 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F135 PRG:3135 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F145 PRG:3145 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F155 PRG:3155 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F165 PRG:3165 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F175 PRG:3175 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F185 PRG:3185 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F195 PRG:3195 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1A5 PRG:31A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1B5 PRG:31B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1C5 PRG:31C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1D5 PRG:31D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1E5 PRG:31E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1F5 PRG:31F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F205 PRG:3205 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F215 PRG:3215 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F225 PRG:3225 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F235 PRG:3235 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F245 PRG:3245 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F255 PRG:3255 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F265 PRG:3265 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F275 PRG:3275 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F285 PRG:3285 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F295 PRG:3295 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2A5 PRG:32A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2B5 PRG:32B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2C5 PRG:32C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2D5 PRG:32D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2E5 PRG:32E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2F5 PRG:32F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F305 PRG:3305 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F315 PRG:3315 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F325 PRG:3325 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F335 PRG:3335 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F345 PRG:3345 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F355 PRG:3355 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F365 PRG:3365 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F375 PRG:3375 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F385 PRG:3385 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F395 PRG:3395 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3A5 PRG:33A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3B5 PRG:33B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3C5 PRG:33C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3D5 PRG:33D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3E5 PRG:33E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3F5 PRG:33F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F405 PRG:3405 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F415 PRG:3415 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F425 PRG:3425 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F435 PRG:3435 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F445 PRG:3445 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F455 PRG:3455 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F465 PRG:3465 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F475 PRG:3475 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F485 PRG:3485 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F495 PRG:3495 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4A5 PRG:34A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4B5 PRG:34B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4C5 PRG:34C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4D5 PRG:34D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4E5 PRG:34E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4F5 PRG:34F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F505 PRG:3505 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F515 PRG:3515 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F525 PRG:3525 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F535 PRG:3535 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F545 PRG:3545 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F555 PRG:3555 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F565 PRG:3565 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F575 PRG:3575 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F585 PRG:3585 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F595 PRG:3595 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5A5 PRG:35A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5B5 PRG:35B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5C5 PRG:35C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5D5 PRG:35D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5E5 PRG:35E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5F5 PRG:35F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F605 PRG:3605 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F615 PRG:3615 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F625 PRG:3625 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F635 PRG:3635 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F645 PRG:3645 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F655 PRG:3655 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F665 PRG:3665 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F675 PRG:3675 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F685 PRG:3685 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F695 PRG:3695 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6A5 PRG:36A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6B5 PRG:36B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6C5 PRG:36C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6D5 PRG:36D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6E5 PRG:36E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6F5 PRG:36F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F705 PRG:3705 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F715 PRG:3715 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F725 PRG:3725 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F735 PRG:3735 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F745 PRG:3745 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F755 PRG:3755 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F765 PRG:3765 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F775 PRG:3775 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F785 PRG:3785 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F795 PRG:3795 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7A5 PRG:37A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7B5 PRG:37B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7C5 PRG:37C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7D5 PRG:37D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7E5 PRG:37E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7F5 PRG:37F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F805 PRG:3805 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F815 PRG:3815 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F825 PRG:3825 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F835 PRG:3835 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F845 PRG:3845 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F855 PRG:3855 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F865 PRG:3865 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F875 PRG:3875 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F885 PRG:3885 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F895 PRG:3895 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8A5 PRG:38A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8B5 PRG:38B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8C5 PRG:38C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8D5 PRG:38D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8E5 PRG:38E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8F5 PRG:38F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F905 PRG:3905 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F915 PRG:3915 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F925 PRG:3925 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F935 PRG:3935 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F945 PRG:3945 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F955 PRG:3955 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F965 PRG:3965 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F975 PRG:3975 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F985 PRG:3985 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F995 PRG:3995 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9A5 PRG:39A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9B5 PRG:39B5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9C5 PRG:39C5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9D5 PRG:39D5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9E5 PRG:39E5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9F5 PRG:39F5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA05 PRG:3A05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA15 PRG:3A15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA25 PRG:3A25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA35 PRG:3A35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA45 PRG:3A45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA55 PRG:3A55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA65 PRG:3A65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA75 PRG:3A75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA85 PRG:3A85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA95 PRG:3A95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAA5 PRG:3AA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAB5 PRG:3AB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAC5 PRG:3AC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAD5 PRG:3AD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAE5 PRG:3AE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAF5 PRG:3AF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB05 PRG:3B05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB15 PRG:3B15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB25 PRG:3B25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB35 PRG:3B35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB45 PRG:3B45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB55 PRG:3B55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB65 PRG:3B65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB75 PRG:3B75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB85 PRG:3B85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB95 PRG:3B95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBA5 PRG:3BA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBB5 PRG:3BB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBC5 PRG:3BC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBD5 PRG:3BD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBE5 PRG:3BE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBF5 PRG:3BF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC05 PRG:3C05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC15 PRG:3C15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC25 PRG:3C25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC35 PRG:3C35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC45 PRG:3C45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC55 PRG:3C55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC65 PRG:3C65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC75 PRG:3C75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC85 PRG:3C85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC95 PRG:3C95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCA5 PRG:3CA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCB5 PRG:3CB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCC5 PRG:3CC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCD5 PRG:3CD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCE5 PRG:3CE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCF5 PRG:3CF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD05 PRG:3D05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD15 PRG:3D15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD25 PRG:3D25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD35 PRG:3D35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD45 PRG:3D45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD55 PRG:3D55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD65 PRG:3D65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD75 PRG:3D75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD85 PRG:3D85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD95 PRG:3D95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDA5 PRG:3DA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDB5 PRG:3DB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDC5 PRG:3DC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDD5 PRG:3DD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDE5 PRG:3DE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDF5 PRG:3DF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE05 PRG:3E05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE15 PRG:3E15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE25 PRG:3E25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE35 PRG:3E35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE45 PRG:3E45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE55 PRG:3E55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE65 PRG:3E65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE75 PRG:3E75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE85 PRG:3E85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE95 PRG:3E95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FEA5 PRG:3EA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FEB5 PRG:3EB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FEC5 PRG:3EC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FED5 PRG:3ED5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FEE5 PRG:3EE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FEF5 PRG:3EF5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF05 PRG:3F05 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF15 PRG:3F15 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF25 PRG:3F25 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF35 PRG:3F35 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF45 PRG:3F45 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF55 PRG:3F55 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF65 PRG:3F65 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF75 PRG:3F75 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF85 PRG:3F85 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF95 PRG:3F95 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FFA5 PRG:3FA5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FFB5 PRG:3FB5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FFC5 PRG:3FC5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FFD5 PRG:3FD5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FFE5 PRG:3FE5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF ; CPU:$FFF5 PRG:3FF5 FF FF FF FF FF
ResetVectors:
; Reset/NMI/IRQ vectors - 6 bytes
; ---- $FFFA-$FFFF (6 bytes) ----
.byte $F7, $CC, $00, $C0, $00, $C0 ; CPU:$FFFA PRG:3FFA F7 CC 00 C0 00 C0
Reference in new issue View Git Blame Copy Permalink