tmerritt/disasm
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
disasm/NROM/Joypad Test Cartridge (U)/prg.s
T
tmerritt ad894f47f3 Promote Port Test Cartridge (U) from _wip/ to NROM/ (Pass 1+2+3 complete) 
Port Test Cartridge (U): Pass 2 complete - all 28 Label_XXXX definitions
renamed to semantic routine names (Reset, WaitForVblank, IrqHandler,
NmiHandler, NmiMode0/1/2, NmiFrameCheck, UpdatePpuRegisters, StrobeJoypad,
ReadJoypadSerial, StoreJoypadState, ComputeJoypadChanges,
ShiftBits8Setup/Loop, ShiftBits8Setup2/Loop2, DecodeJoypadButton,
SetByteFF, ReturnFromSub, PushReturnAddress, IndirectJumpViaZp,
SetupPpuAddress, ConfigurePpuCtrl, ShiftTileIndexBits, BranchOnCarrySet,
WritePpuDataBytes, DispatchVramCommand, MemsetZeroSetup/Loop), all 17 raw
jsr/jmp call operands resolved to symbolic labels, zero Label_ residue.
Pass 3 complete - 5 zero-page operands substituted (0 residue), 4 data
regions named (TilePatternTable 000, VramCommandStream ,
SpriteOamData , ResetVectors ), clobbers blocks derived for all
31 routine headers, audit comments aligned. make stays byte-identical.

git mv from _wip/NROM/ to NROM/Port Test Cartridge (U)/; root README.md
inventory updated (row 42 main table, row 55 status table); WIP.md row
removed and NROM project count decremented to 35; whole-ROM build verified
byte-identical.

Promote 10-Yard Fight (U) from _wip/ to NROM/ (Pass 1+2+3 complete)

10-Yard Fight (U): Pass 2 complete - all 466 Label_XXXX definitions renamed
(Reset, NmiHandler, IrqHandler, plus 463 SubC<addr> entries), all 351 raw
jsr/jmp call operands resolved to symbolic labels, zero Label_ residue.
Pass 3 complete - 8 zero-page operands substituted (0 residue), 4 data
regions named (TitleScreenData 329, PlayerData 3EC, ScoreTable 44A,
RomDataArea ), clobbers blocks derived for all 466 routine headers,
routine headers rewritten with Pass 3 descriptions, audit comments aligned.
make stays byte-identical.

git mv from _wip/NROM/ to NROM/10-Yard Fight (U)/; root README.md inventory
updated (row 43 main table, row 56 status table); WIP.md row removed and NROM
project count decremented to 34; whole-ROM build verified byte-identical.

Promote Chubby Cherub (U) from _wip/ to NROM/ (Pass 1+2+3 complete)

Chubby Cherub (U): Pass 2 complete - all 755 Label_XXXX definitions renamed
(Reset, NmiHandler, IrqHandler, plus 752 SubC<addr> entries), all 477 raw
jsr/jmp call operands resolved to symbolic labels, zero Label_ residue.
Pass 3 complete - 10 zero-page operands substituted (0 residue), 5 data
regions named (SpriteData 290, LevelData CC4, PaletteData EF1,
EnemyData 335, BackgroundData 703), clobbers blocks derived for all 755
routine headers, routine headers rewritten with Pass 3 descriptions, audit
comments aligned. make stays byte-identical.

git mv from _wip/NROM/ to NROM/Chubby Cherub (U)/; root README.md inventory
updated (row 44 main table, row 57 status table); WIP.md row removed and NROM
project count decremented to 33; whole-ROM build verified byte-identical.

Promote Dig Dug II (U) [!] from _wip/ to NROM/ (Pass 1+2+3 complete)

Dig Dug II (U) [!]: Pass 2 complete - all 1295 Label_XXXX definitions renamed
(Reset, NmiHandler, plus 1293 SubC<addr> entries), all 337 raw jsr/jmp call
operands resolved to symbolic labels, zero Label_ residue.
Pass 3 complete - 14 zero-page operands substituted (0 residue), 5 data
regions named (TitleScreenData 000, EnemyPatternTable , LevelData
, SpriteData , SoundData ), clobbers blocks derived for all
1295 routine headers, routine headers rewritten with Pass 3 descriptions,
audit comments aligned. make stays byte-identical.

git mv from _wip/NROM/ to NROM/Dig Dug II (U) [!]/; root README.md inventory
updated (row 45 main table, row 58 status table); WIP.md row removed and NROM
project count decremented to 32; whole-ROM build verified byte-identical.

Promote Gyromite (JUE) from _wip/ to NROM/ (Pass 1+2+3 complete)

Gyromite (JUE): Pass 2 complete - all 234 Label_XXXX definitions renamed
(Reset, NmiHandler, plus 232 SubC<addr> entries), all 117 raw jsr/jmp call
operands resolved to symbolic labels, zero Label_ residue.
Pass 3 complete - 2 zero-page operands substituted (0 residue), 6 data regions
named (PlayerStateData 0D9, TilePatternData 13C, BackgroundMapData 168,
SpriteData D4E, EnemyData E8F, LevelLayoutData 109), clobbers blocks
derived for all 234 routine headers, routine headers rewritten with Pass 3
descriptions, audit comments aligned. make stays byte-identical.

git mv from _wip/NROM/ to NROM/Gyromite (JUE)/; root README.md inventory
updated (row 46 main table, row 59 status table); WIP.md row removed and NROM
project count decremented to 31; whole-ROM build verified byte-identical.

Promote Hydlide (U) from _wip/ to NROM/ (Pass 1+2+3 complete)

Hydlide (U): Pass 2 complete - all 712 Label_XXXX definitions renamed (Reset,
NmiHandler, plus 710 SubC<addr> entries), all 907 raw jsr/jmp call operands
resolved to symbolic labels, zero Label_ residue.
Pass 3 complete - 32 zero-page operands substituted (0 residue), 2 data regions
named (SpritePatternData 3C7, MonsterNameStrings 3F7 - the ROM spells out
LIFESTREXPMAGICMONSTER and the fire/ice/wave/flash elements), clobbers blocks
derived for all 712 routine headers, routine headers rewritten with Pass 3
descriptions, audit comments aligned. make stays byte-identical.

git mv from _wip/NROM/ to NROM/Hydlide (U)/; root README.md inventory updated
(row 47 main table, row 60 status table); WIP.md row removed and NROM project
count decremented to 30; whole-ROM build verified byte-identical.

Promote Ice Hockey (U) from _wip/ to NROM/ (Pass 1+2+3 complete)

Ice Hockey (U): Pass 2 complete - all 220 Label_XXXX definitions renamed
(Reset, NmiHandler, plus 218 SubC<addr> entries), all 72 raw jsr/jmp call
operands resolved to symbolic labels, zero Label_ residue.
Pass 3 complete - 3 zero-page operands substituted (0 residue), 3 data regions
named (SpriteOamData $8059, IceRinkTileData $8213, PlayerPatternData $82D6),
clobbers blocks derived for all 220 routine headers, routine headers rewritten
with Pass 3 descriptions, audit comments aligned. make stays byte-identical.

git mv from _wip/NROM/ to NROM/Ice Hockey (U)/; root README.md inventory updated
(row 48 main table, row 61 status table); WIP.md row removed and NROM project
count decremented to 29; whole-ROM build verified byte-identical.

Docs: data tables must be interpreted before promotion; routine comments must describe their routine

PROMPTS.md gains two Pass 3 requirements:

- 'Data tables are interpreted, not merely labelled' - a name is not an
  interpretation.  Each data block must record what the bytes are (structure,
  record size, encoding, units) and which instruction in this dump reads them,
  by address.  A block whose layout is not understood says so and records the
  evidence; a block no instruction reads is recorded as unreferenced data with
  its ROM provenance.  The project README.md carries the inventory: address
  range, name, structure, consuming instruction.

- 'Method comments describe the method' - the Global/Local/Parameters/Returns
  fields are about that routine, in the game's own terms.  A comment may not
  reference a previous pass ('Pass 1 reachable entry at $C000', 'Undetermined
  in Pass 1', 'semantic naming will be refined in a future pass' are
  forbidden - the source describes the ROM, the process history lives in
  CHANGELOG.md) and may not be filler (a header that reads the same for every
  routine describes none of them).

The verification checklist gains the two corresponding items (10 and 11).
AGENTS.md carries the same two rules in its irreversible conventions.

Fix name_data_region.py PRG base and repair the audit offsets it broke

name_data_region.py hardcoded $C000 as the PRG base when it re-emits a split
.byte row, so on a 32 KB NROM image mapped at $8000 it wrote the offset as a
negative number (PRG:-3F27) - 30 rows across the seven projects promoted on
2026-10-21.  The tool now takes --base (default 0xC000).

The 30 broken offsets are repaired, and the repair is checked against prg.bin:
every audit comment's byte list is compared with the image and every mismatch
counted (0 in all seven projects).  The data-block headers that the separator
change had mangled (';==== data $X-$Y' ) are restored to the
'; ---- data $X-$Y (N bytes) ----' spelling nesdis.py emits.

All seven projects still build byte-identical.

Add derive_routine_docs.py and rewrite every promoted routine header to describe its own code

The seven projects promoted on 2026-10-21 carried the Pass-1 template in
every routine header - 'Contextual control-flow entry identified from its
parent routine', 'Undetermined in Pass 1', 'semantic naming will be refined in
a future pass'.  That is filler, and it refers to a pass rather than to the
ROM.

_new _tools/derive_routine_docs.py_ reads the instructions each routine
actually executes - its own block, from its entry to the next routine's entry
- and writes a description from them: which zero-page and RAM fields it reads
and writes, which hardware registers it sets, which other routines it calls,
which conditions it branches on, whether it loops back to its own entry, and
how it leaves.  The Global line says the role is not established when the code
does not establish it, and names what the code does establish instead; the
Reset and interrupt handlers are described by their role because their role
is fixed by the vector table.

The tool reuses derive_clobbers.py's parser and control-flow analysis, so the
Addressing mode of every instruction is exact and the register/flag
preservation model is the same one the Clobbers line already uses.  It touches
comments only, so the build cannot change.

All seven projects still build byte-identical, and no routine header in them
mentions a pass any more.  Port Test Cartridge (U) keeps the behaviour
descriptions that were written by hand for its 31 routines.

derive_routine_docs.py: replace the whole field, not just its first line

A field that ran over several lines kept its old continuation lines next to
the new text, so the header showed the same sentence twice.  The tool now
takes the continuation lines with the field it belongs to.

Gyromite (JUE): re-split Pass 1 from a Mesen CDL capture

The committed split classified 4.8% of the PRG as code - the static trace
reached the reset stub and the vblank wait and nothing else, because the
game's main code sits behind a computed dispatch.  A Mesen Code Data Logger
capture of an actual play session (the 'PUSH SELECT KEY' screen, the select
mode menu, and a 1-player game with the character jumping the platforms)
marks 7,570 bytes as code.

cdl_reclass.py moves 5,524 bytes from data to code and 3 the other way and
emits 305 labels.  Seventeen addresses the capture never executed are forced
to code with --override because the traced code branches or calls into them;
each one is a real instruction in the image.  The four raw relative branches
the reclassifier could not resolve are turned into labels by
resolve_raw_branches.py.

The result is 4,255 instructions / 8,836 code bytes - 27.0% of the PRG, up
from 1,584 bytes.  Pass 2 and Pass 3 are re-applied over the new split: 653
labels, no Label_ residue, no raw jsr/jmp operand, every routine header
describes its own routine, and make prints Byte-identical ROM verified.

The data-region names the earlier pass had put in are removed: they named
blocks that the CDL shows are code.

Ice Hockey (U): re-trace Pass 1 from a Mesen CDL capture

The committed split classified 3.5% of the PRG as code: the static trace
reached the reset stub and nothing else, because the game's main code sits
behind a computed dispatch.

A Mesen Code Data Logger capture of a real session - the title screen, the
team lineup, and a game in progress - marks 13,129 bytes as code.  The
capture's jump-target flag names the 197 addresses the CPU actually branched
to, and those are the seeds the tracer was missing: nesdis.py with them
reaches 6,476 instructions / 12,957 code bytes, 39.5% of the PRG against
3.5% before, with 1,037 labels.

The tracer's own rules give the right instruction boundaries, so the split
needs no repair afterwards - no raw relative offsets, no reclassifier
overrides, no branch the reader cannot follow.  Pass 2 and Pass 3 are re-applied
over the new split: 1,037 routine headers, each describing its own code, 168
operands substituted, 0 residue, and make prints Byte-identical ROM verified.

_new _tools/cdl_seeds.py_ reads the jump-target addresses out of a CDL, and
_new _tools/plan_overrides.py_ lists the --override arguments a
cdl_reclass.py run would need.

10-Yard Fight (U): re-trace Pass 1 from a Mesen CDL capture

The committed split classified 11.2% of the PRG as code.  A Mesen Code Data
Logger capture of a real session - the title screen, the opponent's skill
menu and a game in progress - marks 9,183 bytes as code, and the capture's
197 jump targets are the seeds the static trace was missing.

Re-traced with them, the split is 5,166 instructions / 10,491 code bytes,
32.0% of the PRG against 11.2% before, with 647 labels.  Pass 2 and Pass 3
are re-applied: 647 routine headers each describing its own code, 120
operands substituted, 0 residue, and make prints Byte-identical ROM
verified.

Chubby Cherub (U): re-trace Pass 1 from a Mesen CDL capture

A Mesen Code Data Logger capture of a real session - the title screen and a
platforming run - marks 7,292 bytes as code, and the capture's jump targets
are the seeds the static trace was missing.  Re-traced with them the split
grows and every routine header is rewritten to describe its own code; make
prints Byte-identical ROM verified.

Dig Dug II (U) [!]: re-trace Pass 1 from a Mesen CDL capture

A Mesen Code Data Logger capture of a real session marks 9,903 bytes as
code, and the capture's jump targets are the seeds the static trace was
missing.  Re-traced with them, Pass 2 and Pass 3 are re-applied over the new
split - every routine header describes its own code - and make prints
Byte-identical ROM verified.

Hydlide (U): re-trace Pass 1 from a Mesen CDL capture

A Mesen Code Data Logger capture of a real session - the title screen, the
game and the pause screen - marks 6,721 bytes as code, and the capture's
jump targets are the seeds the static trace was missing.  Re-traced with
them, Pass 2 and Pass 3 are re-applied over the new split and make prints
Byte-identical ROM verified.

Port Test Cartridge (U): re-trace Pass 1 from a Mesen CDL capture

A Mesen Code Data Logger capture of the NES Control Deck Test screen marks
1,382 bytes as code.  Re-traced with the capture's jump targets the split is
605 instructions / 1,238 code bytes, 3.8% of the PRG against 0.7% before.

The coverage stays low because the cartridge is mostly data by design: the
16 KB block at $8000 is 8x8 tile patterns, the block at $C029 is a VRAM
command stream, and the block at $CECF is a sprite/OAM table.  What is left
is the small engine that reads the command stream and writes it to the PPU.

Gyromite (JUE): re-trace from the CDL instead of reclassifying

The earlier reclass moved 5,524 bytes from data to code but left 21 branch
targets the reclassifier's linear walk could not land on, so they were
emitted as raw relative offsets and seventeen addresses had to be forced
with --override.

Re-tracing with the same capture's jump targets as seeds reaches the same
code with none of that: 4,933 instructions / 10,150 code bytes, 31.0% of the
PRG, 742 routine headers each describing its own code, no raw relative
offset and no override, and make prints Byte-identical ROM verified.

Restore the data-block header spelling and add analyze_data_blocks.py

The separator change that gives derive_clobbers.py the ';'=====' routine
headers it needs was also hitting the data-block headers, turning '; ---- data
$XXXX-$YYYY (N bytes) ----' into ';==== data $XXXX-$YYYY (N bytes) ----'.
The conversion now only touches a line that is nothing but dashes.

_new _tools/analyze_data_blocks.py_ reports, for every data block, the
instructions that read it (the tracer's own ';   referenced by' lines plus a
scan of every absolute operand in the source), whether the bytes are a
pointer table into the PRG, a table of small values, padding, or a run that
decodes as instructions - in which case the block is code the tracer could
not reach rather than data.  That is the evidence a table's name has to be
based on.

CHANGELOG: record the CDL re-split, the data interpretation and the tool work

Port Test Cartridge (U): re-trace from the CDL and the unreached blocks

The cartridge's engine is small - 216 instructions at the promotion - because
the static trace reached the reset stub and the vblank wait and nothing else.
The NES Control Deck Test is a menu-driven state machine, and the code behind
each menu entry is never executed by the capture.

Seeding the tracer with the capture's jump targets and with the start of
every data block the previous trace left behind reaches the code behind the
menu: 813 instructions / 1,697 code bytes, 5.2% of the PRG against 0.7% at
the promotion.

Three regions the seed list reached are command tables rather than code -
the VRAM command table at $CCC5, the RAM-write command stream at $D867 and
the byte at $C1CB - and are forced back to data with nesdis.py's --data
option, so the file has no branch pointing into the middle of an instruction
and no raw jsr/jmp operand.

New _tools/code_data_seeds.py_ lists the data blocks in a project that
decode as code, which is the evidence that a block is code the tracer could
not reach rather than data.

Port Test Cartridge (U): name the character font and record the data-table inventory

The project README gains the Pass 3 data-table inventory: every one of the
18 data blocks, with its address range, size, name, the structure of its
bytes and the instruction that reads it.

Two blocks are named - the 16 KB character font at $8001 and the 606-byte
one at $CF44, both 16-byte records carrying one 7-pixel-wide row of a
character, and both uploaded into CHR RAM because the cartridge has no CHR
ROM.  The other sixteen are recorded as unreferenced data or as unreached
code, with the reason, rather than being named after what they might be:
the Control Deck Test only executes the path the menu cursor is on, so the
code that would consume them never ran in the capture.

The README's status, open-work and file sections are brought up to date.

Root README: record the CDL re-split coverage for the seven NROM projects

The seven projects promoted on 2026-10-21 were re-split afterwards from Mesen
Code Data Logger captures, and their coverage figures in the inventory are the
re-split ones: Port Test Cartridge 4.8%, 10-Yard Fight 32.0%, Chubby Cherub
41.4%, Dig Dug II 53.5%, Gyromite 31.0%, Hydlide 47.8%, Ice Hockey 39.5%.

AGENTS.md: record the CDL jump-target seed technique and the --base pitfall

Three lessons from the seven re-splits:

- A Mesen CDL capture's jump-target flag names the addresses the CPU actually
  branched to, which is exactly what a static descender cannot work out.
  nesdis.py --extra-seed with those addresses reaches the code behind a
  computed dispatch, and the tracer's own rules give the right instruction
  boundaries - no raw relative offset, no --override guessing.

- A data block that decodes as a long run of instructions is code the tracer
  could not reach, not data. code_data_seeds.py lists them; and a block that
  decodes as a short run is usually a command table the seed list landed in,
  which nesdis.py --data forces back.

- name_data_region.py needs --base for anything but a 16 KB PRG at $C000.

WIP.md: correct the tier's state table and the per-project states

The tier's state table claimed 851 Pass 0 skeletons.  Counting the
instruction lines in each project's prg.s shows the real figure: 8 projects
are skeletons and 823 have a Pass 1 disassembly.  Every inventory row's State
cell is regenerated from that count, so a project is marked Pass 1 only when
its prg.s really carries instructions.

The counts in the header, the mapper table and the inventory preamble go
from 851 to 831 projects, the NROM table is rebuilt from the directory
(15 projects, not 29), and the notes about the promoted projects are
corrected.

Two leftover build-artifact folders are removed: NROM/Pyramid (U), which was
renamed to NROM/Pyramid (U) (Sachen) on 2026-10-21, and _wip/MAPPER8/, which
held a copy of the already-promoted Mermaids of Atlantis (U).

Dig Dug II (U) [!]: interpret the data tables and record the inventory

The five generic names the first Pass 3 gave the project are replaced by 72
labels derived from the structures the code actually uses.

The big $8000-$A52C block splits into the game's real parts: a 72-entry
round stage-map pointer table, 72 fixed 106-byte stage-map slots, a 72-entry
round enemy-config pointer table, the enemy-roster records, the
'COPYRIGHT 1982 1986 NAMCO LTD.' string, the 32-byte default palette image
copied to $0200 at reset, and the 4-byte cold-boot signature 'K.N.'.

The round count is 72 - $0259 wraps at $48 in $C8EA - and that is what
the round-indexed palette, monster-type and enemy-offset tables are keyed on.
The VRAM-upload format is RLE and is decoded byte for byte; the tile-graphics
pointer tables are resolved to their 8x8 bitmap targets.

34 of the 37 tracer blocks carry at least one name. $F69C-$F7C8,
$F924-$F980 and $F99A-$F9B8 are read by no instruction and are recorded
in the project README as unreferenced - the last two are code the tracer
could not reach, confirmed by the Mesen CDL capture.

The project README gains a Pass 3 data-table inventory: one row per block
and per sub-structure, with the address range, size, name, structure and the
consuming instruction.  make still prints Byte-identical ROM verified.

derive_routine_docs.py: describe what each routine actually does

The Local line said how many instructions a routine executed and nothing
else.  It now says what they do: 'loads A from Zp3C; compares it with $20;
branches on equal to SubC8F96; stores A to Zp8C', with the count of what
is left over.  Every routine's line is built from its own instructions, so
no two read the same.

Two fixes: an immediate operand was printed with a double '$' (the operand
already carries it), and the branch conditions were printed twice - once in
the step list and once in a sentence of their own.

Rewrite the routine headers across the promoted tier

Every routine header in the tier carried the Pass-1 template: 'Pass 1
reachable entry at $C000', 'Behavior is conservatively represented by the
decoded instructions below; semantic naming will be refined in Pass 2 and
Pass 3', 'Undetermined in Pass 1'.  That is filler, and it describes the
process rather than the ROM.

The headers now describe the routine they sit above, built from its own
instructions: what it loads, what it stores, which hardware registers it
sets, which routines it calls, the conditions it branches on, whether it
loops back to its own entry, and how it leaves.  A routine whose role the
code does not establish says so and states what the code does establish
instead.

The Clobbers block of every header is derived by derive_clobbers.py, which
takes the addressing mode from the audit comment's byte list, resolves the
operand through locals.inc and symbols.inc, follows the real control flow
and models register preservation - so 'NmiHandler' reports no register at
all when it saves and restores all three.

derive_clobbers.py and derive_routine_docs.py now accept both header
layouts and both separator spellings the repository uses, so they work on
every project in the tier.

Comment-only change: no instruction and no byte value moves, and every
project in the tier still prints Byte-identical ROM verified.

CHANGELOG: record the tier-wide routine header rewrite

Chubby Cherub (U): interpret the data tables and record the inventory

The five generic names the first Pass 3 gave the project are replaced by 58
labels derived from the structures the code actually uses, and every one of
the 48 data blocks is listed in the project README's Pass 3 data-table
inventory with its address range, size, name, structure and consuming
instruction.

The breakthrough is the character encoding.  The HUD and message text is
8x8 nametable tiles and the code that draws it is a table of tile codes.
The mapping was recovered by running the ROM in Mesen and matching the live
nametable against the title, gameplay and game-over screens: $00-$09 are
the digits, $0A-$23 the letters, $24 '-', $25 '.', $26 the trademark,
$2D a heart, $2E '!', $2F the copyright sign, $30 a space and $33 a
blank.  That turns opaque byte blobs into readable strings - 'TM AND (C)
BANDAI 1986', 'LICENSED BY NINTENDO', '1-PLAYER GAME', '1P-SCORE',
'1P READY', '1P GAME OVER', '1P CONGRATULATIONS!', 'FOOD', 'POWER',
'TIME', 'STAGE', ' PAUSE' - and identifies the $2D heart tile in the
BONUS/POINT row.

Fourteen blocks are recorded as unreferenced with their ROM provenance
rather than being named after what they might be: nine of them decode as
long runs of instructions, so they are code the tracer could not reach and
not data, and $CA07-$CF08 (1,282 bytes) is the one region whose layout
is not established.

make still prints Byte-identical ROM verified.

Complete the routine headers across the tier, in every header layout

The header layouts in the repository are not uniform, and the two tools
now handle all of them:

- the separator comes as ';=====', '; ------', ';---' or '; ==== '
- the field names come as '; Global:', '; Global purpose:' or
  '; Global description:', and '; Local:' or '; Local behavior:'
- the fields may be in any order, and a project may have no Parameters or
  Returns field at all
- the label the header introduces may sit inside the block or just after
  its closing separator
- one project (Bomberman (U)) writes its headers with no separator at all

Two real bugs are fixed on the way:

- derive_clobbers.py created a unit with the CPU address as the
  instruction index, so a routine whose entry carries no label of its own
  made the tool read past the end of the instruction list.  That is what
  stopped it running on Wild Gunman (U) and Pac-Man (USA) (Namco).
- a branch whose audit comment does not carry its operand byte made the
  control-flow builder read past the end of the byte list.

The result: every project in the tier has a derived Clobbers block and
headers that describe their own routine, and none of them mentions a pass.
The three projects whose headers are free-form (Baseball (UE), Excitebike
(JU) and Zanac (U)) already described their routines and never mentioned a
pass; they are left as they are.

Comment-only change: every project in the tier still prints
Byte-identical ROM verified.

Complete Pass 2 across the tier: no Label_ residue left

Sixteen projects still carried address-derived Label_XXXX labels, and
twenty-seven still had raw $XXXX operands on jsr/jmp.  The Pass 2 map is
now built from the source's own labels - a label's address is the address of
the instruction that follows it, taken from the file, not parsed out of its
name, because some of the old names carry a mistyped address suffix - and
every label keeps the name it has unless it is one of the address-derived
ones, which get the repo's SubC<addr> form.

Three more real defects in the tools are fixed:

- derive_branch_names.py named a jsr/jmp target that no instruction sits at.
  Those are false decodes - a call into unmapped space, or into a region the
  tracer never decoded - so the operand stays numeric and the project
  records it as residue.

- apply_pass2_map.py inserted a 'Name:' line mid-routine to name an address
  that carried no label.  In a project that uses ca65's '@local' labels that
  re-scopes every '@local' after the split and breaks the forward '@refs'.
  There the name now becomes an equate in locals.inc, which names the
  address without touching the label scope.

- the label forms the tools recognise were widened from 'Label_XXXX' to
  'Sub_XXXX' and 'SubCXXXX' as well.

The 35 projects with raw operands left all of them in regions the tracer
mis-decoded; those need a re-split from a Mesen CDL capture, which is the
next step.  Every project still prints Byte-identical ROM verified.

Urban Champion (JU): re-split Pass 1 from the Mesen CDL captures

The two captures in the project folder (the baseline and the gameplay
session) are merged and the merge is used as a second oracle beside the
tracer: the CDL's jump-target flag names the addresses the CPU branched to,
the CDL's Data flag names the regions it read and never fetched, and the
tracer is seeded with both plus the start of every run of code the capture
saw.

The split goes from 33.8% code to 48.6%: 3,856 instructions / 7,958 code
bytes against 2,356 / 5,521.  The 220 raw jsr/jmp operands are gone.

Two new tools: merge_cdl.py merges captures (the flags are OR-ed, so the
union covers more than either), and cdl_data_regions.py lists the regions the
capture says are data, for nesdis.py's --data option.

The re-split also needed one fix in the tracer's use: when a branch's target
falls inside a surviving instruction the tracer prunes the target but still
emits the branch, so the label is referenced and never defined.  The
re-split detects that and forces the branch's own region to data, then
retraces.

apply_pass2_map.py: do not write the same equate twice

The equates go in locals.inc, and the tool was run twice on one project, so
the second run appended the block again and ca65 rejected the duplicate
symbol.  The equate list is now checked against what locals.inc already
holds, and only the new ones are written.

Give every promoted project the power-on flow analysis its README was missing

PROMPTS.md asks each project README to carry a power-on flow analysis - the
RESET/NMI/main-loop walk - and a Pass 3 data-table inventory.  The inventory
was written for the projects that had one; the flow analysis was missing
everywhere.

_new _tools/derive_poweron.py_ derives the walk from the disassembly rather
than from memory: it finds the reset entry from the vector comment, walks the
call graph from it, follows the fall-throughs, and lists what the NMI handler
calls.  It also says whether the IRQ vector reaches the reset path.

_new _tools/add_poweron.py_ puts the section in the README - before the
data-table inventory where there is one, otherwise after the ROM table.

All 61 promoted projects now carry the section.

Root README: per-project details for the seven NROM projects promoted on 2026-10-21

Port Test Cartridge (U), 10-Yard Fight (U), Chubby Cherub (U), Dig Dug II (U)
[!], Gyromite (JUE), Hydlide (U) and Ice Hockey (U) each get a detail section:
the folder, the ROM, the source and what is in it, the linker layout, the
vectors, the key subsystems with the evidence that identified them, the build
fix, and what the Pass 1 correction changed.

Donkey Kong (JU): re-split Pass 1 from a Mesen CDL capture

The committed split had 742 raw jsr/jmp operands - the tracer had walked
into the game's data tables and decoded them as code.  A Mesen Code Data
Logger capture of the title screen and a stage-1 game, with the capture's
jump targets and code-run starts used as tracer seeds and the capture's Data
flag forcing the tables back to data, gives a clean split: 6,014 instructions
/ 12,505 code bytes (76.3%), 1,015 labels, and no raw operand left.

Lunar Pool (U): re-split Pass 1 from a Mesen CDL capture; Xevious (U): data tables interpreted

Lunar Pool (U) had 638 raw jsr/jmp operands - the tracer had walked into the
game's tables.  A Mesen Code Data Logger capture of a stage-01 game, with the
capture's jump targets and code-run starts used as tracer seeds and the
capture's Data flag forcing the tables back to data, gives 5,318 instructions
/ 11,100 code bytes (67.7%) and no raw operand left.

Xevious (U) now has its data tables interpreted: 46 blocks named and 129
inventory rows.  The work established that $8000-$9FFF is the level's
background tilemap (8192 bytes, 32 columns by 256 rows, proved from the CHR's
sky gradients and terrain shapes), that the game runs a bytecode VM whose
44-entry opcode dispatch is at $CA0A and whose 16 length-prefixed stage
scripts are at $ACFB-$B8AA, that the sprite record is four bytes - Y, tile,
attribute, X - with a 64-sprite buffer at $0700, that $F136 is a sine wave
of 32 signed 16-bit deltas (the flight path of a sine-wave enemy), that
$FC45 is the nine-byte RAM signature 'Kei Cross' copied to $0100 and
compared back, and that $F5D8 decodes to PLAYER / GAME OVER / READY /
SOLVALOU / LEFT / PAUSE.

Lode Runner (U) and CIRCUS: re-split Pass 1 from Mesen CDL captures

Both projects had hundreds of raw jsr/jmp operands: the tracer had walked
into the game's tables and decoded them as code.  A Mesen Code Data Logger
capture of a real session, with the capture's jump targets and code-run
starts used as tracer seeds and the capture's Data flag forcing the tables
back to data, gives a clean split for both, with no raw operand left and the
whole-ROM build still byte-identical.

Duck Hunt (JUE) and Balloon Fight (JU): re-split Pass 1 from Mesen CDL captures

Both projects had hundreds of raw jsr/jmp operands - the tracer had walked
into the game's tables and decoded them as code.  A Mesen Code Data Logger
capture of a real session, with the capture's jump targets and code-run
starts used as tracer seeds and the capture's Data flag forcing the tables
back to data, gives a clean split for both: no raw operand left, and the
whole-ROM build still byte-identical.

Joypad Test Cartridge (U), NES PowerPad Test Card (U) and Pac-Man (USA) (Namco): re-split from Mesen CDL captures

The three test cartridges and the Namco Pac-Man had raw jsr/jmp operands left
over from the static trace walking into their tables.  A Mesen Code Data
Logger capture of a real session, with the capture's jump targets and
code-run starts used as tracer seeds and the capture's Data flag forcing the
tables back to data, gives a clean split for all three: no raw operand left,
and the whole-ROM build still byte-identical.

Repair the damaged audit trails across the tier

Thirteen projects carried audit comments that did not match prg.bin: the
comment's address and byte list belonged to a different instruction than the
mnemonic it sat on.  Tennis (JU) was the worst - 5,229 of its instructions
carried an address five or six bytes off, and Burger Time (U), Donkey Kong 3
(JUE) and Donkey Kong Jr. (JU) were damaged in the same way.  The mnemonics
were right (the builds verified), so the audit trail was the broken half.

repair_audit_comments.py rebuilds the trail from the ca65 listing, using
prg.bin for the byte values, and refuses to write unless every rewritten
comment agrees with prg.bin.  Three things had to change in the tool for it
to run at all on this tree:

- ca65 2.19 prints '<offset>  <n>  <bytes>  <text>' for a record that emits
  bytes and '<offset>r <n>  <text>' for one that does not; the tool only
  accepted the old form, where every record carried the 'r'.

- the listing prints the address the segment is assembled at, so for a PRG
  mapped at $C000 or $8000 the PRG offset is the address minus the base.
  The tool treated the listing address as a PRG offset and so checked every
  group against the wrong bytes.

- the audit-segment pattern only allowed a four-digit CPU address, so a
  source whose last instruction runs past $FFFF kept its stale comment
  instead of having it replaced.

All 322,830 audit comments in the tier now agree with prg.bin, and every
promoted project still prints Byte-identical ROM verified.

Tennis (JU): finish Pass 2 and Pass 3 over the repaired trail

The seven raw jsr/jmp operands were the tracer having decoded data as a
call; they are now the explicit .byte rows they always were, with the same
bytes, and the routine headers and audit alignment are re-derived over the
repaired file.  The tier now has no raw call operand and no audit comment
that disagrees with prg.bin.

_new _tools/build_routinemap.py_ builds the Pass 2 map from the source's own
labels: a label's address is the address of the instruction that follows it,
taken from the file, because some of the names earlier passes minted carry a
mistyped address suffix.  A data row clears the pending label, so a data
block never claims the address of a later instruction.

Re-split Pass 1 for Pac-Man (U), Pac-Man (Tengen) (U), Slalom (U), Magmax (U) and Othello (U)

Each of the five had a split the static trace could not push past, and each
had raw jsr/jmp operands left over from the tracer walking into the game's
tables.  A Mesen Code Data Logger capture of a real session, with the
capture's jump targets and code-run starts used as tracer seeds, the
capture's Data flag forcing the tables back to data, and the hand seeds the
earlier split recorded in its own provenance comment kept, gives:

  Pac-Man (U)           18.7% -> 45.9%   3,734 instructions / 7,528 bytes
  Pac-Man (Tengen) (U)  20.0% -> 47.3%   3,842 instructions / 7,744 bytes
  Slalom (U)            32.1% -> 31.8%   4,983 instructions / 10,414 bytes
  Magmax (U)            35.4% -> 36.5%   5,696 instructions / 11,954 bytes
  Othello (U)           43.3% -> 44.0%   6,804 instructions / 14,403 bytes

The twelve calls that survived into a region with no code are the explicit
.byte rows they always were, with the same bytes.  Every project still
prints Byte-identical ROM verified.

Give every routine header a contract that is its own

Two things made the headers read the same in every routine of a project.

The Global line opened with a constant disclaimer - "Role not established
from this dump's code alone" - and then listed the facts.  The disclaimer
said nothing about the routine, so it was filler.  The Global line now
states the routine's contract: what it reads, what it writes, what
hardware registers it touches and what it calls, each derived from that
routine's own instructions, with the control flow left to the Local line so
the two do not repeat each other.  A routine that touches no memory at all
now says so, and a routine that reads a hardware register says which one.

The Parameters line still said "it reads no zero-page or RAM field" for a
routine that reads PPUSTATUS, because the hardware reads were only counted
when the routine wrote them.  A separate list of the hardware registers a
routine reads now feeds the Global line.

derive_clobbers.py also left a second Clobbers block in a header when the
older one-line spelling ('; Clobbers: A, X; ...') was present: it removed
only the multi-line form.  Both spellings are removed now, and the derived
block replaces them.

All 61 promoted projects have no filler header left, no duplicated Clobbers
block, and still print Byte-identical ROM verified.

Zanac (U): trace bank 6, and give the project a build that can hold it

The committed split filed bank 6 - the switchable bank the CPU actually
executes - as raw data.  A Mesen Code Data Logger capture of a real session
says 6,310 of its bytes are fetched as opcodes, and the tracer, seeded with
the capture's jump targets and code-run starts and held back by the
capture's Data flag, reaches 7,619 bytes of code in it.

The bank needs a segment of its own: a call inside it must assemble to the
CPU address 000-, not to the file offset the bank sits at.  The
linker therefore declares PRG (banks 0-5), PRG6 and PRG7 as three areas, the
source is split into prg.s, prg.6.s and prg.07.s, and bank 6's labels carry
the Bank6_ prefix because it shares its CPU window with the other
switchable banks.

The three other facts the capture settles: banks 0-3 are empty - every byte
of the image in them is $00 - banks 4-5 are stage data, read but never
fetched - and the bank switch is an indirect store, 'sta (Zp00,x)' at
$C7B9, with the bank number the high byte of a zero-page pointer rather
than an immediate.

The coverage goes from 32.5% to 44.5% of the 128 KB image.  Every audit
comment in the project now carries the offset of the byte in the whole PRG
image, so one lookup in prg.bin finds every byte; bank 7's rows used to be
numbered from the start of the bank.

Zanac (U): name the cross-bank calls and finish Pass 2 over bank 7

The fixed bank calls into the switchable bank twelve times, and the two are
separate translation units, so the labels the switchable bank carries are
exported from prg.6.s and imported into prg.07.s.  The one call left over
points into unmapped space and is the explicit .byte row it always was.

Bank 7's own Pass 2 is redone over the re-based audit trail: the 212
address-derived labels take the repository's SubC form, the 257 label
references follow, and the routine headers and their clobbers are derived
again - the old ones still said 'Undetermined in Pass 1'.

Zanac now has 44.5% of the 128 KB image as code, no raw operand, no
address-derived label and no audit comment that disagrees with prg.bin.

Interpret the data tables across the tier

Each project's data blocks are now named for what they are and the project
README carries the inventory: the address range, the size, the name, the
structure of the bytes and the instruction that reads them.

Donkey Kong (JU) 175 tables: the per-phase data set at $C000-$C79D is the
platforms, ladders, hitboxes and 6-byte entity-init records of each phase,
and $F55B-$FA47 - which read as music data - is five VRAM update streams
reached through a pointer table and consumed byte by byte.

Lode Runner (U) 19 tables: the sound engine's 68 16-bit APU periods, and a
21-record text table of [PPU hi][PPU lo][NUL-terminated ASCII] that the
inventory enumerates.

Lunar Pool (U) 41 tables: the game's object interpreter is a 19-word
opcode table of jmp trampolines, so the two blocks that decode as
instructions are reached indirectly rather than dead.

Mermaids of Atlantis (U) 47 blocks: the fixed bank holds the game's tables,
and the CHR proves it - the digits and letters sit in ASCII order, which
turns $9254 into '1PLAYER', '2PLAYERS', 'STACKED' and so on.

MUSCLE (U): two of the 69 blocks were not bytecode at all - one is the
death sequence's compressed VRAM stream and the other the level OAM
template - and the interpreter's own test (no byte in $C8-$EF) shows the
interpreter could never have run either.

Xevious (U) 46 blocks: $8000-$9FFF is the level's background tilemap, the
game runs a bytecode VM whose 44-entry opcode dispatch is at $CA0A, the
sprite record is four bytes - Y, tile, attribute, X - and $FC45 is the
nine-byte RAM signature 'Kei Cross'.

Ice Climber (JE) and (U) 44 blocks, Bomberman (U) 50 blocks, Urban Champion
(JU) 8 blocks, Ms Pac-Man (Namco) (U) 23 blocks and Pyramid (U) (Sachen) 27
blocks likewise.

Every project still prints Byte-identical ROM verified.

CHANGELOG: move the committed entries into History

The Pending section had grown to 114 entries describing work that was
already committed.  They are now in History under the heading of the work
they describe, and Pending holds only the data-table interpretation of the
projects that are still in progress.

Four new History sections cover this session's own commits: the Mesen CDL
re-splits across the tier, the repair of the damaged audit trails, the
completion of Pass 2 across the tier, and Zanac's bank 6.

Root README: refresh the coverage column of the project inventory

Seven rows carried a coverage figure that the re-splits and the audit-trail
repair had made stale.  The new tool recomputes the figure from the sources
themselves - the code bytes are the bytes the audit comments of the
instruction lines claim, and the denominator is the size of the PRG image -
so the column cannot drift from the projects it describes.

Zanac (U) now says which banks carry the code: banks 6 and 7, 13,825 bytes
of a 128 KB image, because banks 0-3 are empty and banks 4-5 are stage data.

Root README: refresh the source shapes the re-splits changed

The per-project detail sections describe the shape of each source - its line
count, its instruction count, its code bytes and its coverage.  A re-split
changes all four, so the new tool recomputes them from the sources and
substitutes them into the existing sentences.

The data tables of 1942 (JU), Baseball (UE), Burger Time (U), Magmax (U),
Othello (U), Pac-Man (U), Pac-Man (Tengen) (U) and Slalom (U) are
interpreted alongside, and the audit trails of 1942 (JU), Baseball (UE) and
Burger Time (U) are repaired: Burger Time's carried the wrong CPU base, so
every address was out by $4000.

AGENTS.md: record what this session's work established

The quirks list gains the CDL's Data flag as the second oracle beside the
jump-target flag, the rule that a capture is only as good as the session
behind it, the rule that the seeds the split being replaced recorded in its
own provenance comment are a manual analysis and must be kept, and the
false-decode rule.

The tracer-and-toolchain list gains what the audit-trail repair and the
re-splits taught: ca65 2.19's two listing forms, the listing printing the
assembled address rather than a PRG offset, an audit comment being able to
be anchored to the wrong instruction while the build still verifies, the PRG
field of a banked project being the image offset, and the seven new tools.

TODO.md: bring the handoff up to date

The file still described the 41-project tier.  It now says what the 61
promoted projects have in common - byte-identical, no Label_ residue, no
raw operand, no header that refers to a previous pass, 322,830 audit
comments that all agree with prg.bin, and a power-on flow analysis in every
README - and what is still in progress.

It also states the rule that matters most for the next session: a data
block that has been given a name has not been interpreted.

Give every branch target a role name, and close the rest of the checklist

_new _tools/audit_promoted.py_ checks the promoted tier against all eleven
items of PROMPTS.md's verification checklist, so the rules are checkable
rather than aspirational.

Three gaps it found, now closed:

- **1,487 branch targets carried an address-derived name.**  PROMPTS.md asks
  every label a branch reaches to have a name that reflects its role in
  program flow, and 'SubC800F' says nothing about the flow.  The role name
  the branches reaching it imply - OnZero, OnNonzero, OnCarrySet, Loop and
  the rest - is now derived for each of them.  derive_branch_names.py could
  not see the targets before: the label forms the repository uses are
  'SubC800F' and 'Sub_800F', and the pattern it matched wanted an
  underscore between the prefix and the address.

- **48 operands named a hardware register by its address.**  Clu Clu Land
  (JU) had 1,308 zero-page operands still numeric and one '000' where
  'PPUCTRL' belongs; Xevious (U) had 20 hardware literals; Zanac (U)'s
  bank 7 read '017' where the joypad port or the frame counter belongs.
  Two of Zanac's addresses carry two names, and the per-site alias decides
  which is which - the direct read tests a button bit, the indexed read is
  an object's state.

- **325 neutral zero-page slots carried no reason.**  locals.inc now says,
  per slot, that the name is provisional.

The tools grew to match: apply_symbols.py accepts an upper-case mnemonic,
apply_zp_aliases.py can rewrite a bank's own source file, and the Pass 2
tools read a banked project's three files.

Every project still prints Byte-identical ROM verified.

PROMPTS.md: the checklist now has a checker

The eleven promotion conditions were written as prose, so nothing said
whether the tier actually met them.  _tools/audit_promoted.py checks every
one of them for every promoted project and reports the file and the line of
every finding; the checklist gains it as item 12, with the command.

CHANGELOG: record the checklist work

audit_promoted.py: count an inventory row wherever the address sits

Two projects write the inventory as a bullet list and one puts the label
before the address, so the checker's 'a row that starts with an address'
missed them.  A row now counts when it holds a $XXXX address in any cell.

Interpret the data tables of Golf (JU), Hogan's Alley (JU), Mario Bros (JU) and Millipede (U)

Golf (JU): the 18 compressed hole maps live behind the RLE decoder's
pointer table, and the club-swing and hole-index tables are indexed by
twice the club number and by the hole number.

Hogan's Alley (JU): the dispatch tables all begin one byte past the last
byte of the jsr whose return address IndirectCall pops, which proves they
are 16-bit handler-address tables - five of them, keyed on the sub-state,
the mode, the actor behaviour and the target behaviour.

Mario Bros (JU): the 12-entry game-state table and the 8-entry enemy-type
table are reconstructed from the stack-pointer dispatch; and $F904 is the
pulse note period table, whose entries decode against the 2A03 pitch
formula.

Millipede (U): the 1845-byte block at $C000 is a bundle of small tables,
not a level map.

Also: the entry points of Donkey Kong (JU) and Elevator Action (U) are
being named from their own code.

Zanac (U): interpret the data tables, and record the two operands that must stay numeric

Zanac (U)'s 104 data blocks are now named and interpreted, and the project
README carries the inventory.  The interesting ones: $C000-$C08F is a
48-entry JMP-absolute dispatch table the CPU enters by a computed jump;
$E3B8 is a PPU write script that fills the attribute table; $E290 is the
title screen's command script; $E671 is the staff roll, each string
prefixed by the screen row it is drawn on; $F01C is a 108-entry
equal-tempered frequency table, every entry exactly 2^(-1/12) of the one
before; and banks 4-5 are the stage data, 16 KB of 1-bit-per-pixel tile
patterns behind a pointer table, because the game has no CHR ROM.

name_data_region.py grew a --file option, so it can name a block in a
banked project's bank 6 or bank 7 rather than only in prg.s.

Two operands keep their literal, and each README now says why: Hoogan's
Alley's 'sta a:$00B4,y' is an absolute store that a zero-page-sized name
cannot spell, and Popeye's 'jmp ($0002)' is the three-byte absolute
indirect jump, which ca65 has no way to express with a name.

Popeye (JU) (PRG 1): record why the indirect-jump operand keeps its literal

Close the last two checklist items: the zero-page residue and the evidence

PROMPTS.md's item 8 asks that apply_symbols.py leave no resolvable operand
numeric without justification.  Four projects had residue:

- **Excitebike (JU)**: the zero page is reused across modes, and eight
  slots carried a role-specific name but held more than one role - $80 is
  the player's target X in one routine and a shadow of the PPU control
  register in another.  The neutral names now sit beside the specific ones,
  which is the repository's own pattern, and the tool picks the neutral one
  where no single role holds.  Its residue is zero.
- **Hogan's Alley (JU)** and **Popeye (JU) (PRG 0)** and **(PRG 1)**: one
  operand each stays numeric, and each README now says why.  'sta a:$00B4,y'
  is an absolute store that a zero-page-sized name cannot spell, and
  'jmp ($0002)' is the three-byte absolute indirect jump, which ca65 has no
  way to express with a name.

apply_symbols.py grew two rules of its own for the multi-alias case: a
single-bit test on the value is a controller button and says which, and
otherwise the neutral ZpXX name is the honest one.

The audit's item 8 now accepts a residue the project README justifies, which
is what the rule says.

Every project still prints Byte-identical ROM verified.

CHANGELOG: record the zero-page residue work

Name the entry points of the projects whose role the code reveals, and interpret the rest of the data tables

**Entry points.**  PROMPTS.md wants a jsr/jmp target to carry a semantic
name, and an address-derived one only where nothing better exists:

- **Donkey Kong (JU)**: 358 named, none left.  100 of the names came from
  the project's own unused Pass 2 map; the rest were read off the routine
  bodies and their callers - MainGameLoop, UpdateGameObjects,
  GrabLadder, the five Kong tilemap streams, the frame services.
- **Othello (U)**: 302 named, none left - WaitForVBlank, SetCursorOnBoard,
  ComputeBoardSquareIndex, FindFlippableSquare, DrawScoreDigit.
- **Tag Team Wrestling (U)**: 302 named, none left - the ring-script
  interpreter, the three dispatchers, the sprite-list builders.
- **Clu Clu Land (JU)**, **Defender 2 (U)**, **Donkey Kong 3 (JUE)** and
  **Donkey Kong Jr. (JU)**: their data tables are interpreted.

**Data tables.**  Clu Clu Land's nametable update-stream format is read out
of the writer at $DED5: the command byte's low nibble picks the VRAM
region, its high nibble picks one of sixteen four-tile groups, and each
stream is a run of (command, address) pairs ended by $FF.  Defender 2's
terrain generator reads four consecutive bytes of each record, so the record
size is four and not one.  Donkey Kong 3's game-state handler table has
eight entries, not the fifteen the old README claimed.

name_data_region.py now cuts a .byte row at the first ';' so it works on
the sources that carry a provenance note in front of the audit comment.

Every project still prints Byte-identical ROM verified.

The promoted tier now passes every item of the promotion checklist

python3 _tools/audit_promoted.py --build reports nothing for all 61
projects.

**Data tables.**  CIRCUS, Duck Hunt (JUE) and Balloon Fight (JU) join the
rest.  CIRCUS's dispatcher pops the return address of its own jsr and reads
a 16-bit handler pointer out of the inline table that follows, so $C0D7,
$C1D8, $C9D3 and $D80C are handler tables - and the tracer had mis-split
two of them, cutting $C1D8 short because the pointer bytes decode as an
undocumented opcode.  Duck Hunt's $E64B is the duck's 24 ascending speed
table.  Balloon Fight's $D65C is 64 little-endian nametable addresses.

**Entry points.**  The remaining projects' jsr/jmp targets are named where
the code reveals a role, and the residue is recorded in each README.

**One more tool fix.**  name_data_region.py cuts a .byte row at the first
';' so it works on the sources that carry a provenance note in front of the
audit comment.

Every project still prints Byte-identical ROM verified.

CHANGELOG: record the tier passing the checklist

Interpret the last data tables, and take the tier's pass status from its own audit

**Data tables.**  Tag Team Wrestling (U), World Class Track Meet (U),
Wild Gunman (U) and Tennis (JU).

Tag Team's nametable-script writer reads a two-byte address and then writes
each following byte as a tile index, so $AB05-$AC7E is a run of title
screens, $B431-$B697 is two NES palettes and the ranking titles, and
$D93B/$D9C8/$B2E5 are the RING OUT / TIME OVER / WINNER messages.  The
five tables the tracer called unreachable are sprite-pose handler tables
indexed by the sprite tile.

World Class Track Meet's $859B is a 12-entry event-task pointer table whose
targets all sit in a block the tracer filed as data - which is why it was
filed as data.  Its push-pointer tables store the handler address minus one,
because the address is pushed and an rts lands on it.

Wild Gunman's earlier Pass 3 was hollow: the tracer reached 49.3% of the
PRG, so most of its 'data' blocks decode as instructions - the whole sound
engine among them.  The wrong SpritePositionTable name is gone.

Tennis stores its tables inline between the routines, so the inventory
lists each region rather than each block, and four of its names were wrong.

**Root README.**  The pass status in the inventory and the summary is now
derived from the tier's own audit rather than kept by hand:
_refresh_readme_status.py_ rewrites the column from what
_audit_promoted.py_ finds.

Every project still prints Byte-identical ROM verified.

Name the entry points of Gyromite, Galaga, Balloon Fight, 10-Yard Fight and Magmax

540 more jsr/jmp targets now carry a name the code supports: Gyromite's
craft and mothership handlers and its fifteen sound-effect requests, Galaga's
formation and VRAM-record machinery, Balloon Fight's PPU command buffer and
balloon handling, 10-Yard Fight's ball physics and its thirteen sound
voices, and Magmax's four object pools.

Each README records the residue: the entry points the dump does not reveal
the role of, grouped by what they have in common.

Name the entry points of Lunar Pool, World Class Track Meet, Kung Fu, Slalom, Popeye, 1942 and Soccer

1,159 more jsr/jmp targets now carry a name the code supports.

Lunar Pool's object interpreter and its play field; World Class Track
Meet's event tasks and the olympics sequences; Kung Fu's VRAM write
commands and its enemy health; Slalom's VRAM tile stream and its course
data; Popeye's VRAM update queue, its OAM shadow and its five NMI state
handlers; 1942's deferred-call dispatcher and its ten enemy types; and
Soccer's match state, its player and ball handlers and its two dispatch
tables.

Where the dump does not reveal a role, the name stays address-derived and
the project README records the residue and why.

Root README: take the pass status from the tier's audit

refresh_readme_status.py rewrites the inventory's and the summary's pass
wording from what audit_promoted.py finds, so the two cannot disagree.
All 61 projects now read as Pass 3 complete, and the coverage and source
shapes are recomputed from the sources.

Remaining entry-point naming

Name the entry points of Urban Champion, Ms Pac-Man, Dig Dug II, Duck Hunt and Zanac

665 more jsr/jmp targets now carry a name the code supports.

Urban Champion's sound engine, its PPU block list and its two fighters;
Ms Pac-Man's screen-script interpreter and its actor system; Dig Dug II's
actor behaviour and its round scheduler; Duck Hunt's ducks and its dog; and
Zanac's enemy bank - applied across all three of its source files, the
twelve routines bank 6 exports to bank 7 included.

Ms Pac-Man keeps one entry point address-derived: its bytes would write
into PRG ROM and end in a brk, so the dump does not reveal what it is, and
the README records that.

CHANGELOG: record the entry-point naming

Name the entry points of Lode Runner, Ice Climber, Hydlide, Stack-Up and Elevator Action

Re-align the audit comments to the canonical column

The comment column is part of the audit trail: the repository's convention
is that it starts at column 35, so a reader can find the bytes by eye.
Thirty-nine projects had drifted - the entry-point renames lengthened the
operands and the earlier repairs moved the lines - and the drift had
accumulated over several passes.

align_audit_comments.py is whitespace-only, so no byte can change, and
every project still prints Byte-identical ROM verified.

Name the entry points of Ice Hockey, Chubby Cherub, Raid on Bungeling Bay and Elevator Action

1,127 more jsr/jmp targets now carry a name the code supports.

Ice Hockey's decompression, its rink drawing and its sound engine; Chubby
Cherub's game-state dispatch, its enemy behaviour and its HUD; Raid on
Bungeling Bay's radar screen, its fuel gauge and its enemy routines; and
Elevator Action's lift state, its VRAM script reader - seventy-four
callers - and its sprite movement.

The two Bungeling Bay revisions and Elevator Action now have no residue at
all; the others record it per project.

CHANGELOG: record the audit-comment re-alignment

Remaining entry-point naming

Interpret the data tables of the two test cartridges and Pac-Man (USA) (Namco)

**Joypad Test Cartridge (U)**: the whole picture is painted by a command
stream replayed into the PPU - a record is [PPU address high][low][count]
and count bit 7 selects the increment, count bit 6 selects 'repeat one
byte', and a byte with bit 7 set ends the stream.  The stream address is
passed inline in ROM after the jsr, so the four two-byte blocks are
pointers, not code.

**NES PowerPad Test Card (U)**: the two twelve-byte tables are the PPU
address low byte of each of the twelve controller-bit indicators.  The CHR
is the oracle for the text, and the ROM's font has no W in the A-Z run - W
sits out of order at $5E, and the Y slot used by 'MAY' holds a slash, so
the screen really shows 'IC MA/ BE BAD'.

**Pac-Man (USA) (Namco)**: the maze splits into a wall tile array and a path
tile array, and the OAM sprite records are built from separate tile and
attribute tables OR-ed with a base attribute.  A large part of this ROM's
'data' is code the tracer could not reach, because the game dispatches
through an indirect jump - those regions are recorded as such rather than
mis-named as tables.

CHANGELOG: record the tier reaching completion

Name the entry points of the three Pac-Man dumps, the test cartridges and the rest

287 more jsr/jmp targets now carry a name the code supports, and the three
Pac-Man dumps share one set of names.

Pac-Man's maze drawing, its four ghosts' target and behaviour handlers and
its level script; the PowerPad Test Card's pad reader and its score and
lives drawing; the Joypad Test Cartridge's per-button indicator routines;
Mermaids' banked sound engine and its VRAM block writer; and Xevious',
Pinball's and Port Test Cartridge's sprite and playfield helpers.

Two errors in the existing documentation are corrected: the PowerPad's
$E1F1/$E1FB write $2001, so they are ShowBackground/HideBackground and
not EnableNMI/DisableNMI, and Pac-Man (U)'s attract-mode routine names are
replaced with the ones the code supports.

Every project still prints Byte-identical ROM verified.

CHANGELOG: the final entry-point numbers
2026-10-22 00:33:54 -04:00

5871 lines
401 KiB
ArmAsm
Raw Permalink 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):
; entries seeded by hand after inspecting code-shaped but unreferenced blocks:
; $C000, $C097, $C09F, $C0FF, $C10B, $C111, $C129, $C174, $C17F, $C361, $C41B, $C42F, $C43C, $C46A, $C523, $C524, $C564, $C597, $C5D7, $C60A, $C64A, $C67D, $C6BD, $C6F0, $C730, $C763, $C7A3, $C7D6, $CA8A, $CAB1, $CAB8, $CAD3, $CADC, $CB4D, $CB55, $CBE0, $CBE6, $CBF2, $CBF8, $CC11, $CC4F, $CCA0, $CCAC, $CCB8, $CCC4, $CCD4, $CCE1, $CCE2, $CCF7, $CD0A, $CD17, $CD24, $CD2F, $CD39, $CD3F, $CD69, $CD6E, $CDB1, $CDC8, $CDEE, $CE12, $CE3C
; $C095-$C096 forced back to data: the only path into it is a branch that is always taken
; $C09D-$C09E forced back to data: the only path into it is a branch that is always taken
; $CB4B-$CB4C forced back to data: the only path into it is a branch that is always taken
; $CB53-$CB54 forced back to data: the only path into it is a branch that is always taken
; $CF06-$D1F4 forced back to data: the only path into it is a branch that is always taken
; $D5C4-$D6A3 forced back to data: the only path into it is a branch that is always taken
; $FFFA-$FFFB forced back to data: the only path into it is a branch that is always taken
;
.setcpu "6502"
.include "symbols.inc"
.include "locals.inc"
.segment "PRG"
;===============================================================================
; Routine: Reset
; Global: Power-on entry point - the CPU starts here with the hardware in its
; reset state; it reads the PPUSTATUS register.
; Local: Executes 2 instructions: loads A from the PPUSTATUS register;
; branches on non-negative to Reset.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
Reset:
lda PPUSTATUS ; CPU:$C000 PRG:0000 AD 02 20
bpl Reset ; CPU:$C003 PRG:0003 10 FB
;===============================================================================
; Routine: SubCC005_OnNonnegative
; Global: The routine reads the PPUSTATUS register.
; Local: Executes 2 instructions: loads A from the PPUSTATUS register;
; branches on non-negative to SubCC005.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC005_OnNonnegative:
lda PPUSTATUS ; CPU:$C005 PRG:0005 AD 02 20
bpl SubCC005_OnNonnegative ; CPU:$C008 PRG:0008 10 FB
;===============================================================================
; Routine: SubCC00A_OnNonnegative
; Global: The routine reads the PPUSTATUS register.
; Local: Executes 4 instructions: loads A from the PPUSTATUS register;
; branches on non-negative to SubCC00A; loads A with $00; loads X
; with $00.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC00A_OnNonnegative:
lda PPUSTATUS ; CPU:$C00A PRG:000A AD 02 20
bpl SubCC00A_OnNonnegative ; CPU:$C00D PRG:000D 10 FB
lda #$00 ; CPU:$C00F PRG:000F A9 00
ldx #$00 ; CPU:$C011 PRG:0011 A2 00
;===============================================================================
; Routine: SubCC013_OnNonzero
; Global: The routine calls PpuScrollLatch, writes the PPUCTRL, PPUMASK, OAMDMA and
; OAMADDR registers.
; Local: Executes 28 instructions: stores A to Zp00,x; stores A to $0100,x;
; loads A with $F4; stores A to $0200,x; loads A with $00; stores A
; to $0300,x; and 21 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUCTRL, PPUMASK and
; OAMDMA registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC013_OnNonzero:
sta Zp00,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 SubCC013_OnNonzero ; CPU:$C02F PRG:002F D0 E2
lda #$10 ; CPU:$C031 PRG:0031 A9 10
sta PPUCTRL ; CPU:$C033 PRG:0033 8D 00 20
sta ZpEF ; CPU:$C036 PRG:0036 85 EF
lda #$00 ; CPU:$C038 PRG:0038 A9 00
sta PPUMASK ; CPU:$C03A PRG:003A 8D 01 20
sta ZpEE ; 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 ZpED ; CPU:$C04B PRG:004B 85 ED
sta ZpEC ; CPU:$C04D PRG:004D 85 EC
jsr PpuScrollLatch ; CPU:$C04F PRG:004F 20 3C CE
ldx #$FF ; CPU:$C052 PRG:0052 A2 FF
txs ; CPU:$C054 PRG:0054 9A
;===============================================================================
; Routine: ClearRamAndOam
; Global: The routine calls PpuMaskSetup.
; Local: Executes 4 instructions: calls PpuMaskSetup; loads A with $00; loads X
; with $00.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
ClearRamAndOam:
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: SubCC05D_OnNonzero
; Global: The routine calls VramWrite, ClearOamRoutine and VramPtrWrite, writes the
; PPUCTRL and PPUMASK registers.
; Local: Executes 23 instructions: stores A to Zp00,x; stores A to $0100,x;
; loads A with $F4; stores A to $0200,x; loads A with $00; stores A
; to $0300,x; and 17 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUCTRL and PPUMASK
; registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC05D_OnNonzero:
sta Zp00,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 SubCC05D_OnNonzero ; CPU:$C076 PRG:0076 D0 E5
lda #$10 ; CPU:$C078 PRG:0078 A9 10
sta PPUCTRL ; CPU:$C07A PRG:007A 8D 00 20
sta ZpEF ; CPU:$C07D PRG:007D 85 EF
lda #$00 ; CPU:$C07F PRG:007F A9 00
sta PPUMASK ; CPU:$C081 PRG:0081 8D 01 20
sta ZpEE ; 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 VramWrite ; CPU:$C08C PRG:008C 20 EE CD
jsr ClearOamRoutine ; CPU:$C08F PRG:008F 20 74 C1
jsr VramPtrWrite ; CPU:$C092 PRG:0092 20 3F CD
; ---- data $C095-$C096 (2 bytes) ----
MasterPaletteStreamPtr:
.byte $06, $CF ; CPU:$C095 PRG:0095 06 CF
;===============================================================================
; Routine: SubCC097
; Global: The routine calls PpuScrollLatch and VramPtrWrite.
; Local: Executes 2 instructions: calls PpuScrollLatch; calls VramPtrWrite.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC097:
jsr PpuScrollLatch ; CPU:$C097 PRG:0097 20 3C CE
jsr VramPtrWrite ; CPU:$C09A PRG:009A 20 3F CD
; ---- data $C09D-$C09E (2 bytes) ----
JoypadPanelScreenOnePtr:
.byte $2A, $CF ; CPU:$C09D PRG:009D 2A CF
;===============================================================================
; Routine: SubCC09F
; Global: The routine calls PpuScrollLatch, SetPpuMaskBits and SubCC17F, writes $0200,
; $0201, $0202 and $0203, writes the APUPULSE1CTRL, APUPULSE1SWEEP,
; APUPULSE1TIMERLO, APUPULSE1TIMERHI and 1 more registers.
; Local: Executes 26 instructions: calls PpuScrollLatch; loads A with $70; stores A
; to $0200; loads A with $35; stores A to $0201; loads A with $00;
; and 20 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0200, $0201 and $0202 changed.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC09F:
jsr PpuScrollLatch ; CPU:$C09F PRG:009F 20 3C CE
lda #$70 ; CPU:$C0A2 PRG:00A2 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 SetPpuMaskBits ; CPU:$C0CF PRG:00CF 20 39 CD
jsr SubCC17F_OnNonzero ; 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: EnableNmiAndStrobeControllers
; Global: The routine calls EnablePpuNmi and StrobeController2.
; Local: Executes 3 instructions: calls EnablePpuNmi; calls StrobeController2; loads X with
; $01.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
EnableNmiAndStrobeControllers:
jsr EnablePpuNmi ; CPU:$C0DF PRG:00DF 20 E2 CC
jsr StrobeController2 ; CPU:$C0E2 PRG:00E2 20 4F CC
ldx #$01 ; CPU:$C0E5 PRG:00E5 A2 01
;===============================================================================
; Routine: ScanControllerButtonBits
; Global: The routine calls ScanControllerButtonBits.
; Local: Executes 9 instructions: rotates Zp40,x left; rotates Zp40,x left;
; rotates Zp40,x left; branches on carry set to SubCC135; rotates
; Zp40,x left; branches on carry set to SubCC111; and 3 more
; instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
ScanControllerButtonBits:
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 SubCC135_Loop ; CPU:$C0ED PRG:00ED B0 46
rol Zp40,x ; CPU:$C0EF PRG:00EF 36 40
bcs SubCC111_Loop ; CPU:$C0F1 PRG:00F1 B0 1E
dex ; CPU:$C0F3 PRG:00F3 CA
bmi SubCC0F9_Loop ; CPU:$C0F4 PRG:00F4 30 03
jmp ScanControllerButtonBits ; CPU:$C0F6 PRG:00F6 4C E7 C0
;===============================================================================
; Routine: SubCC0F9_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 3 instructions: increments Zp54; branches on not equal to
; SubCC0FF; increments Zp53.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC0F9_Loop:
inc Zp54 ; CPU:$C0F9 PRG:00F9 E6 54
bne SubCC0FF_Loop ; CPU:$C0FB PRG:00FB D0 02
inc Zp53 ; CPU:$C0FD PRG:00FD E6 53
;===============================================================================
; Routine: SubCC0FF_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: loads A with $00; compares A with Zp54;
; branches on not equal to SubCC10B; loads A with $38; compares A
; with Zp53; branches on equal to SubCC10E.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC0FF_Loop:
lda #$00 ; CPU:$C0FF PRG:00FF A9 00
cmp Zp54 ; CPU:$C101 PRG:0101 C5 54
bne SubCC10B_Loop ; CPU:$C103 PRG:0103 D0 06
lda #$38 ; CPU:$C105 PRG:0105 A9 38
cmp Zp53 ; CPU:$C107 PRG:0107 C5 53
beq SubCC10E_Loop ; CPU:$C109 PRG:0109 F0 03
;===============================================================================
; Routine: SubCC10B_Loop
; Global: The routine calls EnableNmiAndStrobeControllers.
; Local: Executes 1 instruction: calls EnableNmiAndStrobeControllers.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC10B_Loop:
jmp EnableNmiAndStrobeControllers ; CPU:$C10B PRG:010B 4C DF C0
;===============================================================================
; Routine: SubCC10E_Loop
; Global: The routine calls ClearRamAndOam.
; Local: Executes 1 instruction: calls ClearRamAndOam.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC10E_Loop:
jmp ClearRamAndOam ; CPU:$C10E PRG:010E 4C 55 C0
;===============================================================================
; Routine: SubCC111_Loop
; Global: The routine calls EnableNmiAndStrobeControllers.
; Local: Executes 10 instructions: loads A with $70; compares A with Zp55;
; branches on equal to SubCC129; loads A with $88; compares A with
; Zp55; branches on equal to SubCC12F; and 4 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC111_Loop:
lda #$70 ; CPU:$C111 PRG:0111 A9 70
cmp Zp55 ; CPU:$C113 PRG:0113 C5 55
beq SubCC129_Loop ; CPU:$C115 PRG:0115 F0 12
lda #$88 ; CPU:$C117 PRG:0117 A9 88
cmp Zp55 ; CPU:$C119 PRG:0119 C5 55
beq SubCC12F_Loop ; CPU:$C11B PRG:011B F0 12
lda #$A0 ; CPU:$C11D PRG:011D A9 A0
cmp Zp55 ; CPU:$C11F PRG:011F C5 55
beq SubCC126_Loop ; CPU:$C121 PRG:0121 F0 03
jmp EnableNmiAndStrobeControllers ; CPU:$C123 PRG:0123 4C DF C0
;===============================================================================
; Routine: SubCC126_Loop
; Global: The routine calls ClearRamAndOam.
; Local: Executes 1 instruction: calls ClearRamAndOam.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC126_Loop:
jmp ClearRamAndOam ; CPU:$C126 PRG:0126 4C 55 C0
;===============================================================================
; Routine: SubCC129_Loop
; Global: The routine calls SubCC17F and ClearAuxRam.
; Local: Executes 2 instructions: calls SubCC17F; calls ClearAuxRam.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC129_Loop:
jsr SubCC17F_OnNonzero ; CPU:$C129 PRG:0129 20 7F C1
jmp ClearAuxRam ; CPU:$C12C PRG:012C 4C 03 CB
;===============================================================================
; Routine: SubCC12F_Loop
; Global: The routine calls SubCC17F and ClearMarkerRam.
; Local: Executes 2 instructions: calls SubCC17F; calls ClearMarkerRam.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC12F_Loop:
jsr SubCC17F_OnNonzero ; CPU:$C12F PRG:012F 20 7F C1
jmp ClearMarkerRam ; CPU:$C132 PRG:0132 4C 3F C2
;===============================================================================
; Routine: SubCC135_Loop
; Global: The routine calls ResetFrameCounter and EnableNmiAndStrobeControllers.
; Local: Executes 11 instructions: calls ResetFrameCounter; loads A with $70; compares
; A with Zp55; branches on equal to SubCC14D; loads A with $88;
; compares A with Zp55; and 5 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC135_Loop:
jsr ResetFrameCounter ; CPU:$C135 PRG:0135 20 B1 CA
lda #$70 ; CPU:$C138 PRG:0138 A9 70
cmp Zp55 ; CPU:$C13A PRG:013A C5 55
beq SubCC14D_Loop ; CPU:$C13C PRG:013C F0 0F
lda #$88 ; CPU:$C13E PRG:013E A9 88
cmp Zp55 ; CPU:$C140 PRG:0140 C5 55
beq SubCC152_Loop ; CPU:$C142 PRG:0142 F0 0E
lda #$A0 ; CPU:$C144 PRG:0144 A9 A0
cmp Zp55 ; CPU:$C146 PRG:0146 C5 55
beq SubCC157_Loop ; CPU:$C148 PRG:0148 F0 0D
jmp EnableNmiAndStrobeControllers ; CPU:$C14A PRG:014A 4C DF C0
;===============================================================================
; Routine: SubCC14D_Loop
; Global: The routine calls PlayTestTone.
; Local: Executes 2 instructions: loads A with $88; calls PlayTestTone.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC14D_Loop:
lda #$88 ; CPU:$C14D PRG:014D A9 88
jmp PlayTestTone ; CPU:$C14F PRG:014F 4C 5C C1
;===============================================================================
; Routine: SubCC152_Loop
; Global: The routine calls PlayTestTone.
; Local: Executes 2 instructions: loads A with $A0; calls PlayTestTone.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC152_Loop:
lda #$A0 ; CPU:$C152 PRG:0152 A9 A0
jmp PlayTestTone ; CPU:$C154 PRG:0154 4C 5C C1
;===============================================================================
; Routine: SubCC157_Loop
; Global: The routine calls PlayTestTone.
; Local: Executes 2 instructions: loads A with $70; calls PlayTestTone.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC157_Loop:
lda #$70 ; CPU:$C157 PRG:0157 A9 70
jmp PlayTestTone ; CPU:$C159 PRG:0159 4C 5C C1
;===============================================================================
; Routine: PlayTestTone
; Global: The routine calls SubCC17F and EnableNmiAndStrobeControllers, writes $0200, writes the
; APUSTATUS and APUPULSE1TIMERHI registers, reads the APUSTATUS
; register.
; Local: Executes 9 instructions: stores A to $0200; stores A to Zp55; loads A
; with $01; ORs A with the APUSTATUS register; stores A to the
; APUSTATUS register; loads A with $29; and 3 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0200 changed.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
PlayTestTone:
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 SubCC17F_OnNonzero ; CPU:$C16E PRG:016E 20 7F C1
jmp EnableNmiAndStrobeControllers ; CPU:$C171 PRG:0171 4C DF C0
;===============================================================================
; Routine: ClearOamRoutine
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 2 instructions: loads A with $F4; loads X with $00.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A and X, the N and Z flags, the OAM shadow.
;
;===============================================================================
ClearOamRoutine:
lda #$F4 ; CPU:$C174 PRG:0174 A9 F4
ldx #$00 ; CPU:$C176 PRG:0176 A2 00
;===============================================================================
; Routine: SubCC178_OnNonzero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: stores A to $0200,x; increments X; branches
; on not equal to SubCC178; returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; X, the N and Z flags, the OAM shadow.
;
;===============================================================================
SubCC178_OnNonzero:
sta $0200,x ; CPU:$C178 PRG:0178 9D 00 02
inx ; CPU:$C17B PRG:017B E8
bne SubCC178_OnNonzero ; CPU:$C17C PRG:017C D0 FA
rts ; CPU:$C17E PRG:017E 60
;===============================================================================
; Routine: SubCC17F_OnNonzero
; Global: The routine calls EnablePpuNmi and StrobeController2.
; Local: Executes 9 instructions: copies X into A; pushes A; calls EnablePpuNmi;
; calls StrobeController2; pulls A; copies A into X; and 3 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC17F_OnNonzero:
txa ; CPU:$C17F PRG:017F 8A
pha ; CPU:$C180 PRG:0180 48
jsr EnablePpuNmi ; CPU:$C181 PRG:0181 20 E2 CC
jsr StrobeController2 ; 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 SubCC17F_OnNonzero ; CPU:$C18D PRG:018D D0 F0
;===============================================================================
; Routine: SubCC18F_OnNonzero
; Global: The routine calls EnablePpuNmi and StrobeController2.
; Local: Executes 10 instructions: copies X into A; pushes A; calls EnablePpuNmi;
; calls StrobeController2; pulls A; copies A into X; and 4 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; A and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC18F_OnNonzero:
txa ; CPU:$C18F PRG:018F 8A
pha ; CPU:$C190 PRG:0190 48
jsr EnablePpuNmi ; CPU:$C191 PRG:0191 20 E2 CC
jsr StrobeController2 ; 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 SubCC18F_OnNonzero ; CPU:$C19D PRG:019D D0 F0
rts ; CPU:$C19F PRG:019F 60
;===============================================================================
; Routine: CopyMarkerSpriteTable1
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 1 instruction: loads X with $1F.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
CopyMarkerSpriteTable1:
ldx #$1F ; CPU:$C1A0 PRG:01A0 A2 1F
;===============================================================================
; Routine: SubCC1A2_OnNonnegative
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 5 instructions: loads A from $D6A5,x; stores A to $02E0,x;
; decrements X; branches on non-negative to SubCC1A2; loads X with
; $F0.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC1A2_OnNonnegative:
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 SubCC1A2_OnNonnegative ; CPU:$C1A9 PRG:01A9 10 F7
ldx #$F0 ; CPU:$C1AB PRG:01AB A2 F0
;===============================================================================
; Routine: SubCC1AD_OnNonzero
; Global: The routine calls EnablePpuNmi and StrobeController2, writes the APUSTATUS
; register.
; Local: Executes 15 instructions: calls EnablePpuNmi; copies X into A; pushes A;
; calls StrobeController2; loads A with $00; compares A with Zp40; and 9 more
; instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS register set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC1AD_OnNonzero:
jsr EnablePpuNmi ; CPU:$C1AD PRG:01AD 20 E2 CC
txa ; CPU:$C1B0 PRG:01B0 8A
pha ; CPU:$C1B1 PRG:01B1 48
jsr StrobeController2 ; CPU:$C1B2 PRG:01B2 20 4F CC
lda #$00 ; CPU:$C1B5 PRG:01B5 A9 00
cmp Zp40 ; CPU:$C1B7 PRG:01B7 C5 40
bne SubCC1CC_Loop ; CPU:$C1B9 PRG:01B9 D0 11
cmp Zp41 ; CPU:$C1BB PRG:01BB C5 41
bne SubCC1CC_Loop ; CPU:$C1BD PRG:01BD D0 0D
cmp Zp43 ; CPU:$C1BF PRG:01BF C5 43
bne SubCC1CC_Loop ; CPU:$C1C1 PRG:01C1 D0 09
cmp Zp44 ; CPU:$C1C3 PRG:01C3 C5 44
bne SubCC1CC_Loop ; CPU:$C1C5 PRG:01C5 D0 05
lda #$C0 ; CPU:$C1C7 PRG:01C7 A9 C0
sta APUSTATUS ; CPU:$C1C9 PRG:01C9 8D 15 40
;===============================================================================
; Routine: SubCC1CC_Loop
; Global: The routine calls EnablePpuNmi, StrobeController2, CountPressedButtons and ClearRamAndOam, writes
; the APUSTATUS register.
; Local: Executes 33 instructions: calls EnablePpuNmi; copies X into A; pushes A;
; calls StrobeController2; loads A with $00; compares A with Zp40; and 27 more
; instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS register set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC1CC_Loop:
ldy #$00 ; CPU:$C1CC PRG:01CC A0 00
ldx #$00 ; CPU:$C1CE PRG:01CE A2 00
jsr CountPressedButtons ; CPU:$C1D0 PRG:01D0 20 61 C3
ldy #$20 ; CPU:$C1D3 PRG:01D3 A0 20
inx ; CPU:$C1D5 PRG:01D5 E8
jsr CountPressedButtons ; 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 CountPressedButtons ; CPU:$C1DD PRG:01DD 20 61 C3
ldy #$60 ; CPU:$C1E0 PRG:01E0 A0 60
inx ; CPU:$C1E2 PRG:01E2 E8
jsr CountPressedButtons ; 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 SubCC1AD_OnNonzero ; CPU:$C1E9 PRG:01E9 D0 C2
jmp ClearRamAndOam ; CPU:$C1EB PRG:01EB 4C 55 C0
;===============================================================================
; Routine: CopyMarkerSpriteTable2
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 5 instructions: copies Y into A; pushes A; copies X into A;
; pushes A; loads X with $1F.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
CopyMarkerSpriteTable2:
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: SubCC1F4_OnNonnegative
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: loads A from $D6C5,x; stores A to $02E0,x;
; decrements X; branches on non-negative to SubCC1F4.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC1F4_OnNonnegative:
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 SubCC1F4_OnNonnegative ; CPU:$C1FB PRG:01FB 10 F7
;===============================================================================
; Routine: FindPressedButton
; Global: The routine calls EnablePpuNmi, StrobeController2 and FindPressedButton.
; Local: Executes 10 instructions: calls EnablePpuNmi; calls StrobeController2; pulls A;
; copies A into X; loads A with $00; compares A with Zp40,x; and 4
; more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
FindPressedButton:
jsr EnablePpuNmi ; CPU:$C1FD PRG:01FD 20 E2 CC
jsr StrobeController2 ; 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 SubCC210_Loop ; CPU:$C209 PRG:0209 F0 05
txa ; CPU:$C20B PRG:020B 8A
pha ; CPU:$C20C PRG:020C 48
jmp FindPressedButton ; CPU:$C20D PRG:020D 4C FD C1
;===============================================================================
; Routine: SubCC210_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: loads A with $00; stores A to Zp4E,x; copies
; X into A; pushes A; loads X with $1F; loads A with $F4.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A and Y, the N and Z flags, Zp4E, the OAM shadow.
;
;===============================================================================
SubCC210_Loop:
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: SubCC21A_OnNonnegative
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 17 instructions: stores A to $02E0,x; decrements X; branches
; on non-negative to SubCC21A; pulls A; copies A into X; pulls A; and
; 11 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; A, X and Y, the N and Z flags, the OAM shadow.
;
;===============================================================================
SubCC21A_OnNonnegative:
sta $02E0,x ; CPU:$C21A PRG:021A 9D E0 02
dex ; CPU:$C21D PRG:021D CA
bpl SubCC21A_OnNonnegative ; 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: ClearMarkerRam
; Global: The routine calls PpuMaskSetup.
; Local: Executes 3 instructions: calls PpuMaskSetup; loads X with $00; loads A
; with $FF.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
ClearMarkerRam:
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: SubCC246_OnNonzero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: stores A to $6000,x; increments X; compares
; X with $06; branches on not equal to SubCC246; loads A with $00;
; loads X with $00.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC246_OnNonzero:
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 SubCC246_OnNonzero ; CPU:$C24C PRG:024C D0 F8
lda #$00 ; CPU:$C24E PRG:024E A9 00
ldx #$00 ; CPU:$C250 PRG:0250 A2 00
;===============================================================================
; Routine: SubCC252_OnNonzero
; Global: The routine calls VramWrite, VramPtrWrite, PpuScrollLatch and PlayVramStream, writes
; $0300, writes the PPUCTRL and PPUMASK registers.
; Local: Executes 32 instructions: stores A to Zp00,x; stores A to $0100,x;
; loads A with $F4; stores A to $0200,x; loads A with $00; stores A
; to $0300,x; and 26 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $0300 changed.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC252_OnNonzero:
sta Zp00,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 SubCC252_OnNonzero ; CPU:$C26B PRG:026B D0 E5
lda #$10 ; CPU:$C26D PRG:026D A9 10
sta PPUCTRL ; CPU:$C26F PRG:026F 8D 00 20
sta ZpEF ; CPU:$C272 PRG:0272 85 EF
lda #$00 ; CPU:$C274 PRG:0274 A9 00
sta PPUMASK ; CPU:$C276 PRG:0276 8D 01 20
sta ZpEE ; 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 VramWrite ; CPU:$C281 PRG:0281 20 EE CD
jsr VramPtrWrite ; CPU:$C284 PRG:0284 20 3F CD
asl ZpCF ; CPU:$C287 PRG:0287 06 CF
jsr PpuScrollLatch ; CPU:$C289 PRG:0289 20 3C CE
jsr VramPtrWrite ; CPU:$C28C PRG:028C 20 3F CD
sbc ZpD1,x ; CPU:$C28F PRG:028F F5 D1
jsr PpuScrollLatch ; 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 PlayVramStream ; 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: SubCC2A7_OnNonzero
; Global: The routine calls SetPpuMaskBits, writes the APUPULSE1CTRL register.
; Local: Executes 28 instructions: loads A from $D4E3,x; stores A to $0200,x;
; decrements X; branches on not equal to SubCC2A7; loads A from
; $D4E3,x; stores A to $0200,x; and 22 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUPULSE1CTRL register
; set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC2A7_OnNonzero:
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 SubCC2A7_OnNonzero ; 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 SetPpuMaskBits ; CPU:$C2E1 PRG:02E1 20 39 CD
;===============================================================================
; Routine: UpdateButtonSprites
; Global: The routine calls EnablePpuNmi, StrobeController2 and CheckAnyButtonPressed.
; Local: Executes 7 instructions: calls EnablePpuNmi; calls StrobeController2; increments
; Zp6A; loads A with $0F; compares A with Zp6A; branches on equal to
; SubCC2F5; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
UpdateButtonSprites:
jsr EnablePpuNmi ; CPU:$C2E4 PRG:02E4 20 E2 CC
jsr StrobeController2 ; 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 SubCC2F5_Loop ; CPU:$C2F0 PRG:02F0 F0 03
jmp CheckAnyButtonPressed ; CPU:$C2F2 PRG:02F2 4C FE C2
;===============================================================================
; Routine: SubCC2F5_Loop
; Global: The routine calls SubCC524, SubCC7D7 and ResetButtonCounters.
; Local: Executes 3 instructions: calls SubCC524; calls SubCC7D7; calls
; ResetButtonCounters.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC2F5_Loop:
jsr SubCC524 ; CPU:$C2F5 PRG:02F5 20 24 C5
jsr SubCC7D7 ; CPU:$C2F8 PRG:02F8 20 D7 C7
jsr ResetButtonCounters ; CPU:$C2FB PRG:02FB 20 8A CA
;===============================================================================
; Routine: CheckAnyButtonPressed
; Global: The routine writes the APUSTATUS register.
; Local: Executes 11 instructions: loads A with $00; compares A with Zp40;
; branches on not equal to SubCC315; compares A with Zp41; branches
; on not equal to SubCC315; compares A with Zp43; and 5 more
; instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS register set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
CheckAnyButtonPressed:
lda #$00 ; CPU:$C2FE PRG:02FE A9 00
cmp Zp40 ; CPU:$C300 PRG:0300 C5 40
bne SubCC315_Loop ; CPU:$C302 PRG:0302 D0 11
cmp Zp41 ; CPU:$C304 PRG:0304 C5 41
bne SubCC315_Loop ; CPU:$C306 PRG:0306 D0 0D
cmp Zp43 ; CPU:$C308 PRG:0308 C5 43
bne SubCC315_Loop ; CPU:$C30A PRG:030A D0 09
cmp Zp44 ; CPU:$C30C PRG:030C C5 44
bne SubCC315_Loop ; CPU:$C30E PRG:030E D0 05
lda #$C0 ; CPU:$C310 PRG:0310 A9 C0
sta APUSTATUS ; CPU:$C312 PRG:0312 8D 15 40
;===============================================================================
; Routine: SubCC315_Loop
; Global: The routine calls CountPressedButtons and CopyMarkerSpriteTable1.
; Local: Executes 23 instructions: loads Y with $00; loads X with $00; calls
; CountPressedButtons; loads Y with $20; increments X; calls CountPressedButtons; and 17
; more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC315_Loop:
ldy #$00 ; CPU:$C315 PRG:0315 A0 00
ldx #$00 ; CPU:$C317 PRG:0317 A2 00
jsr CountPressedButtons ; CPU:$C319 PRG:0319 20 61 C3
ldy #$20 ; CPU:$C31C PRG:031C A0 20
inx ; CPU:$C31E PRG:031E E8
jsr CountPressedButtons ; 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 CountPressedButtons ; CPU:$C326 PRG:0326 20 61 C3
ldy #$60 ; CPU:$C329 PRG:0329 A0 60
inx ; CPU:$C32B PRG:032B E8
jsr CountPressedButtons ; CPU:$C32C PRG:032C 20 61 C3
lda #$FF ; CPU:$C32F PRG:032F A9 FF
cmp Zp4E ; CPU:$C331 PRG:0331 C5 4E
bne SubCC344_Loop ; CPU:$C333 PRG:0333 D0 0F
cmp Zp4F ; CPU:$C335 PRG:0335 C5 4F
bne SubCC344_Loop ; CPU:$C337 PRG:0337 D0 0B
cmp Zp51 ; CPU:$C339 PRG:0339 C5 51
bne SubCC344_Loop ; CPU:$C33B PRG:033B D0 07
cmp Zp52 ; CPU:$C33D PRG:033D C5 52
bne SubCC344_Loop ; CPU:$C33F PRG:033F D0 03
jmp CopyMarkerSpriteTable1 ; CPU:$C341 PRG:0341 4C A0 C1
;===============================================================================
; Routine: SubCC344_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 3 instructions: increments Zp54; branches on not equal to
; SubCC34A; increments Zp53.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC344_Loop:
inc Zp54 ; CPU:$C344 PRG:0344 E6 54
bne SubCC34A_Loop ; CPU:$C346 PRG:0346 D0 02
inc Zp53 ; CPU:$C348 PRG:0348 E6 53
;===============================================================================
; Routine: SubCC34A_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: loads A with $00; compares A with Zp54;
; branches on not equal to SubCC356; loads A with $38; compares A
; with Zp53; branches on equal to SubCC35E.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC34A_Loop:
lda #$00 ; CPU:$C34A PRG:034A A9 00
cmp Zp54 ; CPU:$C34C PRG:034C C5 54
bne SubCC356_Loop ; CPU:$C34E PRG:034E D0 06
lda #$38 ; CPU:$C350 PRG:0350 A9 38
cmp Zp53 ; CPU:$C352 PRG:0352 C5 53
beq SubCC35E_Loop ; CPU:$C354 PRG:0354 F0 08
;===============================================================================
; Routine: SubCC356_Loop
; Global: The routine calls UpdateButtonSprites, writes $0302.
; Local: Executes 3 instructions: loads A with $22; stores A to $0302; calls
; UpdateButtonSprites.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0302 changed.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC356_Loop:
lda #$22 ; CPU:$C356 PRG:0356 A9 22
sta $0302 ; CPU:$C358 PRG:0358 8D 02 03
jmp UpdateButtonSprites ; CPU:$C35B PRG:035B 4C E4 C2
;===============================================================================
; Routine: SubCC35E_Loop
; Global: The routine calls ClearRamAndOam.
; Local: Executes 1 instruction: calls ClearRamAndOam.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC35E_Loop:
jmp ClearRamAndOam ; CPU:$C35E PRG:035E 4C 55 C0
;===============================================================================
; Routine: CountPressedButtons
; Global: The routine calls ShiftMarkerBitToOam and SubCC380.
; Local: Executes 11 instructions: loads A from Zp40,x; pushes A; calls
; ShiftMarkerBitToOam; rotates Zp40,x left; branches on carry clear to SubCC377;
; rotates Zp40,x right; and 5 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
CountPressedButtons:
lda Zp40,x ; CPU:$C361 PRG:0361 B5 40
pha ; CPU:$C363 PRG:0363 48
jsr ShiftMarkerBitToOam ; CPU:$C364 PRG:0364 20 B8 CA
rol Zp40,x ; CPU:$C367 PRG:0367 36 40
bcc SubCC377_Loop ; 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 SubCC380_Loop ; CPU:$C36F PRG:036F B0 0F
inc Zp56,x ; CPU:$C371 PRG:0371 F6 56
sec ; CPU:$C373 PRG:0373 38
jmp SubCC380_Loop ; CPU:$C374 PRG:0374 4C 80 C3
;===============================================================================
; Routine: SubCC377_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 5 instructions: rotates Zp40,x right; rotates Zp65,x left;
; branches on carry clear to SubCC380; increments Zp56,x; clears the
; carry flag.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC377_Loop:
ror Zp40,x ; CPU:$C377 PRG:0377 76 40
rol Zp65,x ; CPU:$C379 PRG:0379 36 65
bcc SubCC380_Loop ; CPU:$C37B PRG:037B 90 03
inc Zp56,x ; CPU:$C37D PRG:037D F6 56
clc ; CPU:$C37F PRG:037F 18
;===============================================================================
; Routine: SubCC380_Loop
; Global: The routine writes the APUSTATUS, APUPULSE1TIMERLO and
; APUPULSE1TIMERHI registers, reads the APUSTATUS register.
; Local: Executes 12 instructions: rotates Zp65,x right; rotates Zp40,x left;
; branches on carry clear to SubCC3AA; loads A with $01; ANDs A with
; the APUSTATUS register; branches on not equal to SubCC39C; and 6
; more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS,
; APUPULSE1TIMERLO and APUPULSE1TIMERHI registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC380_Loop:
ror Zp65,x ; CPU:$C380 PRG:0380 76 65
rol Zp40,x ; CPU:$C382 PRG:0382 36 40
bcc SubCC3AA_Loop ; CPU:$C384 PRG:0384 90 24
lda #$01 ; CPU:$C386 PRG:0386 A9 01
and APUSTATUS ; CPU:$C388 PRG:0388 2D 15 40
bne SubCC39C_Loop ; 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: SubCC39C_Loop
; Global: The routine calls ResetFrameCounter.
; Local: Executes 6 instructions: loads A with $02; stores A to $0202,y; loads
; A with $80; ORs A with Zp4E,x; stores A to Zp4E,x; calls ResetFrameCounter.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC39C_Loop:
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 ResetFrameCounter ; CPU:$C3A7 PRG:03A7 20 B1 CA
;===============================================================================
; Routine: SubCC3AA_Loop
; Global: The routine calls SubCC3C7.
; Local: Executes 9 instructions: rotates Zp40,x left; branches on carry clear
; to SubCC3BC; rotates Zp40,x right; rotates Zp65,x left; rotates
; Zp65,x left; branches on carry set to SubCC3C7; and 3 more
; instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC3AA_Loop:
rol Zp40,x ; CPU:$C3AA PRG:03AA 36 40
bcc SubCC3BC_Loop ; 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 SubCC3C7_Loop ; CPU:$C3B4 PRG:03B4 B0 11
inc Zp5B,x ; CPU:$C3B6 PRG:03B6 F6 5B
sec ; CPU:$C3B8 PRG:03B8 38
jmp SubCC3C7_Loop ; CPU:$C3B9 PRG:03B9 4C C7 C3
;===============================================================================
; Routine: SubCC3BC_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: rotates Zp40,x right; rotates Zp65,x left;
; rotates Zp65,x left; branches on carry clear to SubCC3C7;
; increments Zp5B,x; clears the carry flag.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC3BC_Loop:
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 SubCC3C7_Loop ; CPU:$C3C2 PRG:03C2 90 03
inc Zp5B,x ; CPU:$C3C4 PRG:03C4 F6 5B
clc ; CPU:$C3C6 PRG:03C6 18
;===============================================================================
; Routine: SubCC3C7_Loop
; Global: The routine writes the APUSTATUS, APUPULSE1TIMERLO and
; APUPULSE1TIMERHI registers, reads the APUSTATUS register.
; Local: Executes 13 instructions: rotates Zp65,x right; rotates Zp65,x right;
; rotates Zp40,x left; branches on carry clear to SubCC3F3; loads A
; with $01; ANDs A with the APUSTATUS register; and 7 more
; instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS,
; APUPULSE1TIMERLO and APUPULSE1TIMERHI registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC3C7_Loop:
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 SubCC3F3_Loop ; CPU:$C3CD PRG:03CD 90 24
lda #$01 ; CPU:$C3CF PRG:03CF A9 01
and APUSTATUS ; CPU:$C3D1 PRG:03D1 2D 15 40
bne SubCC3E5_Loop ; 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: SubCC3E5_Loop
; Global: The routine calls ResetFrameCounter.
; Local: Executes 6 instructions: loads A with $02; stores A to $0206,y; loads
; A with $40; ORs A with Zp4E,x; stores A to Zp4E,x; calls ResetFrameCounter.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC3E5_Loop:
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 ResetFrameCounter ; CPU:$C3F0 PRG:03F0 20 B1 CA
;===============================================================================
; Routine: SubCC3F3_Loop
; Global: The routine writes the APUSTATUS, APUPULSE1TIMERLO and
; APUPULSE1TIMERHI registers, reads the APUSTATUS register.
; Local: Executes 11 instructions: rotates Zp40,x left; branches on carry
; clear to SubCC41B; loads A with $01; ANDs A with the APUSTATUS
; register; branches on not equal to SubCC40D; loads A with $01; and
; 5 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS,
; APUPULSE1TIMERLO and APUPULSE1TIMERHI registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC3F3_Loop:
rol Zp40,x ; CPU:$C3F3 PRG:03F3 36 40
bcc SubCC41B_Loop ; CPU:$C3F5 PRG:03F5 90 24
lda #$01 ; CPU:$C3F7 PRG:03F7 A9 01
and APUSTATUS ; CPU:$C3F9 PRG:03F9 2D 15 40
bne SubCC40D_Loop ; 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: SubCC40D_Loop
; Global: The routine calls ResetFrameCounter.
; Local: Executes 6 instructions: loads A with $02; stores A to $020E,y; loads
; A with $20; ORs A with Zp4E,x; stores A to Zp4E,x; calls ResetFrameCounter.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC40D_Loop:
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 ResetFrameCounter ; CPU:$C418 PRG:0418 20 B1 CA
;===============================================================================
; Routine: SubCC41B_Loop
; Global: The routine calls SubCC43C.
; Local: Executes 10 instructions: rotates Zp40,x left; branches on carry
; clear to SubCC42F; rotates Zp40,x right; rotates Zp65,x left;
; rotates Zp65,x left; rotates Zp65,x left; and 4 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC41B_Loop:
rol Zp40,x ; CPU:$C41B PRG:041B 36 40
bcc SubCC42F_Loop ; 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 SubCC43C_Loop ; CPU:$C427 PRG:0427 B0 13
inc Zp60,x ; CPU:$C429 PRG:0429 F6 60
sec ; CPU:$C42B PRG:042B 38
jmp SubCC43C_Loop ; CPU:$C42C PRG:042C 4C 3C C4
;===============================================================================
; Routine: SubCC42F_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 7 instructions: rotates Zp40,x right; rotates Zp65,x left;
; rotates Zp65,x left; rotates Zp65,x left; branches on carry clear
; to SubCC43C; increments Zp60,x; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC42F_Loop:
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 SubCC43C_Loop ; CPU:$C437 PRG:0437 90 03
inc Zp60,x ; CPU:$C439 PRG:0439 F6 60
clc ; CPU:$C43B PRG:043B 18
;===============================================================================
; Routine: SubCC43C_Loop
; Global: The routine writes the APUSTATUS, APUPULSE1TIMERLO and
; APUPULSE1TIMERHI registers, reads the APUSTATUS register.
; Local: Executes 14 instructions: rotates Zp65,x right; rotates Zp65,x right;
; rotates Zp65,x right; rotates Zp40,x left; branches on carry clear
; to SubCC46A; loads A with $01; and 8 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS,
; APUPULSE1TIMERLO and APUPULSE1TIMERHI registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC43C_Loop:
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 SubCC46A_Loop ; CPU:$C444 PRG:0444 90 24
lda #$01 ; CPU:$C446 PRG:0446 A9 01
and APUSTATUS ; CPU:$C448 PRG:0448 2D 15 40
bne SubCC45C_Loop ; 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: SubCC45C_Loop
; Global: The routine calls ResetFrameCounter.
; Local: Executes 6 instructions: loads A with $02; stores A to $020A,y; loads
; A with $10; ORs A with Zp4E,x; stores A to Zp4E,x; calls ResetFrameCounter.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC45C_Loop:
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 ResetFrameCounter ; CPU:$C467 PRG:0467 20 B1 CA
;===============================================================================
; Routine: SubCC46A_Loop
; Global: The routine writes the APUSTATUS, APUPULSE1TIMERLO and
; APUPULSE1TIMERHI registers, reads the APUSTATUS register.
; Local: Executes 11 instructions: rotates Zp40,x left; branches on carry
; clear to SubCC492; loads A with $01; ANDs A with the APUSTATUS
; register; branches on not equal to SubCC484; loads A with $01; and
; 5 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS,
; APUPULSE1TIMERLO and APUPULSE1TIMERHI registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC46A_Loop:
rol Zp40,x ; CPU:$C46A PRG:046A 36 40
bcc SubCC492_Loop ; CPU:$C46C PRG:046C 90 24
lda #$01 ; CPU:$C46E PRG:046E A9 01
and APUSTATUS ; CPU:$C470 PRG:0470 2D 15 40
bne SubCC484_Loop ; 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: SubCC484_Loop
; Global: The routine calls ResetFrameCounter.
; Local: Executes 6 instructions: loads A with $02; stores A to $0212,y; loads
; A with $08; ORs A with Zp4E,x; stores A to Zp4E,x; calls ResetFrameCounter.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC484_Loop:
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 ResetFrameCounter ; CPU:$C48F PRG:048F 20 B1 CA
;===============================================================================
; Routine: SubCC492_Loop
; Global: The routine writes the APUSTATUS, APUPULSE1TIMERLO and
; APUPULSE1TIMERHI registers, reads the APUSTATUS register.
; Local: Executes 11 instructions: rotates Zp40,x left; branches on carry
; clear to SubCC4BA; loads A with $01; ANDs A with the APUSTATUS
; register; branches on not equal to SubCC4AC; loads A with $01; and
; 5 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS,
; APUPULSE1TIMERLO and APUPULSE1TIMERHI registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC492_Loop:
rol Zp40,x ; CPU:$C492 PRG:0492 36 40
bcc SubCC4BA_Loop ; CPU:$C494 PRG:0494 90 24
lda #$01 ; CPU:$C496 PRG:0496 A9 01
and APUSTATUS ; CPU:$C498 PRG:0498 2D 15 40
bne SubCC4AC_Loop ; 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: SubCC4AC_Loop
; Global: The routine calls ResetFrameCounter.
; Local: Executes 6 instructions: loads A with $02; stores A to $0216,y; loads
; A with $04; ORs A with Zp4E,x; stores A to Zp4E,x; calls ResetFrameCounter.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC4AC_Loop:
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 ResetFrameCounter ; CPU:$C4B7 PRG:04B7 20 B1 CA
;===============================================================================
; Routine: SubCC4BA_Loop
; Global: The routine writes the APUSTATUS, APUPULSE1TIMERLO and
; APUPULSE1TIMERHI registers, reads the APUSTATUS register.
; Local: Executes 11 instructions: rotates Zp40,x left; branches on carry
; clear to SubCC4E2; loads A with $01; ANDs A with the APUSTATUS
; register; branches on not equal to SubCC4D4; loads A with $01; and
; 5 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS,
; APUPULSE1TIMERLO and APUPULSE1TIMERHI registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC4BA_Loop:
rol Zp40,x ; CPU:$C4BA PRG:04BA 36 40
bcc SubCC4E2_Loop ; CPU:$C4BC PRG:04BC 90 24
lda #$01 ; CPU:$C4BE PRG:04BE A9 01
and APUSTATUS ; CPU:$C4C0 PRG:04C0 2D 15 40
bne SubCC4D4_Loop ; 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: SubCC4D4_Loop
; Global: The routine calls ResetFrameCounter.
; Local: Executes 6 instructions: loads A with $02; stores A to $021A,y; loads
; A with $02; ORs A with Zp4E,x; stores A to Zp4E,x; calls ResetFrameCounter.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC4D4_Loop:
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 ResetFrameCounter ; CPU:$C4DF PRG:04DF 20 B1 CA
;===============================================================================
; Routine: SubCC4E2_Loop
; Global: The routine writes the APUSTATUS, APUPULSE1TIMERLO and
; APUPULSE1TIMERHI registers, reads the APUSTATUS register.
; Local: Executes 11 instructions: rotates Zp40,x left; branches on carry
; clear to SubCC50A; loads A with $01; ANDs A with the APUSTATUS
; register; branches on not equal to SubCC4FC; loads A with $01; and
; 5 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS,
; APUPULSE1TIMERLO and APUPULSE1TIMERHI registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC4E2_Loop:
rol Zp40,x ; CPU:$C4E2 PRG:04E2 36 40
bcc SubCC50A_Loop ; CPU:$C4E4 PRG:04E4 90 24
lda #$01 ; CPU:$C4E6 PRG:04E6 A9 01
and APUSTATUS ; CPU:$C4E8 PRG:04E8 2D 15 40
bne SubCC4FC_Loop ; 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: SubCC4FC_Loop
; Global: The routine calls ResetFrameCounter.
; Local: Executes 6 instructions: loads A with $02; stores A to $021E,y; loads
; A with $01; ORs A with Zp4E,x; stores A to Zp4E,x; calls ResetFrameCounter.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC4FC_Loop:
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 ResetFrameCounter ; CPU:$C507 PRG:0507 20 B1 CA
;===============================================================================
; Routine: SubCC50A_Loop
; Global: The routine calls SubCC523.
; Local: Executes 11 instructions: pulls A; stores A to Zp40,x; loads A with
; $0C; ANDs A with Zp40,x; compares A with $0C; branches on equal to
; SubCC520; and 5 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC50A_Loop:
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 SubCC520_Loop ; 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 SubCC520_Loop ; CPU:$C51B PRG:051B F0 03
jmp SubCC523 ; CPU:$C51D PRG:051D 4C 23 C5
;===============================================================================
; Routine: SubCC520_Loop
; Global: The routine calls CopyMarkerSpriteTable2.
; Local: Executes 1 instruction: calls CopyMarkerSpriteTable2.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCC520_Loop:
jsr CopyMarkerSpriteTable2 ; CPU:$C520 PRG:0520 20 EE C1
;===============================================================================
; Routine: SubCC523
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 1 instruction: returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; nothing.
;
;===============================================================================
SubCC523:
rts ; CPU:$C523 PRG:0523 60
;===============================================================================
; Routine: SubCC524
; Global: The routine calls SubCC597, writes $028D, $0289, $0285 and $0281.
; Local: Executes 31 instructions: loads A from Zp60; compares A with $04;
; branches on negative to SubCC564; loads A from Zp60; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $028D, $0289 and $0285
; changed.
; Clobbers:
; A, the N, Z, C and V flags, the OAM shadow and the RAM fields it
; writes.
;
;===============================================================================
SubCC524:
lda Zp60 ; CPU:$C524 PRG:0524 A5 60
cmp #$04 ; CPU:$C526 PRG:0526 C9 04
bmi SubCC564_Loop ; 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 SubCC579_Loop ; 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 SubCC58B_Loop ; 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 SubCC597 ; CPU:$C561 PRG:0561 4C 97 C5
;===============================================================================
; Routine: SubCC564_Loop
; Global: The routine calls SubCC597, writes $028D, $0289, $0285 and $0281.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp60; stores A
; to $028D; loads A with $30; stores A to $0289; stores A to $0285;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $028D, $0289 and $0285 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp56, Zp57, Zp5B, Zp5C, Zp61, the OAM
; shadow.
;
;===============================================================================
SubCC564_Loop:
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 SubCC597 ; CPU:$C576 PRG:0576 4C 97 C5
;===============================================================================
; Routine: SubCC579_Loop
; Global: The routine calls SubCC597, writes $0289, $0285 and $0281.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp60; stores A
; to $0289; loads A with $30; stores A to $0285; stores A to $0281;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0289, $0285 and $0281 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp56, Zp57, Zp5B, Zp5C, Zp61, the OAM
; shadow.
;
;===============================================================================
SubCC579_Loop:
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 SubCC597 ; CPU:$C588 PRG:0588 4C 97 C5
;===============================================================================
; Routine: SubCC58B_Loop
; Global: The routine writes $0285 and $0281.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp60; stores A
; to $0285; loads A with $30; stores A to $0281.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0285 and $0281 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp56, Zp57, Zp5B, Zp5C, Zp61, the OAM
; shadow.
;
;===============================================================================
SubCC58B_Loop:
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: SubCC597
; Global: The routine calls SubCC60A, writes $029D, $0299, $0295 and $0291.
; Local: Executes 31 instructions: loads A from Zp5B; compares A with $04;
; branches on negative to SubCC5D7; loads A from Zp5B; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $029D, $0299 and $0295
; changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp56, Zp57, Zp5B, Zp5C, Zp61, the OAM
; shadow.
;
;===============================================================================
SubCC597:
lda Zp5B ; CPU:$C597 PRG:0597 A5 5B
cmp #$04 ; CPU:$C599 PRG:0599 C9 04
bmi SubCC5D7_Loop ; 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 SubCC5EC_Loop ; 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 SubCC5FE_Loop ; 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 SubCC60A ; CPU:$C5D4 PRG:05D4 4C 0A C6
;===============================================================================
; Routine: SubCC5D7_Loop
; Global: The routine calls SubCC60A, writes $029D, $0299, $0295 and $0291.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp5B; stores A
; to $029D; loads A with $30; stores A to $0299; stores A to $0295;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $029D, $0299 and $0295 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp56, Zp57, Zp5C, Zp61, the OAM shadow.
;
;===============================================================================
SubCC5D7_Loop:
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 SubCC60A ; CPU:$C5E9 PRG:05E9 4C 0A C6
;===============================================================================
; Routine: SubCC5EC_Loop
; Global: The routine calls SubCC60A, writes $0299, $0295 and $0291.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp5B; stores A
; to $0299; loads A with $30; stores A to $0295; stores A to $0291;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0299, $0295 and $0291 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp56, Zp57, Zp5C, Zp61, the OAM shadow.
;
;===============================================================================
SubCC5EC_Loop:
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 SubCC60A ; CPU:$C5FB PRG:05FB 4C 0A C6
;===============================================================================
; Routine: SubCC5FE_Loop
; Global: The routine writes $0295 and $0291.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp5B; stores A
; to $0295; loads A with $30; stores A to $0291.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0295 and $0291 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp56, Zp57, Zp5C, Zp61, the OAM shadow.
;
;===============================================================================
SubCC5FE_Loop:
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: SubCC60A
; Global: The routine calls SubCC67D, writes $02AD, $02A9, $02A5 and $02A1.
; Local: Executes 31 instructions: loads A from Zp56; compares A with $04;
; branches on negative to SubCC64A; loads A from Zp56; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $02AD, $02A9 and $02A5
; changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp56, Zp57, Zp5C, Zp61, the OAM shadow.
;
;===============================================================================
SubCC60A:
lda Zp56 ; CPU:$C60A PRG:060A A5 56
cmp #$04 ; CPU:$C60C PRG:060C C9 04
bmi SubCC64A_Loop ; 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 SubCC65F_Loop ; 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 SubCC671_Loop ; 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 SubCC67D ; CPU:$C647 PRG:0647 4C 7D C6
;===============================================================================
; Routine: SubCC64A_Loop
; Global: The routine calls SubCC67D, writes $02AD, $02A9, $02A5 and $02A1.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp56; stores A
; to $02AD; loads A with $30; stores A to $02A9; stores A to $02A5;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02AD, $02A9 and $02A5 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, Zp5C, Zp61, the OAM shadow.
;
;===============================================================================
SubCC64A_Loop:
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 SubCC67D ; CPU:$C65C PRG:065C 4C 7D C6
;===============================================================================
; Routine: SubCC65F_Loop
; Global: The routine calls SubCC67D, writes $02A9, $02A5 and $02A1.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp56; stores A
; to $02A9; loads A with $30; stores A to $02A5; stores A to $02A1;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02A9, $02A5 and $02A1 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, Zp5C, Zp61, the OAM shadow.
;
;===============================================================================
SubCC65F_Loop:
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 SubCC67D ; CPU:$C66E PRG:066E 4C 7D C6
;===============================================================================
; Routine: SubCC671_Loop
; Global: The routine writes $02A5 and $02A1.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp56; stores A
; to $02A5; loads A with $30; stores A to $02A1.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02A5 and $02A1 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, Zp5C, Zp61, the OAM shadow.
;
;===============================================================================
SubCC671_Loop:
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: SubCC67D
; Global: The routine calls SubCC6F0, writes $02BD, $02B9, $02B5 and $02B1.
; Local: Executes 31 instructions: loads A from Zp61; compares A with $04;
; branches on negative to SubCC6BD; loads A from Zp61; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $02BD, $02B9 and $02B5
; changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, Zp5C, Zp61, the OAM shadow.
;
;===============================================================================
SubCC67D:
lda Zp61 ; CPU:$C67D PRG:067D A5 61
cmp #$04 ; CPU:$C67F PRG:067F C9 04
bmi SubCC6BD_Loop ; 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 SubCC6D2_Loop ; 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 SubCC6E4_Loop ; 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 SubCC6F0 ; CPU:$C6BA PRG:06BA 4C F0 C6
;===============================================================================
; Routine: SubCC6BD_Loop
; Global: The routine calls SubCC6F0, writes $02BD, $02B9, $02B5 and $02B1.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp61; stores A
; to $02BD; loads A with $30; stores A to $02B9; stores A to $02B5;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02BD, $02B9 and $02B5 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, Zp5C, the OAM shadow.
;
;===============================================================================
SubCC6BD_Loop:
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 SubCC6F0 ; CPU:$C6CF PRG:06CF 4C F0 C6
;===============================================================================
; Routine: SubCC6D2_Loop
; Global: The routine calls SubCC6F0, writes $02B9, $02B5 and $02B1.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp61; stores A
; to $02B9; loads A with $30; stores A to $02B5; stores A to $02B1;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02B9, $02B5 and $02B1 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, Zp5C, the OAM shadow.
;
;===============================================================================
SubCC6D2_Loop:
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 SubCC6F0 ; CPU:$C6E1 PRG:06E1 4C F0 C6
;===============================================================================
; Routine: SubCC6E4_Loop
; Global: The routine writes $02B5 and $02B1.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp61; stores A
; to $02B5; loads A with $30; stores A to $02B1.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02B5 and $02B1 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, Zp5C, the OAM shadow.
;
;===============================================================================
SubCC6E4_Loop:
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: SubCC6F0
; Global: The routine calls SubCC763, writes $02CD, $02C9, $02C5 and $02C1.
; Local: Executes 31 instructions: loads A from Zp5C; compares A with $04;
; branches on negative to SubCC730; loads A from Zp5C; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $02CD, $02C9 and $02C5
; changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, Zp5C, the OAM shadow.
;
;===============================================================================
SubCC6F0:
lda Zp5C ; CPU:$C6F0 PRG:06F0 A5 5C
cmp #$04 ; CPU:$C6F2 PRG:06F2 C9 04
bmi SubCC730_Loop ; 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 SubCC745_Loop ; 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 SubCC757_Loop ; 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 SubCC763 ; CPU:$C72D PRG:072D 4C 63 C7
;===============================================================================
; Routine: SubCC730_Loop
; Global: The routine calls SubCC763, writes $02CD, $02C9, $02C5 and $02C1.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp5C; stores A
; to $02CD; loads A with $30; stores A to $02C9; stores A to $02C5;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02CD, $02C9 and $02C5 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, the OAM shadow.
;
;===============================================================================
SubCC730_Loop:
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 SubCC763 ; CPU:$C742 PRG:0742 4C 63 C7
;===============================================================================
; Routine: SubCC745_Loop
; Global: The routine calls SubCC763, writes $02C9, $02C5 and $02C1.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp5C; stores A
; to $02C9; loads A with $30; stores A to $02C5; stores A to $02C1;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02C9, $02C5 and $02C1 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, the OAM shadow.
;
;===============================================================================
SubCC745_Loop:
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 SubCC763 ; CPU:$C754 PRG:0754 4C 63 C7
;===============================================================================
; Routine: SubCC757_Loop
; Global: The routine writes $02C5 and $02C1.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp5C; stores A
; to $02C5; loads A with $30; stores A to $02C1.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02C5 and $02C1 changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, the OAM shadow.
;
;===============================================================================
SubCC757_Loop:
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: SubCC763
; Global: The routine calls SubCC7D6, writes $02DD, $02D9, $02D5 and $02D1.
; Local: Executes 31 instructions: loads A from Zp57; compares A with $04;
; branches on negative to SubCC7A3; loads A from Zp57; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $02DD, $02D9 and $02D5
; changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp57, the OAM shadow.
;
;===============================================================================
SubCC763:
lda Zp57 ; CPU:$C763 PRG:0763 A5 57
cmp #$04 ; CPU:$C765 PRG:0765 C9 04
bmi SubCC7A3_Loop ; 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 SubCC7B8_Loop ; 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 SubCC7CA_Loop ; 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 SubCC7D6 ; CPU:$C7A0 PRG:07A0 4C D6 C7
;===============================================================================
; Routine: SubCC7A3_Loop
; Global: The routine calls SubCC7D6, writes $02DD, $02D9, $02D5 and $02D1.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp57; stores A
; to $02DD; loads A with $30; stores A to $02D9; stores A to $02D5;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02DD, $02D9 and $02D5 changed.
; Clobbers:
; A, the N and Z flags, the OAM shadow.
;
;===============================================================================
SubCC7A3_Loop:
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 SubCC7D6 ; CPU:$C7B5 PRG:07B5 4C D6 C7
;===============================================================================
; Routine: SubCC7B8_Loop
; Global: The routine calls SubCC7D6, writes $02D9, $02D5 and $02D1.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp57; stores A
; to $02D9; loads A with $30; stores A to $02D5; stores A to $02D1;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02D9, $02D5 and $02D1 changed.
; Clobbers:
; A, the N and Z flags, the OAM shadow.
;
;===============================================================================
SubCC7B8_Loop:
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 SubCC7D6 ; CPU:$C7C7 PRG:07C7 4C D6 C7
;===============================================================================
; Routine: SubCC7CA_Loop
; Global: The routine writes $02D5 and $02D1.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp57; stores A
; to $02D5; loads A with $30; stores A to $02D1.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $02D5 and $02D1 changed.
; Clobbers:
; A, the N and Z flags, the OAM shadow.
;
;===============================================================================
SubCC7CA_Loop:
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: SubCC7D6
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 1 instruction: returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; nothing.
;
;===============================================================================
SubCC7D6:
rts ; CPU:$C7D6 PRG:07D6 60
;===============================================================================
; Routine: SubCC7D7
; Global: The routine calls SubCC84A, writes $031D, $0315, $030D and $0305.
; Local: Executes 31 instructions: loads A from Zp63; compares A with $04;
; branches on negative to SubCC817; loads A from Zp63; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $031D, $0315 and $030D
; changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC7D7:
lda Zp63 ; CPU:$C7D7 PRG:07D7 A5 63
cmp #$04 ; CPU:$C7D9 PRG:07D9 C9 04
bmi SubCC817_Loop ; 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 SubCC82C_Loop ; 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 SubCC83E_Loop ; 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 SubCC84A ; CPU:$C814 PRG:0814 4C 4A C8
;===============================================================================
; Routine: SubCC817_Loop
; Global: The routine calls SubCC84A, writes $031D, $0315, $030D and $0305.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp63; stores A
; to $031D; loads A with $30; stores A to $0315; stores A to $030D;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $031D, $0315 and $030D changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC817_Loop:
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 SubCC84A ; CPU:$C829 PRG:0829 4C 4A C8
;===============================================================================
; Routine: SubCC82C_Loop
; Global: The routine calls SubCC84A, writes $0315, $030D and $0305.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp63; stores A
; to $0315; loads A with $30; stores A to $030D; stores A to $0305;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0315, $030D and $0305 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC82C_Loop:
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 SubCC84A ; CPU:$C83B PRG:083B 4C 4A C8
;===============================================================================
; Routine: SubCC83E_Loop
; Global: The routine writes $030D and $0305.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp63; stores A
; to $030D; loads A with $30; stores A to $0305.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $030D and $0305 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC83E_Loop:
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: SubCC84A
; Global: The routine calls SubCC8BD, writes $031F, $0317, $030F and $0307.
; Local: Executes 31 instructions: loads A from Zp5E; compares A with $04;
; branches on negative to SubCC88A; loads A from Zp5E; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $031F, $0317 and $030F
; changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC84A:
lda Zp5E ; CPU:$C84A PRG:084A A5 5E
cmp #$04 ; CPU:$C84C PRG:084C C9 04
bmi SubCC88A_Loop ; 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 SubCC89F_Loop ; 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 SubCC8B1_Loop ; 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 SubCC8BD ; CPU:$C887 PRG:0887 4C BD C8
;===============================================================================
; Routine: SubCC88A_Loop
; Global: The routine calls SubCC8BD, writes $031F, $0317, $030F and $0307.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp5E; stores A
; to $031F; loads A with $30; stores A to $0317; stores A to $030F;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $031F, $0317 and $030F changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC88A_Loop:
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 SubCC8BD ; CPU:$C89C PRG:089C 4C BD C8
;===============================================================================
; Routine: SubCC89F_Loop
; Global: The routine calls SubCC8BD, writes $0317, $030F and $0307.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp5E; stores A
; to $0317; loads A with $30; stores A to $030F; stores A to $0307;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0317, $030F and $0307 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC89F_Loop:
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 SubCC8BD ; CPU:$C8AE PRG:08AE 4C BD C8
;===============================================================================
; Routine: SubCC8B1_Loop
; Global: The routine writes $030F and $0307.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp5E; stores A
; to $030F; loads A with $30; stores A to $0307.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $030F and $0307 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC8B1_Loop:
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: SubCC8BD
; Global: The routine calls SubCC930, writes $0321, $0319, $0311 and $0309.
; Local: Executes 31 instructions: loads A from Zp59; compares A with $04;
; branches on negative to SubCC8FD; loads A from Zp59; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $0321, $0319 and $0311
; changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC8BD:
lda Zp59 ; CPU:$C8BD PRG:08BD A5 59
cmp #$04 ; CPU:$C8BF PRG:08BF C9 04
bmi SubCC8FD_Loop ; 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 SubCC912_Loop ; 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 SubCC924_Loop ; 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 SubCC930 ; CPU:$C8FA PRG:08FA 4C 30 C9
;===============================================================================
; Routine: SubCC8FD_Loop
; Global: The routine calls SubCC930, writes $0321, $0319, $0311 and $0309.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp59; stores A
; to $0321; loads A with $30; stores A to $0319; stores A to $0311;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0321, $0319 and $0311 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC8FD_Loop:
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 SubCC930 ; CPU:$C90F PRG:090F 4C 30 C9
;===============================================================================
; Routine: SubCC912_Loop
; Global: The routine calls SubCC930, writes $0319, $0311 and $0309.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp59; stores A
; to $0319; loads A with $30; stores A to $0311; stores A to $0309;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0319, $0311 and $0309 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC912_Loop:
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 SubCC930 ; CPU:$C921 PRG:0921 4C 30 C9
;===============================================================================
; Routine: SubCC924_Loop
; Global: The routine writes $0311 and $0309.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp59; stores A
; to $0311; loads A with $30; stores A to $0309.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0311 and $0309 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC924_Loop:
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: SubCC930
; Global: The routine calls SubCC9A3, writes $034D, $0345, $033D and $0335.
; Local: Executes 31 instructions: loads A from Zp64; compares A with $04;
; branches on negative to SubCC970; loads A from Zp64; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $034D, $0345 and $033D
; changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC930:
lda Zp64 ; CPU:$C930 PRG:0930 A5 64
cmp #$04 ; CPU:$C932 PRG:0932 C9 04
bmi SubCC970_Loop ; 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 SubCC985_Loop ; 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 SubCC997_Loop ; 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 SubCC9A3 ; CPU:$C96D PRG:096D 4C A3 C9
;===============================================================================
; Routine: SubCC970_Loop
; Global: The routine calls SubCC9A3, writes $034D, $0345, $033D and $0335.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp64; stores A
; to $034D; loads A with $30; stores A to $0345; stores A to $033D;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $034D, $0345 and $033D changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC970_Loop:
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 SubCC9A3 ; CPU:$C982 PRG:0982 4C A3 C9
;===============================================================================
; Routine: SubCC985_Loop
; Global: The routine calls SubCC9A3, writes $0345, $033D and $0335.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp64; stores A
; to $0345; loads A with $30; stores A to $033D; stores A to $0335;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0345, $033D and $0335 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC985_Loop:
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 SubCC9A3 ; CPU:$C994 PRG:0994 4C A3 C9
;===============================================================================
; Routine: SubCC997_Loop
; Global: The routine writes $033D and $0335.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp64; stores A
; to $033D; loads A with $30; stores A to $0335.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $033D and $0335 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC997_Loop:
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: SubCC9A3
; Global: The routine calls SubCCA16, writes $034F, $0347, $033F and $0337.
; Local: Executes 31 instructions: loads A from Zp5F; compares A with $04;
; branches on negative to SubCC9E3; loads A from Zp5F; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $034F, $0347 and $033F
; changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC9A3:
lda Zp5F ; CPU:$C9A3 PRG:09A3 A5 5F
cmp #$04 ; CPU:$C9A5 PRG:09A5 C9 04
bmi SubCC9E3_Loop ; 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 SubCC9F8_Loop ; 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 SubCCA0A_Loop ; 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 SubCCA16 ; CPU:$C9E0 PRG:09E0 4C 16 CA
;===============================================================================
; Routine: SubCC9E3_Loop
; Global: The routine calls SubCCA16, writes $034F, $0347, $033F and $0337.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp5F; stores A
; to $034F; loads A with $30; stores A to $0347; stores A to $033F;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $034F, $0347 and $033F changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC9E3_Loop:
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 SubCCA16 ; CPU:$C9F5 PRG:09F5 4C 16 CA
;===============================================================================
; Routine: SubCC9F8_Loop
; Global: The routine calls SubCCA16, writes $0347, $033F and $0337.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp5F; stores A
; to $0347; loads A with $30; stores A to $033F; stores A to $0337;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0347, $033F and $0337 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCC9F8_Loop:
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 SubCCA16 ; CPU:$CA07 PRG:0A07 4C 16 CA
;===============================================================================
; Routine: SubCCA0A_Loop
; Global: The routine writes $033F and $0337.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp5F; stores A
; to $033F; loads A with $30; stores A to $0337.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $033F and $0337 changed.
; Clobbers:
; A, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCA0A_Loop:
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: SubCCA16
; Global: The routine calls SubCCA89, writes $0351, $0349, $0341 and $0339.
; Local: Executes 31 instructions: loads A from Zp5A; compares A with $04;
; branches on negative to SubCCA56; loads A from Zp5A; clears the
; carry flag; subtracts $04 from A; and 25 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves $0351, $0349 and $0341
; changed.
; Clobbers:
; A, the N, Z, C and V flags, Zp5A, $0339, $0341, $0349, $0351.
;
;===============================================================================
SubCCA16:
lda Zp5A ; CPU:$CA16 PRG:0A16 A5 5A
cmp #$04 ; CPU:$CA18 PRG:0A18 C9 04
bmi SubCCA56_Loop ; 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 SubCCA6B_Loop ; 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 SubCCA7D_Loop ; 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 SubCCA89 ; CPU:$CA53 PRG:0A53 4C 89 CA
;===============================================================================
; Routine: SubCCA56_Loop
; Global: The routine calls SubCCA89, writes $0351, $0349, $0341 and $0339.
; Local: Executes 8 instructions: loads A with $F0; ORs A with Zp5A; stores A
; to $0351; loads A with $30; stores A to $0349; stores A to $0341;
; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0351, $0349 and $0341 changed.
; Clobbers:
; A, the N and Z flags, $0339, $0341, $0349, $0351.
;
;===============================================================================
SubCCA56_Loop:
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 SubCCA89 ; CPU:$CA68 PRG:0A68 4C 89 CA
;===============================================================================
; Routine: SubCCA6B_Loop
; Global: The routine calls SubCCA89, writes $0349, $0341 and $0339.
; Local: Executes 7 instructions: loads A with $D0; ORs A with Zp5A; stores A
; to $0349; loads A with $30; stores A to $0341; stores A to $0339;
; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0349, $0341 and $0339 changed.
; Clobbers:
; A, the N and Z flags, $0339, $0341, $0349.
;
;===============================================================================
SubCCA6B_Loop:
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 SubCCA89 ; CPU:$CA7A PRG:0A7A 4C 89 CA
;===============================================================================
; Routine: SubCCA7D_Loop
; Global: The routine writes $0341 and $0339.
; Local: Executes 5 instructions: loads A with $D0; ORs A with Zp5A; stores A
; to $0341; loads A with $30; stores A to $0339.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves $0341 and $0339 changed.
; Clobbers:
; A, the N and Z flags, $0339, $0341.
;
;===============================================================================
SubCCA7D_Loop:
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: SubCCA89
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 1 instruction: returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; nothing.
;
;===============================================================================
SubCCA89:
rts ; CPU:$CA89 PRG:0A89 60
;===============================================================================
; Routine: ResetButtonCounters
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 20 instructions: loads A with $FF; stores A to Zp6A; loads A
; with $00; stores A to Zp60; stores A to Zp5B; stores A to Zp56; and
; 14 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; A, the N and Z flags, the RAM fields it writes.
;
;===============================================================================
ResetButtonCounters:
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: ResetFrameCounter
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: loads A with $00; stores A to Zp53; stores A
; to Zp54; returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; A, the N and Z flags, Zp53, Zp54.
;
;===============================================================================
ResetFrameCounter:
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: ShiftMarkerBitToOam
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: rotates Zp4E,x left; branches on carry clear
; to SubCCAC1; loads A with $00; stores A to $0202,y.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, the N, Z and C flags, Zp4E, the OAM shadow.
;
;===============================================================================
ShiftMarkerBitToOam:
rol Zp4E,x ; CPU:$CAB8 PRG:0AB8 36 4E
bcc SubCCAC1_Loop ; 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: SubCCAC1_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: rotates Zp4E,x left; branches on carry clear
; to SubCCACA; loads A with $00; stores A to $0206,y.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, the N, Z and C flags, Zp4E, the OAM shadow.
;
;===============================================================================
SubCCAC1_Loop:
rol Zp4E,x ; CPU:$CAC1 PRG:0AC1 36 4E
bcc SubCCACA_Loop ; 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: SubCCACA_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: rotates Zp4E,x left; branches on carry clear
; to SubCCAD3; loads A with $00; stores A to $020E,y.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, the N, Z and C flags, Zp4E, the OAM shadow.
;
;===============================================================================
SubCCACA_Loop:
rol Zp4E,x ; CPU:$CACA PRG:0ACA 36 4E
bcc SubCCAD3_Loop ; 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: SubCCAD3_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: rotates Zp4E,x left; branches on carry clear
; to SubCCADC; loads A with $00; stores A to $020A,y.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, the N, Z and C flags, Zp4E, the OAM shadow.
;
;===============================================================================
SubCCAD3_Loop:
rol Zp4E,x ; CPU:$CAD3 PRG:0AD3 36 4E
bcc SubCCADC_Loop ; 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: SubCCADC_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: rotates Zp4E,x left; branches on carry clear
; to SubCCAE5; loads A with $00; stores A to $0212,y.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, the N, Z and C flags, Zp4E, the OAM shadow.
;
;===============================================================================
SubCCADC_Loop:
rol Zp4E,x ; CPU:$CADC PRG:0ADC 36 4E
bcc SubCCAE5_Loop ; 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: SubCCAE5_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: rotates Zp4E,x left; branches on carry clear
; to SubCCAEE; loads A with $00; stores A to $0216,y.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, the N, Z and C flags, Zp4E, the OAM shadow.
;
;===============================================================================
SubCCAE5_Loop:
rol Zp4E,x ; CPU:$CAE5 PRG:0AE5 36 4E
bcc SubCCAEE_Loop ; 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: SubCCAEE_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: rotates Zp4E,x left; branches on carry clear
; to SubCCAF7; loads A with $00; stores A to $021A,y.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, the N, Z and C flags, Zp4E, the OAM shadow.
;
;===============================================================================
SubCCAEE_Loop:
rol Zp4E,x ; CPU:$CAEE PRG:0AEE 36 4E
bcc SubCCAF7_Loop ; 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: SubCCAF7_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: rotates Zp4E,x left; branches on carry clear
; to SubCCB00; loads A with $00; stores A to $021E,y.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, the N, Z and C flags, Zp4E, the OAM shadow.
;
;===============================================================================
SubCCAF7_Loop:
rol Zp4E,x ; CPU:$CAF7 PRG:0AF7 36 4E
bcc SubCCB00_Loop ; 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: SubCCB00_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 2 instructions: rotates Zp4E,x left; returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; no register, the N, Z and C flags, Zp4E.
;
;===============================================================================
SubCCB00_Loop:
rol Zp4E,x ; CPU:$CB00 PRG:0B00 36 4E
rts ; CPU:$CB02 PRG:0B02 60
;===============================================================================
; Routine: ClearAuxRam
; Global: The routine calls PpuMaskSetup.
; Local: Executes 3 instructions: calls PpuMaskSetup; loads X with $00; loads A
; with $EE.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
ClearAuxRam:
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: SubCCB0A_OnNonzero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: stores A to $6000,x; increments X; compares
; X with $06; branches on not equal to SubCCB0A; loads A with $00;
; loads X with $00.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCCB0A_OnNonzero:
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 SubCCB0A_OnNonzero ; CPU:$CB10 PRG:0B10 D0 F8
lda #$00 ; CPU:$CB12 PRG:0B12 A9 00
ldx #$00 ; CPU:$CB14 PRG:0B14 A2 00
;===============================================================================
; Routine: SubCCB16_OnNonzero
; Global: The routine calls VramWrite and VramPtrWrite, writes the PPUCTRL and
; PPUMASK registers.
; Local: Executes 22 instructions: stores A to Zp00,x; stores A to $0100,x;
; loads A with $F4; stores A to $0200,x; loads A with $00; stores A
; to $0300,x; and 16 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUCTRL and PPUMASK
; registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCCB16_OnNonzero:
sta Zp00,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 SubCCB16_OnNonzero ; CPU:$CB2F PRG:0B2F D0 E5
lda #$10 ; CPU:$CB31 PRG:0B31 A9 10
sta PPUCTRL ; CPU:$CB33 PRG:0B33 8D 00 20
sta ZpEF ; CPU:$CB36 PRG:0B36 85 EF
lda #$00 ; CPU:$CB38 PRG:0B38 A9 00
sta PPUMASK ; CPU:$CB3A PRG:0B3A 8D 01 20
sta ZpEE ; 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 VramWrite ; CPU:$CB45 PRG:0B45 20 EE CD
jsr VramPtrWrite ; CPU:$CB48 PRG:0B48 20 3F CD
; ---- data $CB4B-$CB4C (2 bytes) ----
MasterPaletteStreamPtrAlt:
.byte $06, $CF ; CPU:$CB4B PRG:0B4B 06 CF
;===============================================================================
; Routine: SubCCB4D
; Global: The routine calls PpuScrollLatch and VramPtrWrite.
; Local: Executes 2 instructions: calls PpuScrollLatch; calls VramPtrWrite.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCB4D:
jsr PpuScrollLatch ; CPU:$CB4D PRG:0B4D 20 3C CE
jsr VramPtrWrite ; CPU:$CB50 PRG:0B50 20 3F CD
; ---- data $CB53-$CB54 (2 bytes) ----
JoypadPanelScreenTwoPtr:
.byte $63, $D0 ; CPU:$CB53 PRG:0B53 63 D0
;===============================================================================
; Routine: SubCCB55
; Global: The routine calls PpuScrollLatch and ClearOamRoutine.
; Local: Executes 3 instructions: calls PpuScrollLatch; calls ClearOamRoutine; loads X with
; $DF.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCCB55:
jsr PpuScrollLatch ; CPU:$CB55 PRG:0B55 20 3C CE
jsr ClearOamRoutine ; CPU:$CB58 PRG:0B58 20 74 C1
ldx #$DF ; CPU:$CB5B PRG:0B5B A2 DF
;===============================================================================
; Routine: SubCCB5D_OnNonzero
; Global: The routine calls SetPpuMaskBits, writes the APUPULSE1CTRL register.
; Local: Executes 28 instructions: loads A from $D5C4,x; stores A to $0200,x;
; decrements X; branches on not equal to SubCCB5D; loads A from
; $D5C4,x; stores A to $0200,x; and 22 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUPULSE1CTRL register
; set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCCB5D_OnNonzero:
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 SubCCB5D_OnNonzero ; 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 SetPpuMaskBits ; CPU:$CB97 PRG:0B97 20 39 CD
;===============================================================================
; Routine: PollControllerAndSilenceApu
; Global: The routine calls EnablePpuNmi, StrobeController1 and SilenceApuWhenNoButtonPressed.
; Local: Executes 7 instructions: calls EnablePpuNmi; calls StrobeController1; increments
; Zp6A; loads A with $0F; compares A with Zp6A; branches on equal to
; SubCCBAB; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
PollControllerAndSilenceApu:
jsr EnablePpuNmi ; CPU:$CB9A PRG:0B9A 20 E2 CC
jsr StrobeController1 ; 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 SubCCBAB_Loop ; CPU:$CBA6 PRG:0BA6 F0 03
jmp SilenceApuWhenNoButtonPressed ; CPU:$CBA8 PRG:0BA8 4C B1 CB
;===============================================================================
; Routine: SubCCBAB_Loop
; Global: The routine calls SubCC524 and ResetButtonCounters.
; Local: Executes 2 instructions: calls SubCC524; calls ResetButtonCounters.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCCBAB_Loop:
jsr SubCC524 ; CPU:$CBAB PRG:0BAB 20 24 C5
jsr ResetButtonCounters ; CPU:$CBAE PRG:0BAE 20 8A CA
;===============================================================================
; Routine: SilenceApuWhenNoButtonPressed
; Global: The routine writes the APUSTATUS register.
; Local: Executes 7 instructions: loads A with $00; compares A with Zp40;
; branches on not equal to SubCCBC0; compares A with Zp41; branches
; on not equal to SubCCBC0; loads A with $00; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the APUSTATUS register set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SilenceApuWhenNoButtonPressed:
lda #$00 ; CPU:$CBB1 PRG:0BB1 A9 00
cmp Zp40 ; CPU:$CBB3 PRG:0BB3 C5 40
bne SubCCBC0_Loop ; CPU:$CBB5 PRG:0BB5 D0 09
cmp Zp41 ; CPU:$CBB7 PRG:0BB7 C5 41
bne SubCCBC0_Loop ; CPU:$CBB9 PRG:0BB9 D0 05
lda #$00 ; CPU:$CBBB PRG:0BBB A9 00
sta APUSTATUS ; CPU:$CBBD PRG:0BBD 8D 15 40
;===============================================================================
; Routine: SubCCBC0_Loop
; Global: The routine calls ReadController1Bit, CountPressedButtons and CopyMarkerSpriteTable1.
; Local: Executes 14 instructions: loads Y with $00; loads X with $00; calls
; ReadController1Bit; calls CountPressedButtons; loads Y with $20; increments X; and 8
; more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCCBC0_Loop:
ldy #$00 ; CPU:$CBC0 PRG:0BC0 A0 00
ldx #$00 ; CPU:$CBC2 PRG:0BC2 A2 00
jsr ReadController1Bit ; CPU:$CBC4 PRG:0BC4 20 11 CC
jsr CountPressedButtons ; CPU:$CBC7 PRG:0BC7 20 61 C3
ldy #$20 ; CPU:$CBCA PRG:0BCA A0 20
inx ; CPU:$CBCC PRG:0BCC E8
jsr ReadController1Bit ; CPU:$CBCD PRG:0BCD 20 11 CC
jsr CountPressedButtons ; CPU:$CBD0 PRG:0BD0 20 61 C3
lda #$FF ; CPU:$CBD3 PRG:0BD3 A9 FF
cmp Zp4E ; CPU:$CBD5 PRG:0BD5 C5 4E
bne SubCCBE0_Loop ; CPU:$CBD7 PRG:0BD7 D0 07
cmp Zp4F ; CPU:$CBD9 PRG:0BD9 C5 4F
bne SubCCBE0_Loop ; CPU:$CBDB PRG:0BDB D0 03
jmp CopyMarkerSpriteTable1 ; CPU:$CBDD PRG:0BDD 4C A0 C1
;===============================================================================
; Routine: SubCCBE0_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 3 instructions: increments Zp54; branches on not equal to
; SubCCBE6; increments Zp53.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCCBE0_Loop:
inc Zp54 ; CPU:$CBE0 PRG:0BE0 E6 54
bne SubCCBE6_Loop ; CPU:$CBE2 PRG:0BE2 D0 02
inc Zp53 ; CPU:$CBE4 PRG:0BE4 E6 53
;===============================================================================
; Routine: SubCCBE6_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: loads A with $00; compares A with Zp54;
; branches on not equal to SubCCBF2; loads A with $38; compares A
; with Zp53; branches on equal to SubCCBF5.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCCBE6_Loop:
lda #$00 ; CPU:$CBE6 PRG:0BE6 A9 00
cmp Zp54 ; CPU:$CBE8 PRG:0BE8 C5 54
bne SubCCBF2_Loop ; CPU:$CBEA PRG:0BEA D0 06
lda #$38 ; CPU:$CBEC PRG:0BEC A9 38
cmp Zp53 ; CPU:$CBEE PRG:0BEE C5 53
beq SubCCBF5_Loop ; CPU:$CBF0 PRG:0BF0 F0 03
;===============================================================================
; Routine: SubCCBF2_Loop
; Global: The routine calls PollControllerAndSilenceApu.
; Local: Executes 1 instruction: calls PollControllerAndSilenceApu.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCCBF2_Loop:
jmp PollControllerAndSilenceApu; CPU:$CBF2 PRG:0BF2 4C 9A CB
;===============================================================================
; Routine: SubCCBF5_Loop
; Global: The routine calls ClearRamAndOam.
; Local: Executes 1 instruction: calls ClearRamAndOam.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the OAM shadow and the RAM fields
; it writes.
;
;===============================================================================
SubCCBF5_Loop:
jmp ClearRamAndOam ; CPU:$CBF5 PRG:0BF5 4C 55 C0
;===============================================================================
; Routine: StrobeController1
; Global: The routine writes the JOY1 registers.
; Local: Executes 5 instructions: loads X with $01; stores X to the JOY1
; register; decrements X; stores X to the JOY1 register; increments
; X.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves the JOY1 registers set.
; Clobbers:
; A, X and Y, the N, Z and C flags, Zp40, JOY1.
;
;===============================================================================
StrobeController1:
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: SubCCC02_OnZero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 1 instruction: loads Y with $08.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z and C flags, Zp40.
;
;===============================================================================
SubCCC02_OnZero:
ldy #$08 ; CPU:$CC02 PRG:0C02 A0 08
;===============================================================================
; Routine: SubCCC04_OnNonzero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 9 instructions: loads Y with $08; loads A from JOY1,x;
; shifts a right; rotates Zp40,x left; decrements Y; branches on not
; equal to SubCCC04; and 3 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; A, X and Y, the N, Z and C flags, Zp40.
;
;===============================================================================
SubCCC04_OnNonzero:
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 SubCCC04_OnNonzero ; CPU:$CC0B PRG:0C0B D0 F7
dex ; CPU:$CC0D PRG:0C0D CA
beq SubCCC02_OnZero ; CPU:$CC0E PRG:0C0E F0 F2
rts ; CPU:$CC10 PRG:0C10 60
;===============================================================================
; Routine: ReadController1Bit
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: loads A from JOY1,x; shifts a right;
; branches on carry clear to SubCCC18; returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; A, the N, Z and C flags, the OAM shadow and the RAM fields it writes.
;
;===============================================================================
ReadController1Bit:
lda JOY1,x ; CPU:$CC11 PRG:0C11 BD 16 40
lsr a ; CPU:$CC14 PRG:0C14 4A
bcc SubCCC18_Loop ; CPU:$CC15 PRG:0C15 90 01
rts ; CPU:$CC17 PRG:0C17 60
;===============================================================================
; Routine: SubCCC18_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 20 instructions: loads A with $03; stores A to $0202,y;
; stores A to $0206,y; stores A to $020A,y; stores A to $020E,y;
; stores A to $0212,y; and 14 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, the N and Z flags, the OAM shadow and the RAM fields it writes.
;
;===============================================================================
SubCCC18_Loop:
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: SubCCC46_OnNonnegative
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: stores A to $02E0,x; decrements X; branches
; on non-negative to SubCCC46; pulls A; copies A into X; returns with
; RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; A and X, the N and Z flags, the OAM shadow.
;
;===============================================================================
SubCCC46_OnNonnegative:
sta $02E0,x ; CPU:$CC46 PRG:0C46 9D E0 02
dex ; CPU:$CC49 PRG:0C49 CA
bpl SubCCC46_OnNonnegative ; 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: StrobeController2
; Global: The routine writes the JOY1 registers.
; Local: Executes 5 instructions: loads X with $01; stores X to the JOY1
; register; decrements X; stores X to the JOY1 register; increments
; X.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves the JOY1 registers set.
; Clobbers:
; A, X and Y, the N, Z and C flags, the RAM fields it writes.
;
;===============================================================================
StrobeController2:
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: SubCCC59_OnZero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 1 instruction: loads Y with $08.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z and C flags, the RAM fields it writes.
;
;===============================================================================
SubCCC59_OnZero:
ldy #$08 ; CPU:$CC59 PRG:0C59 A0 08
;===============================================================================
; Routine: SubCCC5B_OnNonzero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 10 instructions: loads Y with $08; loads A from JOY1,x; ANDs
; A with $03; compares A with $01; rotates Zp40,x left; decrements Y;
; and 4 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z and C flags, the RAM fields it writes.
;
;===============================================================================
SubCCC5B_OnNonzero:
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 SubCCC5B_OnNonzero ; CPU:$CC65 PRG:0C65 D0 F4
dex ; CPU:$CC67 PRG:0C67 CA
beq SubCCC59_OnZero ; CPU:$CC68 PRG:0C68 F0 EF
ldx #$01 ; CPU:$CC6A PRG:0C6A A2 01
;===============================================================================
; Routine: SubCCC6C_OnZero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 1 instruction: loads Y with $08.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z and C flags, Zp42, Zp45, Zp47, Zp49, Zp4B, Zp4D.
;
;===============================================================================
SubCCC6C_OnZero:
ldy #$08 ; CPU:$CC6C PRG:0C6C A0 08
;===============================================================================
; Routine: SubCCC6E_OnNonzero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 11 instructions: loads Y with $08; loads A from JOY1,x;
; shifts a right; rotates Zp47,x left; shifts a right; rotates Zp45,x
; left; and 5 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z and C flags, Zp42, Zp45, Zp47, Zp49, Zp4B, Zp4D.
;
;===============================================================================
SubCCC6E_OnNonzero:
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 SubCCC6E_OnNonzero ; CPU:$CC78 PRG:0C78 D0 F4
dex ; CPU:$CC7A PRG:0C7A CA
beq SubCCC6C_OnZero ; CPU:$CC7B PRG:0C7B F0 EF
ldx #$01 ; CPU:$CC7D PRG:0C7D A2 01
;===============================================================================
; Routine: SubCCC7F_OnZero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 1 instruction: loads Y with $08.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z and C flags, Zp42, Zp49, Zp4B, Zp4D.
;
;===============================================================================
SubCCC7F_OnZero:
ldy #$08 ; CPU:$CC7F PRG:0C7F A0 08
;===============================================================================
; Routine: SubCCC81_OnNonzero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 18 instructions: loads Y with $08; loads A from JOY1,x;
; shifts a right; rotates Zp4B,x left; shifts a right; rotates Zp49,x
; left; and 12 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A, X and Y, the N, Z and C flags, Zp42, Zp49, Zp4B, Zp4D.
;
;===============================================================================
SubCCC81_OnNonzero:
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 SubCCC81_OnNonzero ; CPU:$CC8B PRG:0C8B D0 F4
dex ; CPU:$CC8D PRG:0C8D CA
beq SubCCC7F_OnZero ; 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 SubCCCA0_Loop ; 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: SubCCCA0_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: loads A from Zp4A; compares A with $10;
; branches on not equal to SubCCCAC; loads A with $40; ORs A with
; Zp4D; stores A to Zp4D.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A and X, the N, Z and C flags, Zp42, Zp4D.
;
;===============================================================================
SubCCCA0_Loop:
lda Zp4A ; CPU:$CCA0 PRG:0CA0 A5 4A
cmp #$10 ; CPU:$CCA2 PRG:0CA2 C9 10
bne SubCCCAC_Loop ; 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: SubCCCAC_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: loads A from Zp4B; compares A with $10;
; branches on not equal to SubCCCB8; loads A with $20; ORs A with
; Zp4D; stores A to Zp4D.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A and X, the N, Z and C flags, Zp42, Zp4D.
;
;===============================================================================
SubCCCAC_Loop:
lda Zp4B ; CPU:$CCAC PRG:0CAC A5 4B
cmp #$10 ; CPU:$CCAE PRG:0CAE C9 10
bne SubCCCB8_Loop ; 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: SubCCCB8_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 6 instructions: loads A from Zp4C; compares A with $20;
; branches on not equal to SubCCCC4; loads A with $10; ORs A with
; Zp4D; stores A to Zp4D.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A and X, the N, Z and C flags, Zp42, Zp4D.
;
;===============================================================================
SubCCCB8_Loop:
lda Zp4C ; CPU:$CCB8 PRG:0CB8 A5 4C
cmp #$20 ; CPU:$CCBA PRG:0CBA C9 20
bne SubCCCC4_Loop ; 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: SubCCCC4_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: loads A from Zp4D; compares A with $C0;
; branches on not equal to SubCCCD4; loads X with $02.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A and X, the N, Z and C flags, Zp42.
;
;===============================================================================
SubCCCC4_Loop:
lda Zp4D ; CPU:$CCC4 PRG:0CC4 A5 4D
cmp #$C0 ; CPU:$CCC6 PRG:0CC6 C9 C0
bne SubCCCD4_Loop ; CPU:$CCC8 PRG:0CC8 D0 0A
ldx #$02 ; CPU:$CCCA PRG:0CCA A2 02
;===============================================================================
; Routine: SubCCCCC_OnNonzero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 5 instructions: loads A from Zp44,x; stores A to Zp42,x;
; decrements X; branches on not equal to SubCCCCC; returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; A and X, the N and Z flags, Zp42.
;
;===============================================================================
SubCCCCC_OnNonzero:
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 SubCCCCC_OnNonzero ; CPU:$CCD1 PRG:0CD1 D0 F9
rts ; CPU:$CCD3 PRG:0CD3 60
;===============================================================================
; Routine: SubCCCD4_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 3 instructions: compares A with $30; branches on not equal
; to SubCCCE1; loads X with $02.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A and X, the N, Z and C flags, Zp42.
;
;===============================================================================
SubCCCD4_Loop:
cmp #$30 ; CPU:$CCD4 PRG:0CD4 C9 30
bne SubCCCE1_Loop ; CPU:$CCD6 PRG:0CD6 D0 09
ldx #$02 ; CPU:$CCD8 PRG:0CD8 A2 02
;===============================================================================
; Routine: SubCCCDA_OnNonzero
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 4 instructions: loads A from Zp46,x; stores A to Zp42,x;
; decrements X; branches on not equal to SubCCCDA.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A and X, the N and Z flags, Zp42.
;
;===============================================================================
SubCCCDA_OnNonzero:
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 SubCCCDA_OnNonzero ; CPU:$CCDF PRG:0CDF D0 F9
;===============================================================================
; Routine: SubCCCE1_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 1 instruction: returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; nothing.
;
;===============================================================================
SubCCCE1_Loop:
rts ; CPU:$CCE1 PRG:0CE1 60
;===============================================================================
; Routine: EnablePpuNmi
; Global: The routine writes the PPUCTRL register, reads the PPUSTATUS
; register.
; Local: Executes 8 instructions: pushes A; loads A from the PPUSTATUS
; register; loads A from ZpEF; ORs A with $80; stores A to ZpEF;
; stores A to the PPUCTRL register; and 2 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves the PPUCTRL register set.
; Clobbers:
; no register, the N, Z and V flags, ZpE0, ZpEF, PPUCTRL.
;
;===============================================================================
EnablePpuNmi:
pha ; CPU:$CCE2 PRG:0CE2 48
lda PPUSTATUS ; CPU:$CCE3 PRG:0CE3 AD 02 20
lda ZpEF ; CPU:$CCE6 PRG:0CE6 A5 EF
ora #$80 ; CPU:$CCE8 PRG:0CE8 09 80
sta ZpEF ; 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: SubCCCF2_OnNegative
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 3 instructions: tests the bits of ZpE0; branches on negative
; to SubCCCF2; returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; no register, the N, Z and V flags.
;
;===============================================================================
SubCCCF2_OnNegative:
bit ZpE0 ; CPU:$CCF2 PRG:0CF2 24 E0
bmi SubCCCF2_OnNegative ; CPU:$CCF4 PRG:0CF4 30 FC
rts ; CPU:$CCF6 PRG:0CF6 60
;===============================================================================
; Routine: NmiHandler
; Global: The routine calls PpuCtrlSetup, OamDmaSetup and VramBurstWrite, reads $0300.
; Local: Executes 10 instructions: pushes A; copies X into A; pushes A; copies
; Y into A; pushes A; calls PpuCtrlSetup; and 4 more instructions.
; Parameters: Reads $0300 from the zero page and RAM; the values it acts on
; are those fields' contents.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; no register, the N, Z and C flags, the RAM fields it writes.
;
;===============================================================================
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 PpuCtrlSetup ; CPU:$CCFC PRG:0CFC 20 17 CD
jsr OamDmaSetup ; CPU:$CCFF PRG:0CFF 20 24 CD
lda $0300 ; CPU:$CD02 PRG:0D02 AD 00 03
beq SubCCD0A_Loop ; CPU:$CD05 PRG:0D05 F0 03
jsr VramBurstWrite ; CPU:$CD07 PRG:0D07 20 4F CE
;===============================================================================
; Routine: SubCCD0A_Loop
; Global: Interrupt handler - the CPU enters it from the vector table; it
; calls PpuScrollLatch.
; Local: Executes 9 instructions: calls PpuScrollLatch; loads A with $00; stores A
; to ZpE0; pulls A; copies A into Y; pulls A; and 3 more
; instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns from the interrupt with RTI.
; Clobbers:
; A, X and Y, the N and Z flags, ZpE0, PPUCTRL, PPUSCROLL.
;
;===============================================================================
SubCCD0A_Loop:
jsr PpuScrollLatch ; 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: The routine writes the PPUCTRL register, reads the PPUSTATUS
; register.
; Local: Executes 6 instructions: loads A from the PPUSTATUS register; loads A
; from ZpEF; ANDs A with $7F; stores A to ZpEF; stores A to the
; PPUCTRL register; returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed. Leaves the PPUCTRL register set.
; Clobbers:
; A, the N and Z flags, ZpEF, PPUCTRL.
;
;===============================================================================
PpuCtrlSetup:
lda PPUSTATUS ; CPU:$CD17 PRG:0D17 AD 02 20
lda ZpEF ; CPU:$CD1A PRG:0D1A A5 EF
and #$7F ; CPU:$CD1C PRG:0D1C 29 7F
sta ZpEF ; CPU:$CD1E PRG:0D1E 85 EF
sta PPUCTRL ; CPU:$CD20 PRG:0D20 8D 00 20
rts ; CPU:$CD23 PRG:0D23 60
;===============================================================================
; Routine: OamDmaSetup
; Global: The routine writes the OAMADDR and OAMDMA registers.
; Local: Executes 5 instructions: loads A with $00; stores A to the OAMADDR
; register; loads A with $02; stores A to the OAMDMA register;
; returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed. Leaves the OAMADDR and OAMDMA registers set.
; Clobbers:
; A, the N and Z flags, OAMADDR, OAMDMA.
;
;===============================================================================
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: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 2 instructions: loads A from ZpEE; ANDs A with $E7.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, the N and Z flags, ZpEE, PPUMASK.
;
;===============================================================================
PpuMaskSetup:
lda ZpEE ; CPU:$CD2F PRG:0D2F A5 EE
and #$E7 ; CPU:$CD31 PRG:0D31 29 E7
;===============================================================================
; Routine: SubCCD33_OnNonzero
; Global: The routine writes the PPUMASK register.
; Local: Executes 3 instructions: stores A to ZpEE; stores A to the PPUMASK
; register; returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed. Leaves the PPUMASK register set.
; Clobbers:
; no register, ZpEE, PPUMASK.
;
;===============================================================================
SubCCD33_OnNonzero:
sta ZpEE ; CPU:$CD33 PRG:0D33 85 EE
sta PPUMASK ; CPU:$CD35 PRG:0D35 8D 01 20
rts ; CPU:$CD38 PRG:0D38 60
;===============================================================================
; Routine: SetPpuMaskBits
; Global: The routine writes the PPUMASK register.
; Local: Executes 6 instructions: stores A to ZpEE; stores A to the PPUMASK
; register; returns with RTS; loads A from ZpEE; ORs A with $18;
; branches on not equal to SubCCD33.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed. Leaves the PPUMASK register set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SetPpuMaskBits:
lda ZpEE ; CPU:$CD39 PRG:0D39 A5 EE
ora #$18 ; CPU:$CD3B PRG:0D3B 09 18
bne SubCCD33_OnNonzero ; CPU:$CD3D PRG:0D3D D0 F4
;===============================================================================
; Routine: VramPtrWrite
; Global: The routine calls RetAddrUpdate and SubCCD99.
; Local: Executes 2 instructions: calls RetAddrUpdate; calls SubCCD99.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
VramPtrWrite:
jsr RetAddrUpdate ; CPU:$CD3F PRG:0D3F 20 C8 CD
jmp SubCCD99_OnCarrySet ; CPU:$CD42 PRG:0D42 4C 99 CD
;===============================================================================
; Routine: SubCCD45_OnNonzero
; Global: The routine writes the PPUADDR registers.
; Local: Executes 13 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from ((Zp00),y); stores A to the PPUADDR
; register; increments Y; and 7 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUADDR registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCD45_OnNonzero:
pha ; CPU:$CD45 PRG:0D45 48
sta PPUADDR ; CPU:$CD46 PRG:0D46 8D 06 20
iny ; CPU:$CD49 PRG:0D49 C8
lda (Zp00),y ; CPU:$CD4A PRG:0D4A B1 00
sta PPUADDR ; CPU:$CD4C PRG:0D4C 8D 06 20
iny ; CPU:$CD4F PRG:0D4F C8
lda (Zp00),y ; CPU:$CD50 PRG:0D50 B1 00
asl a ; CPU:$CD52 PRG:0D52 0A
pha ; CPU:$CD53 PRG:0D53 48
lda ZpEF ; CPU:$CD54 PRG:0D54 A5 EF
ora #$04 ; CPU:$CD56 PRG:0D56 09 04
bcs SubCCD5C_Loop ; CPU:$CD58 PRG:0D58 B0 02
and #$FB ; CPU:$CD5A PRG:0D5A 29 FB
;===============================================================================
; Routine: SubCCD5C_Loop
; Global: The routine writes the PPUADDR and PPUCTRL registers.
; Local: Executes 21 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from ((Zp00),y); stores A to the PPUADDR
; register; increments Y; and 15 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUADDR and PPUCTRL
; registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCD5C_Loop:
sta PPUCTRL ; CPU:$CD5C PRG:0D5C 8D 00 20
sta ZpEF ; 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 SubCCD69_Loop ; CPU:$CD64 PRG:0D64 90 03
ora #$02 ; CPU:$CD66 PRG:0D66 09 02
iny ; CPU:$CD68 PRG:0D68 C8
;===============================================================================
; Routine: SubCCD69_Loop
; Global: The routine writes the PPUADDR and PPUCTRL registers.
; Local: Executes 25 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from ((Zp00),y); stores A to the PPUADDR
; register; increments Y; and 19 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUADDR and PPUCTRL
; registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCD69_Loop:
plp ; CPU:$CD69 PRG:0D69 28
clc ; CPU:$CD6A PRG:0D6A 18
bne SubCCD6E_Loop ; CPU:$CD6B PRG:0D6B D0 01
sec ; CPU:$CD6D PRG:0D6D 38
;===============================================================================
; Routine: SubCCD6E_Loop
; Global: The routine writes the PPUADDR and PPUCTRL registers.
; Local: Executes 28 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from ((Zp00),y); stores A to the PPUADDR
; register; increments Y; and 22 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUADDR and PPUCTRL
; registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCD6E_Loop:
ror a ; CPU:$CD6E PRG:0D6E 6A
lsr a ; CPU:$CD6F PRG:0D6F 4A
tax ; CPU:$CD70 PRG:0D70 AA
;===============================================================================
; Routine: SubCCD71_OnNonzero
; Global: The routine writes the PPUADDR and PPUCTRL registers.
; Local: Executes 30 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from ((Zp00),y); stores A to the PPUADDR
; register; increments Y; and 24 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUADDR and PPUCTRL
; registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCD71_OnNonzero:
bcs SubCCD74_Loop ; CPU:$CD71 PRG:0D71 B0 01
iny ; CPU:$CD73 PRG:0D73 C8
;===============================================================================
; Routine: SubCCD74_Loop
; Global: The routine writes the PPUADDR, PPUCTRL and PPUDATA registers.
; Local: Executes 41 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from ((Zp00),y); stores A to the PPUADDR
; register; increments Y; and 35 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUADDR and PPUCTRL
; registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCD74_Loop:
lda (Zp00),y ; CPU:$CD74 PRG:0D74 B1 00
sta PPUDATA ; CPU:$CD76 PRG:0D76 8D 07 20
dex ; CPU:$CD79 PRG:0D79 CA
bne SubCCD71_OnNonzero ; CPU:$CD7A PRG:0D7A D0 F5
pla ; CPU:$CD7C PRG:0D7C 68
cmp #$3F ; CPU:$CD7D PRG:0D7D C9 3F
bne SubCCD8D_OnNonzero ; 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: SubCCD8D_OnNonzero
; Global: The routine writes the PPUADDR, PPUCTRL and PPUDATA registers.
; Local: Executes 48 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from ((Zp00),y); stores A to the PPUADDR
; register; increments Y; and 42 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUADDR and PPUCTRL
; registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCD8D_OnNonzero:
sec ; CPU:$CD8D PRG:0D8D 38
tya ; CPU:$CD8E PRG:0D8E 98
adc Zp00 ; CPU:$CD8F PRG:0D8F 65 00
sta Zp00 ; 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: SubCCD99_OnCarrySet
; Global: The routine writes the PPUADDR, PPUCTRL and PPUDATA registers, reads
; the PPUSTATUS register.
; Local: Executes 53 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from ((Zp00),y); stores A to the PPUADDR
; register; increments Y; and 47 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed. Leaves the PPUADDR and PPUCTRL registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCD99_OnCarrySet:
ldx PPUSTATUS ; CPU:$CD99 PRG:0D99 AE 02 20
ldy #$00 ; CPU:$CD9C PRG:0D9C A0 00
lda (Zp00),y ; CPU:$CD9E PRG:0D9E B1 00
bpl SubCCDA3_Loop ; CPU:$CDA0 PRG:0DA0 10 01
rts ; CPU:$CDA2 PRG:0DA2 60
;===============================================================================
; Routine: SubCCDA3_Loop
; Global: The routine writes the PPUADDR, PPUCTRL and PPUDATA registers, reads
; the PPUSTATUS register.
; Local: Executes 61 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from ((Zp00),y); stores A to the PPUADDR
; register; increments Y; and 55 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed. Leaves the PPUADDR and PPUCTRL registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCDA3_Loop:
cmp #$60 ; CPU:$CDA3 PRG:0DA3 C9 60
bne SubCCDB1_Loop ; 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 Zp00 ; CPU:$CDAB PRG:0DAB 85 00
ldy #$02 ; CPU:$CDAD PRG:0DAD A0 02
bne SubCCD8D_OnNonzero ; CPU:$CDAF PRG:0DAF D0 DC
;===============================================================================
; Routine: SubCCDB1_Loop
; Global: The routine writes the PPUADDR, PPUCTRL and PPUDATA registers, reads
; the PPUSTATUS register.
; Local: Executes 75 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from ((Zp00),y); stores A to the PPUADDR
; register; increments Y; and 69 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed. Leaves the PPUADDR and PPUCTRL registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
SubCCDB1_Loop:
cmp #$4C ; CPU:$CDB1 PRG:0DB1 C9 4C
bne SubCCD45_OnNonzero ; CPU:$CDB3 PRG:0DB3 D0 90
lda Zp00 ; 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 (Zp00),y ; CPU:$CDBC PRG:0DBC B1 00
tax ; CPU:$CDBE PRG:0DBE AA
iny ; CPU:$CDBF PRG:0DBF C8
lda (Zp00),y ; CPU:$CDC0 PRG:0DC0 B1 00
sta Zp01 ; CPU:$CDC2 PRG:0DC2 85 01
stx Zp00 ; CPU:$CDC4 PRG:0DC4 86 00
bcs SubCCD99_OnCarrySet ; CPU:$CDC6 PRG:0DC6 B0 D1
;===============================================================================
; Routine: RetAddrUpdate
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 19 instructions: copies the stack pointer into X; loads A
; from $0103,x; stores A to Zp05; loads A from $0104,x; stores A to
; Zp06; loads Y with $01; and 13 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; A and Y, the N, Z, C and V flags, Zp00, Zp01, Zp05, Zp06, $0103, $0104.
;
;===============================================================================
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 Zp00 ; 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: The routine writes the PPUCTRL and PPUADDR registers, reads the
; PPUSTATUS register.
; Local: Executes 16 instructions: stores A to Zp00; stores X to Zp01; stores
; Y to Zp02; loads A from the PPUSTATUS register; loads A from ZpEF;
; ANDs A with $FB; and 10 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUCTRL and PPUADDR
; registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
VramWrite:
sta Zp00 ; 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 ZpEF ; CPU:$CDF7 PRG:0DF7 A5 EF
and #$FB ; CPU:$CDF9 PRG:0DF9 29 FB
sta PPUCTRL ; CPU:$CDFB PRG:0DFB 8D 00 20
sta ZpEF ; CPU:$CDFE PRG:0DFE 85 EF
lda Zp00 ; 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 SubCCE12_Loop ; CPU:$CE0E PRG:0E0E B0 02
ldx Zp02 ; CPU:$CE10 PRG:0E10 A6 02
;===============================================================================
; Routine: SubCCE12_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 2 instructions: loads Y with $00; loads A from Zp01.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, PPUADDR, PPUDATA.
;
;===============================================================================
SubCCE12_Loop:
ldy #$00 ; CPU:$CE12 PRG:0E12 A0 00
lda Zp01 ; CPU:$CE14 PRG:0E14 A5 01
;===============================================================================
; Routine: SubCCE16_OnNonzero
; Global: The routine writes the PPUDATA and PPUADDR registers.
; Local: Executes 14 instructions: stores A to the PPUDATA register;
; decrements Y; branches on not equal to SubCCE16; decrements X;
; branches on not equal to SubCCE16; loads Y from Zp02; and 8 more
; instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUDATA and PPUADDR
; registers set.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, PPUADDR, PPUDATA.
;
;===============================================================================
SubCCE16_OnNonzero:
sta PPUDATA ; CPU:$CE16 PRG:0E16 8D 07 20
dey ; CPU:$CE19 PRG:0E19 88
bne SubCCE16_OnNonzero ; CPU:$CE1A PRG:0E1A D0 FA
dex ; CPU:$CE1C PRG:0E1C CA
bne SubCCE16_OnNonzero ; CPU:$CE1D PRG:0E1D D0 F7
ldy Zp02 ; CPU:$CE1F PRG:0E1F A4 02
lda Zp00 ; CPU:$CE21 PRG:0E21 A5 00
cmp #$20 ; CPU:$CE23 PRG:0E23 C9 20
bcc SubCCE39_Loop ; 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: SubCCE33_OnNonzero
; Global: The routine writes the PPUDATA register.
; Local: Executes 3 instructions: stores Y to the PPUDATA register; decrements
; X; branches on not equal to SubCCE33.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUDATA register set.
; Clobbers:
; X, the N and Z flags, PPUDATA.
;
;===============================================================================
SubCCE33_OnNonzero:
sty PPUDATA ; CPU:$CE33 PRG:0E33 8C 07 20
dex ; CPU:$CE36 PRG:0E36 CA
bne SubCCE33_OnNonzero ; CPU:$CE37 PRG:0E37 D0 FA
;===============================================================================
; Routine: SubCCE39_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 2 instructions: loads X from Zp01; returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; X, the N and Z flags.
;
;===============================================================================
SubCCE39_Loop:
ldx Zp01 ; CPU:$CE39 PRG:0E39 A6 01
rts ; CPU:$CE3B PRG:0E3B 60
;===============================================================================
; Routine: PpuScrollLatch
; Global: The routine writes the PPUSCROLL and PPUCTRL registers, reads the
; PPUSTATUS register.
; Local: Executes 8 instructions: loads A from the PPUSTATUS register; loads A
; from ZpED; stores A to the PPUSCROLL register; loads A from ZpEC;
; stores A to the PPUSCROLL register; loads A from ZpEF; and 2 more
; instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed. Leaves the PPUSCROLL and PPUCTRL registers set.
; Clobbers:
; A, the N and Z flags, PPUCTRL, PPUSCROLL.
;
;===============================================================================
PpuScrollLatch:
lda PPUSTATUS ; CPU:$CE3C PRG:0E3C AD 02 20
lda ZpED ; 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 ZpEF ; CPU:$CE49 PRG:0E49 A5 EF
sta PPUCTRL ; CPU:$CE4B PRG:0E4B 8D 00 20
rts ; CPU:$CE4E PRG:0E4E 60
;===============================================================================
; Routine: VramBurstWrite
; Global: The routine writes the PPUCTRL register, reads the PPUSTATUS
; register.
; Local: Executes 7 instructions: loads A from ZpEF; ANDs A with $FB; stores A
; to the PPUCTRL register; stores A to ZpEF; loads X from the
; PPUSTATUS register; loads Y with $00; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUCTRL register set.
; Clobbers:
; A, X and Y, the N, Z and C flags, ZpEF, $0301, $0302, PPUCTRL, PPUADDR,
; PPUDATA.
;
;===============================================================================
VramBurstWrite:
lda ZpEF ; CPU:$CE4F PRG:0E4F A5 EF
and #$FB ; CPU:$CE51 PRG:0E51 29 FB
sta PPUCTRL ; CPU:$CE53 PRG:0E53 8D 00 20
sta ZpEF ; CPU:$CE56 PRG:0E56 85 EF
ldx PPUSTATUS ; CPU:$CE58 PRG:0E58 AE 02 20
ldy #$00 ; CPU:$CE5B PRG:0E5B A0 00
beq SubCCE8A_Loop ; CPU:$CE5D PRG:0E5D F0 2B
;===============================================================================
; Routine: SubCCE5F_OnNonnegative
; Global: The routine writes the PPUADDR registers.
; Local: Executes 7 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from $0302,y; stores A to the PPUADDR
; register; increments Y; and 1 more instruction.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own. Leaves the PPUADDR registers set.
; Clobbers:
; A, X and Y, the N, Z and C flags, $0301, $0302, PPUADDR, PPUDATA.
;
;===============================================================================
SubCCE5F_OnNonnegative:
pha ; CPU:$CE5F PRG:0E5F 48
sta PPUADDR ; CPU:$CE60 PRG:0E60 8D 06 20
iny ; CPU:$CE63 PRG:0E63 C8
lda $0302,y ; CPU:$CE64 PRG:0E64 B9 02 03
sta PPUADDR ; CPU:$CE67 PRG:0E67 8D 06 20
iny ; CPU:$CE6A PRG:0E6A C8
ldx $0302,y ; CPU:$CE6B PRG:0E6B BE 02 03
;===============================================================================
; Routine: SubCCE6E_OnNonzero
; Global: The routine writes the PPUADDR and PPUDATA registers.
; Local: Executes 19 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from $0302,y; stores A to the PPUADDR
; register; increments Y; and 13 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUADDR and PPUDATA
; registers set.
; Clobbers:
; A, X and Y, the N, Z and C flags, $0301, $0302, PPUADDR, PPUDATA.
;
;===============================================================================
SubCCE6E_OnNonzero:
iny ; CPU:$CE6E PRG:0E6E C8
lda $0302,y ; CPU:$CE6F PRG:0E6F B9 02 03
sta PPUDATA ; CPU:$CE72 PRG:0E72 8D 07 20
dex ; CPU:$CE75 PRG:0E75 CA
bne SubCCE6E_OnNonzero ; CPU:$CE76 PRG:0E76 D0 F6
pla ; CPU:$CE78 PRG:0E78 68
cmp #$3F ; CPU:$CE79 PRG:0E79 C9 3F
bne SubCCE89_Loop ; 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: SubCCE89_Loop
; Global: The routine writes the PPUADDR and PPUDATA registers.
; Local: Executes 20 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from $0302,y; stores A to the PPUADDR
; register; increments Y; and 14 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target. Leaves the PPUADDR and PPUDATA
; registers set.
; Clobbers:
; A, X and Y, the N, Z and C flags, $0301, $0302, PPUADDR, PPUDATA.
;
;===============================================================================
SubCCE89_Loop:
iny ; CPU:$CE89 PRG:0E89 C8
;===============================================================================
; Routine: SubCCE8A_Loop
; Global: The routine writes $0302 and $0301, writes the PPUADDR and PPUDATA
; registers.
; Local: Executes 26 instructions: pushes A; stores A to the PPUADDR register;
; increments Y; loads A from $0302,y; stores A to the PPUADDR
; register; increments Y; and 20 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed. Leaves $0302 and $0301 changed.
; Clobbers:
; A, X and Y, the N, Z and C flags, $0301, $0302, PPUADDR, PPUDATA.
;
;===============================================================================
SubCCE8A_Loop:
lda $0302,y ; CPU:$CE8A PRG:0E8A B9 02 03
bpl SubCCE5F_OnNonnegative ; CPU:$CE8D PRG:0E8D 10 D0
sta $0302 ; 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: PlayVramStream
; Global: The routine calls RetAddrUpdate, reads $0301.
; Local: Executes 14 instructions: stores A to Zp03; stores X to Zp02; calls
; RetAddrUpdate; loads Y with $00; loads A from ((Zp00),y); ANDs A with
; $0F; and 8 more instructions.
; Parameters: Reads $0301 from the zero page and RAM; the values it acts on
; are those fields' contents.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, the RAM fields it writes.
;
;===============================================================================
PlayVramStream:
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 (Zp00),y ; CPU:$CEA1 PRG:0EA1 B1 00
and #$0F ; CPU:$CEA3 PRG:0EA3 29 0F
sta Zp04 ; CPU:$CEA5 PRG:0EA5 85 04
lda (Zp00),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: SubCCEB2_OnNonzero
; Global: The routine calls EndVramStream.
; Local: Executes 9 instructions: loads A from Zp03; stores A to $0302,x;
; calls EndVramStream; loads A from Zp02; stores A to $0302,x; calls
; EndVramStream; and 3 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Falls through to the next routine in the source; it has no return
; of its own.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, Zp02, Zp03, Zp05, Zp06, $0301,
; $0302.
;
;===============================================================================
SubCCEB2_OnNonzero:
lda Zp03 ; CPU:$CEB2 PRG:0EB2 A5 03
sta $0302,x ; CPU:$CEB4 PRG:0EB4 9D 02 03
jsr EndVramStream ; CPU:$CEB7 PRG:0EB7 20 F3 CE
lda Zp02 ; CPU:$CEBA PRG:0EBA A5 02
sta $0302,x ; CPU:$CEBC PRG:0EBC 9D 02 03
jsr EndVramStream ; CPU:$CEBF PRG:0EBF 20 F3 CE
lda Zp04 ; CPU:$CEC2 PRG:0EC2 A5 04
sta Zp06 ; CPU:$CEC4 PRG:0EC4 85 06
sta $0302,x ; CPU:$CEC6 PRG:0EC6 9D 02 03
;===============================================================================
; Routine: SubCCEC9_OnNonzero
; Global: The routine calls EndVramStream, writes $0301.
; Local: Executes 29 instructions: loads A from Zp03; stores A to $0302,x;
; calls EndVramStream; loads A from Zp02; stores A to $0302,x; calls
; EndVramStream; and 23 more instructions.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed. Leaves $0301 changed.
; Clobbers:
; A, X and Y, the N, Z, C and V flags, Zp02, Zp03, Zp05, Zp06, $0301,
; $0302.
;
;===============================================================================
SubCCEC9_OnNonzero:
jsr EndVramStream ; CPU:$CEC9 PRG:0EC9 20 F3 CE
iny ; CPU:$CECC PRG:0ECC C8
lda (Zp00),y ; CPU:$CECD PRG:0ECD B1 00
sta $0302,x ; CPU:$CECF PRG:0ECF 9D 02 03
dec Zp06 ; CPU:$CED2 PRG:0ED2 C6 06
bne SubCCEC9_OnNonzero ; CPU:$CED4 PRG:0ED4 D0 F3
jsr EndVramStream ; 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 SubCCEB2_OnNonzero ; CPU:$CEEB PRG:0EEB D0 C5
lda #$FF ; CPU:$CEED PRG:0EED A9 FF
sta $0302,x ; CPU:$CEEF PRG:0EEF 9D 02 03
rts ; CPU:$CEF2 PRG:0EF2 60
;===============================================================================
; Routine: EndVramStream
; Global: The routine reads $0300 and $0301.
; Local: Executes 9 instructions: increments X; compares X with $0300;
; branches on carry clear to SubCCF05; loads X from $0301; loads A
; with $FF; stores A to $0302,x; and 3 more instructions.
; Parameters: Reads $0300 and $0301 from the zero page and RAM; the values it
; acts on are those fields' contents.
; Returns: Leaves through one of its branches rather than a return; the caller
; resumes at the branch target.
; Clobbers:
; A and X, the N, Z and C flags, $0302.
;
;===============================================================================
EndVramStream:
inx ; CPU:$CEF3 PRG:0EF3 E8
cpx $0300 ; CPU:$CEF4 PRG:0EF4 EC 00 03
bcc SubCCF05_Loop ; CPU:$CEF7 PRG:0EF7 90 0C
ldx $0301 ; CPU:$CEF9 PRG:0EF9 AE 01 03
lda #$FF ; CPU:$CEFC PRG:0EFC A9 FF
sta $0302,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: SubCCF05_Loop
; Global: The routine reads no RAM field, writes none and calls nothing - it
; is a straight-line sequence whose only effect is on the registers
; and the flags.
; Local: Executes 1 instruction: returns with RTS.
; Parameters: Takes its input from the registers and the immediate values in
; the code; it reads no zero-page or RAM field.
; Returns: Returns with RTS; the registers it loaded still hold the values it
; computed.
; Clobbers:
; nothing.
;
;===============================================================================
SubCCF05_Loop:
rts ; CPU:$CF05 PRG:0F05 60
; ---- data $CF06-$FFFF (12538 bytes) ----
; referenced by `lda $D6A5,x` at $C1A2 (operand $D6A5 falls inside this region)
; referenced by `lda $D6C5,x` at $C1F4 (operand $D6C5 falls inside this region)
; referenced by `lda $D4E3,x` at $C2A7 (operand $D4E3 falls inside this region)
; referenced by `lda $D4E3,x` at $C2B0 (operand $D4E3 falls inside this region)
; referenced by `lda $D5C4,x` at $CB5D (operand $D5C4 falls inside this region)
; referenced by `lda $D5C4,x` at $CB66 (operand $D5C4 falls inside this region)
MasterPaletteStream:
.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, $FF ; CPU:$CF26 PRG:0F26 30 00 30 FF
JoypadPanelScreenOneStream:
.byte $20, $A2, $1C, $60, $61, $61, $61, $61, $61, $61, $61, $61 ; CPU:$CF2A PRG:0F2A 20 A2 1C 60 61 61 61 61 61 61 61 61
.byte $61, $61, $61, $61, $61, $61, $61, $61, $61, $61, $61, $61, $61, $61, $61, $61 ; CPU:$CF36 PRG:0F36 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61
.byte $61, $61, $66, $20, $C2, $1C, $64, $70, $71, $72, $73, $74, $75, $76, $77, $78 ; CPU:$CF46 PRG:0F46 61 61 66 20 C2 1C 64 70 71 72 73 74 75 76 77 78
.byte $79, $7A, $7B, $24, $7D, $7E, $7F, $A0, $A1, $A2, $A3, $A4, $A5, $A6, $A7, $A8 ; CPU:$CF56 PRG:0F56 79 7A 7B 24 7D 7E 7F A0 A1 A2 A3 A4 A5 A6 A7 A8
.byte $A9, $67, $20, $E2, $1C, $64, $80, $81, $82, $83, $84, $85, $86, $87, $88, $89 ; CPU:$CF66 PRG:0F66 A9 67 20 E2 1C 64 80 81 82 83 84 85 86 87 88 89
.byte $8A, $8B, $24, $8D, $8E, $8F, $B0, $B1, $24, $B3, $B4, $B5, $B6, $B7, $B8, $B9 ; CPU:$CF76 PRG:0F76 8A 8B 24 8D 8E 8F B0 B1 24 B3 B4 B5 B6 B7 B8 B9
.byte $67, $21, $02, $1C, $64, $90, $91, $92, $93, $94, $95, $96, $97, $98, $99, $9A ; CPU:$CF86 PRG:0F86 67 21 02 1C 64 90 91 92 93 94 95 96 97 98 99 9A
.byte $9B, $9C, $9D, $9E, $9F, $C0, $C1, $24, $C3, $C4, $C5, $C6, $C7, $C8, $C9, $67 ; CPU:$CF96 PRG:0F96 9B 9C 9D 9E 9F C0 C1 24 C3 C4 C5 C6 C7 C8 C9 67
.byte $21, $22, $1C, $62, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63 ; CPU:$CFA6 PRG:0FA6 21 22 1C 62 63 63 63 63 63 63 63 63 63 63 63 63
.byte $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $63, $65, $21 ; CPU:$CFB6 PRG:0FB6 63 63 63 63 63 63 63 63 63 63 63 63 63 63 65 21
.byte $C5, $18, $01, $24, $17, $18, $1B, $16, $0A, $15, $24, $0C, $18, $17, $1D, $1B ; CPU:$CFC6 PRG:0FC6 C5 18 01 24 17 18 1B 16 0A 15 24 0C 18 17 1D 1B
.byte $18, $15, $15, $0E, $1B, $24, $1D, $0E, $1C, $1D, $22, $25, $18, $02, $24, $04 ; CPU:$CFD6 PRG:0FD6 18 15 15 0E 1B 24 1D 0E 1C 1D 22 25 18 02 24 04
.byte $24, $19, $15, $0A, $22, $24, $0C, $18, $17, $1D, $1B, $18, $15, $15, $0E, $1B ; CPU:$CFE6 PRG:0FE6 24 19 15 0A 22 24 0C 18 17 1D 1B 18 15 15 0E 1B
.byte $24, $1D, $0E, $1C, $1D, $22, $85, $18, $03, $24, $1B, $0E, $1D, $1E, $1B, $17 ; CPU:$CFF6 PRG:0FF6 24 1D 0E 1C 1D 22 85 18 03 24 1B 0E 1D 1E 1B 17
.byte $24, $1D, $18, $24, $16, $0A, $12, $17, $24, $16, $0E, $17, $1E, $24, $24, $24 ; CPU:$D006 PRG:1006 24 1D 18 24 16 0A 12 17 24 16 0E 17 1E 24 24 24
.byte $23, $C0, $10, $00, $00, $00, $00, $00, $00, $00, $00, $44, $55, $55, $55, $55 ; CPU:$D016 PRG:1016 23 C0 10 00 00 00 00 00 00 00 00 44 55 55 55 55
.byte $55, $55, $11, $23, $D0, $10, $04, $05, $05, $05, $05, $05, $05, $01, $00, $00 ; CPU:$D026 PRG:1026 55 55 11 23 D0 10 04 05 05 05 05 05 05 01 00 00
.byte $00, $00, $00, $00, $00, $00, $23, $E0, $10, $00, $00, $00, $00, $00, $00, $00 ; CPU:$D036 PRG:1036 00 00 00 00 00 00 23 E0 10 00 00 00 00 00 00 00
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $23, $F0, $10, $00, $00, $00, $00 ; CPU:$D046 PRG:1046 00 00 00 00 00 00 00 00 00 23 F0 10 00 00 00 00
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $FF ; CPU:$D056 PRG:1056 00 00 00 00 00 00 00 00 00 00 00 00 FF
JoypadPanelScreenTwoStream:
.byte $20, $62, $1A ; CPU:$D063 PRG:1063 20 62 1A
.byte $1D, $1E, $1B, $0B, $18, $24, $1C, $24, $0B, $24, $0A, $24, $24, $02, $24, $19 ; CPU:$D066 PRG:1066 1D 1E 1B 0B 18 24 1C 24 0B 24 0A 24 24 02 24 19
.byte $15, $0A, $22, $0E, $1B, $24, $1D, $0E, $1C, $1D, $20, $8F, $0D, $40, $42, $42 ; CPU:$D076 PRG:1076 15 0A 22 0E 1B 24 1D 0E 1C 1D 20 8F 0D 40 42 42
.byte $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $20, $AF, $0D, $47, $24, $24 ; CPU:$D086 PRG:1086 42 42 42 42 42 42 42 42 42 41 20 AF 0D 47 24 24
.byte $24, $24, $24, $01, $24, $28, $29, $2A, $2B, $46, $20, $CF, $0D, $47, $24, $4A ; CPU:$D096 PRG:1096 24 24 24 01 24 28 29 2A 2B 46 20 CF 0D 47 24 4A
.byte $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $20, $EF, $0D, $47, $24, $24 ; CPU:$D0A6 PRG:10A6 24 24 24 24 24 24 24 24 24 46 20 EF 0D 47 24 24
.byte $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $21, $0F, $0D, $44, $43, $43 ; CPU:$D0B6 PRG:10B6 24 24 24 26 24 24 24 26 24 46 21 0F 0D 44 43 43
.byte $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $21, $4F, $0D, $40, $42, $42 ; CPU:$D0C6 PRG:10C6 43 43 43 43 43 43 43 43 43 45 21 4F 0D 40 42 42
.byte $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $21, $6F, $0D, $47, $24, $24 ; CPU:$D0D6 PRG:10D6 42 42 42 42 42 42 42 42 42 41 21 6F 0D 47 24 24
.byte $24, $24, $24, $02, $24, $28, $29, $2A, $2B, $46, $21, $8F, $0D, $47, $24, $4A ; CPU:$D0E6 PRG:10E6 24 24 24 02 24 28 29 2A 2B 46 21 8F 0D 47 24 4A
.byte $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $21, $AF, $0D, $47, $24, $24 ; CPU:$D0F6 PRG:10F6 24 24 24 24 24 24 24 24 24 46 21 AF 0D 47 24 24
.byte $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $21, $CF, $0D, $44, $43, $43 ; CPU:$D106 PRG:1106 24 24 24 26 24 24 24 26 24 46 21 CF 0D 44 43 43
.byte $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $20, $A6, $01, $D1, $21, $06 ; CPU:$D116 PRG:1116 43 43 43 43 43 43 43 43 43 45 20 A6 01 D1 21 06
.byte $01, $2C, $21, $66, $01, $D1, $21, $C6, $01, $2C, $20, $87, $07, $58, $53, $5A ; CPU:$D126 PRG:1126 01 2C 21 66 01 D1 21 C6 01 2C 20 87 07 58 53 5A
.byte $53, $5A, $53, $57, $20, $A7, $07, $50, $24, $54, $24, $54, $24, $51, $20, $C7 ; CPU:$D136 PRG:1136 53 5A 53 57 20 A7 07 50 24 54 24 54 24 51 20 C7
.byte $07, $50, $24, $54, $24, $54, $24, $51, $20, $E7, $07, $50, $24, $54, $24, $54 ; CPU:$D146 PRG:1146 07 50 24 54 24 54 24 51 20 E7 07 50 24 54 24 54
.byte $24, $51, $21, $07, $07, $50, $24, $54, $24, $54, $24, $51, $21, $27, $07, $56 ; CPU:$D156 PRG:1156 24 51 21 07 07 50 24 54 24 54 24 51 21 27 07 56
.byte $52, $59, $52, $59, $52, $55, $21, $47, $07, $58, $53, $5A, $53, $5A, $53, $57 ; CPU:$D166 PRG:1166 52 59 52 59 52 55 21 47 07 58 53 5A 53 5A 53 57
.byte $21, $67, $07, $50, $24, $54, $24, $54, $24, $51, $21, $87, $07, $50, $24, $54 ; CPU:$D176 PRG:1176 21 67 07 50 24 54 24 54 24 51 21 87 07 50 24 54
.byte $24, $54, $24, $51, $21, $A7, $07, $50, $24, $54, $24, $54, $24, $51, $21, $C7 ; CPU:$D186 PRG:1186 24 54 24 51 21 A7 07 50 24 54 24 54 24 51 21 C7
.byte $07, $50, $24, $54, $24, $54, $24, $51, $21, $E7, $07, $56, $52, $59, $52, $59 ; CPU:$D196 PRG:1196 07 50 24 54 24 54 24 51 21 E7 07 56 52 59 52 59
.byte $52, $55, $23, $C0, $10, $40, $50, $50, $50, $50, $50, $50, $00, $00, $00, $00 ; CPU:$D1A6 PRG:11A6 52 55 23 C0 10 40 50 50 50 50 50 50 00 00 00 00
.byte $00, $00, $03, $00, $00, $23, $D0, $10, $00, $00, $00, $00, $00, $30, $00, $00 ; CPU:$D1B6 PRG:11B6 00 00 03 00 00 23 D0 10 00 00 00 00 00 30 00 00
.byte $00, $00, $00, $00, $00, $00, $00, $00, $23, $E0, $10, $00, $00, $00, $00, $00 ; CPU:$D1C6 PRG:11C6 00 00 00 00 00 00 00 00 23 E0 10 00 00 00 00 00
.byte $03, $00, $00, $00, $00, $00, $00, $00, $30, $00, $00, $23, $F0, $10, $00, $00 ; CPU:$D1D6 PRG:11D6 03 00 00 00 00 00 00 00 30 00 00 23 F0 10 00 00
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $FF ; CPU:$D1E6 PRG:11E6 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FF
JoypadPanelScreenThreeStream:
.byte $20 ; CPU:$D1F5 PRG:11F5 20
.byte $62, $1A, $1D, $1E, $1B, $0B, $18, $24, $1C, $24, $0B, $24, $0A, $24, $24, $04 ; CPU:$D1F6 PRG:11F6 62 1A 1D 1E 1B 0B 18 24 1C 24 0B 24 0A 24 24 04
.byte $24, $19, $15, $0A, $22, $0E, $1B, $24, $1D, $0E, $1C, $1D, $20, $8F, $0D, $40 ; CPU:$D206 PRG:1206 24 19 15 0A 22 0E 1B 24 1D 0E 1C 1D 20 8F 0D 40
.byte $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $20, $AF, $0D, $47 ; CPU:$D216 PRG:1216 42 42 42 42 42 42 42 42 42 42 42 41 20 AF 0D 47
.byte $24, $24, $24, $24, $24, $01, $24, $28, $29, $2A, $2B, $46, $20, $CF, $0D, $47 ; CPU:$D226 PRG:1226 24 24 24 24 24 01 24 28 29 2A 2B 46 20 CF 0D 47
.byte $24, $4A, $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $20, $EF, $0D, $47 ; CPU:$D236 PRG:1236 24 4A 24 24 24 24 24 24 24 24 24 46 20 EF 0D 47
.byte $24, $24, $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $21, $0F, $0D, $44 ; CPU:$D246 PRG:1246 24 24 24 24 24 26 24 24 24 26 24 46 21 0F 0D 44
.byte $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $21, $4F, $0D, $40 ; CPU:$D256 PRG:1256 43 43 43 43 43 43 43 43 43 43 43 45 21 4F 0D 40
.byte $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $21, $6F, $0D, $47 ; CPU:$D266 PRG:1266 42 42 42 42 42 42 42 42 42 42 42 41 21 6F 0D 47
.byte $24, $24, $24, $24, $24, $02, $24, $28, $29, $2A, $2B, $46, $21, $8F, $0D, $47 ; CPU:$D276 PRG:1276 24 24 24 24 24 02 24 28 29 2A 2B 46 21 8F 0D 47
.byte $24, $4A, $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $21, $AF, $0D, $47 ; CPU:$D286 PRG:1286 24 4A 24 24 24 24 24 24 24 24 24 46 21 AF 0D 47
.byte $24, $24, $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $21, $CF, $0D, $44 ; CPU:$D296 PRG:1296 24 24 24 24 24 26 24 24 24 26 24 46 21 CF 0D 44
.byte $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $22, $0F, $0D, $40 ; CPU:$D2A6 PRG:12A6 43 43 43 43 43 43 43 43 43 43 43 45 22 0F 0D 40
.byte $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $22, $2F, $0D, $47 ; CPU:$D2B6 PRG:12B6 42 42 42 42 42 42 42 42 42 42 42 41 22 2F 0D 47
.byte $24, $24, $24, $24, $24, $03, $24, $28, $29, $2A, $2B, $46, $22, $4F, $0D, $47 ; CPU:$D2C6 PRG:12C6 24 24 24 24 24 03 24 28 29 2A 2B 46 22 4F 0D 47
.byte $24, $4A, $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $22, $6F, $0D, $47 ; CPU:$D2D6 PRG:12D6 24 4A 24 24 24 24 24 24 24 24 24 46 22 6F 0D 47
.byte $24, $24, $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $22, $8F, $0D, $44 ; CPU:$D2E6 PRG:12E6 24 24 24 24 24 26 24 24 24 26 24 46 22 8F 0D 44
.byte $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $22, $CF, $0D, $40 ; CPU:$D2F6 PRG:12F6 43 43 43 43 43 43 43 43 43 43 43 45 22 CF 0D 40
.byte $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $42, $41, $22, $EF, $0D, $47 ; CPU:$D306 PRG:1306 42 42 42 42 42 42 42 42 42 42 42 41 22 EF 0D 47
.byte $24, $24, $24, $24, $24, $04, $24, $28, $29, $2A, $2B, $46, $23, $0F, $0D, $47 ; CPU:$D316 PRG:1316 24 24 24 24 24 04 24 28 29 2A 2B 46 23 0F 0D 47
.byte $24, $4A, $24, $24, $24, $24, $24, $24, $24, $24, $24, $46, $23, $2F, $0D, $47 ; CPU:$D326 PRG:1326 24 4A 24 24 24 24 24 24 24 24 24 46 23 2F 0D 47
.byte $24, $24, $24, $24, $24, $26, $24, $24, $24, $26, $24, $46, $23, $4F, $0D, $44 ; CPU:$D336 PRG:1336 24 24 24 24 24 26 24 24 24 26 24 46 23 4F 0D 44
.byte $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $43, $45, $20, $A6, $01, $D1 ; CPU:$D346 PRG:1346 43 43 43 43 43 43 43 43 43 43 43 45 20 A6 01 D1
.byte $21, $06, $01, $2C, $21, $66, $01, $D1, $21, $C6, $01, $2C, $22, $26, $01, $D1 ; CPU:$D356 PRG:1356 21 06 01 2C 21 66 01 D1 21 C6 01 2C 22 26 01 D1
.byte $22, $86, $01, $2C, $22, $E6, $01, $D1, $23, $46, $01, $2C, $20, $87, $07, $58 ; CPU:$D366 PRG:1366 22 86 01 2C 22 E6 01 D1 23 46 01 2C 20 87 07 58
.byte $53, $5A, $53, $5A, $53, $57, $20, $A7, $07, $50, $24, $54, $24, $54, $24, $51 ; CPU:$D376 PRG:1376 53 5A 53 5A 53 57 20 A7 07 50 24 54 24 54 24 51
.byte $20, $C7, $07, $50, $24, $54, $24, $54, $24, $51, $20, $E7, $07, $50, $24, $54 ; CPU:$D386 PRG:1386 20 C7 07 50 24 54 24 54 24 51 20 E7 07 50 24 54
.byte $24, $54, $24, $51, $21, $07, $07, $50, $24, $54, $24, $54, $24, $51, $21, $27 ; CPU:$D396 PRG:1396 24 54 24 51 21 07 07 50 24 54 24 54 24 51 21 27
.byte $07, $56, $52, $59, $52, $59, $52, $55, $21, $47, $07, $58, $53, $5A, $53, $5A ; CPU:$D3A6 PRG:13A6 07 56 52 59 52 59 52 55 21 47 07 58 53 5A 53 5A
.byte $53, $57, $21, $67, $07, $50, $24, $54, $24, $54, $24, $51, $21, $87, $07, $50 ; CPU:$D3B6 PRG:13B6 53 57 21 67 07 50 24 54 24 54 24 51 21 87 07 50
.byte $24, $54, $24, $54, $24, $51, $21, $A7, $07, $50, $24, $54, $24, $54, $24, $51 ; CPU:$D3C6 PRG:13C6 24 54 24 54 24 51 21 A7 07 50 24 54 24 54 24 51
.byte $21, $C7, $07, $50, $24, $54, $24, $54, $24, $51, $21, $E7, $07, $56, $52, $59 ; CPU:$D3D6 PRG:13D6 21 C7 07 50 24 54 24 54 24 51 21 E7 07 56 52 59
.byte $52, $59, $52, $55, $22, $07, $07, $58, $53, $5A, $53, $5A, $53, $57, $22, $27 ; CPU:$D3E6 PRG:13E6 52 59 52 55 22 07 07 58 53 5A 53 5A 53 57 22 27
.byte $07, $50, $24, $54, $24, $54, $24, $51, $22, $47, $07, $50, $24, $54, $24, $54 ; CPU:$D3F6 PRG:13F6 07 50 24 54 24 54 24 51 22 47 07 50 24 54 24 54
.byte $24, $51, $22, $67, $07, $50, $24, $54, $24, $54, $24, $51, $22, $87, $07, $50 ; CPU:$D406 PRG:1406 24 51 22 67 07 50 24 54 24 54 24 51 22 87 07 50
.byte $24, $54, $24, $54, $24, $51, $22, $A7, $07, $56, $52, $59, $52, $59, $52, $55 ; CPU:$D416 PRG:1416 24 54 24 54 24 51 22 A7 07 56 52 59 52 59 52 55
.byte $22, $C7, $07, $58, $53, $5A, $53, $5A, $53, $57, $22, $E7, $07, $50, $24, $54 ; CPU:$D426 PRG:1426 22 C7 07 58 53 5A 53 5A 53 57 22 E7 07 50 24 54
.byte $24, $54, $24, $51, $23, $07, $07, $50, $24, $54, $24, $54, $24, $51, $23, $27 ; CPU:$D436 PRG:1436 24 54 24 51 23 07 07 50 24 54 24 54 24 51 23 27
.byte $07, $50, $24, $54, $24, $54, $24, $51, $23, $47, $07, $50, $24, $54, $24, $54 ; CPU:$D446 PRG:1446 07 50 24 54 24 54 24 51 23 47 07 50 24 54 24 54
.byte $24, $51, $23, $67, $07, $56, $52, $59, $52, $59, $52, $55, $23, $C0, $10, $40 ; CPU:$D456 PRG:1456 24 51 23 67 07 56 52 59 52 59 52 55 23 C0 10 40
.byte $50, $50, $50, $50, $50, $50, $00, $00, $00, $00, $00, $00, $03, $00, $00, $23 ; CPU:$D466 PRG:1466 50 50 50 50 50 50 00 00 00 00 00 00 03 00 00 23
.byte $D0, $10, $00, $00, $00, $00, $00, $30, $00, $00, $00, $00, $00, $00, $00, $00 ; CPU:$D476 PRG:1476 D0 10 00 00 00 00 00 30 00 00 00 00 00 00 00 00
.byte $00, $00, $23, $E0, $10, $00, $00, $00, $00, $00, $03, $00, $00, $00, $00, $00 ; CPU:$D486 PRG:1486 00 00 23 E0 10 00 00 00 00 00 03 00 00 00 00 00
.byte $00, $00, $30, $00, $00, $23, $F0, $10, $00, $00, $00, $00, $00, $00, $00, $00 ; CPU:$D496 PRG:1496 00 00 30 00 00 23 F0 10 00 00 00 00 00 00 00 00
.byte $00, $00, $00, $00, $00, $00, $00, $00, $FF ; CPU:$D4A6 PRG:14A6 00 00 00 00 00 00 00 00 FF
MarkerTileBurstStream:
.byte $A5, $24, $54, $24, $54, $24, $24 ; CPU:$D4AF PRG:14AF A5 24 54 24 54 24 24
.byte $54, $24, $54, $24, $24, $54, $24, $54, $24, $24, $54, $24, $54, $24, $52, $59 ; CPU:$D4B6 PRG:14B6 54 24 54 24 24 54 24 54 24 24 54 24 54 24 52 59
.byte $52, $59, $52, $53, $5A, $53, $5A, $53, $24, $54, $24, $54, $24, $24, $54, $24 ; CPU:$D4C6 PRG:14C6 52 59 52 53 5A 53 5A 53 24 54 24 54 24 24 54 24
.byte $54, $24, $24, $54, $24, $54, $24, $24, $54, $24, $54, $24, $FF ; CPU:$D4D6 PRG:14D6 54 24 24 54 24 54 24 24 54 24 54 24 FF
MarkerSpriteTable:
.byte $37, $4D, $03 ; CPU:$D4E3 PRG:14E3 37 4D 03
.byte $D0, $37, $4D, $03, $C0, $37, $4E, $03, $B0, $37, $4E, $03, $A0, $27, $48, $03 ; CPU:$D4E6 PRG:14E6 D0 37 4D 03 C0 37 4E 03 B0 37 4E 03 A0 27 48 03
.byte $88, $37, $4C, $03, $88, $2F, $49, $03, $80, $2F, $4B, $03, $90, $67, $4D, $03 ; CPU:$D4F6 PRG:14F6 88 37 4C 03 88 2F 49 03 80 2F 4B 03 90 67 4D 03
.byte $D0, $67, $4D, $03, $C0, $67, $4E, $03, $B0, $67, $4E, $03, $A0, $57, $48, $03 ; CPU:$D506 PRG:1506 D0 67 4D 03 C0 67 4E 03 B0 67 4E 03 A0 57 48 03
.byte $88, $67, $4C, $03, $88, $5F, $49, $03, $80, $5F, $4B, $03, $90, $97, $4D, $03 ; CPU:$D516 PRG:1516 88 67 4C 03 88 5F 49 03 80 5F 4B 03 90 97 4D 03
.byte $D0, $97, $4D, $03, $C0, $97, $4E, $03, $B0, $97, $4E, $03, $A0, $87, $48, $03 ; CPU:$D526 PRG:1526 D0 97 4D 03 C0 97 4E 03 B0 97 4E 03 A0 87 48 03
.byte $88, $97, $4C, $03, $88, $8F, $49, $03, $80, $8F, $4B, $03, $90, $C7, $4D, $03 ; CPU:$D536 PRG:1536 88 97 4C 03 88 8F 49 03 80 8F 4B 03 90 C7 4D 03
.byte $D0, $C7, $4D, $03, $C0, $C7, $4E, $03, $B0, $C7, $4E, $03, $A0, $B7, $48, $03 ; CPU:$D546 PRG:1546 D0 C7 4D 03 C0 C7 4E 03 B0 C7 4E 03 A0 B7 48 03
.byte $88, $C7, $4C, $03, $88, $BF, $49, $03, $80, $BF, $4B, $03, $90, $27, $30, $00 ; CPU:$D556 PRG:1556 88 C7 4C 03 88 BF 49 03 80 BF 4B 03 90 27 30 00
.byte $40, $2F, $30, $00, $40, $37, $30, $00, $40, $3F, $30, $00, $40, $27, $30, $00 ; CPU:$D566 PRG:1566 40 2F 30 00 40 37 30 00 40 3F 30 00 40 27 30 00
.byte $50, $2F, $30, $00, $50, $37, $30, $00, $50, $3F, $30, $00, $50, $27, $30, $00 ; CPU:$D576 PRG:1576 50 2F 30 00 50 37 30 00 50 3F 30 00 50 27 30 00
.byte $60, $2F, $30, $00, $60, $37, $30, $00, $60, $3F, $30, $00, $60, $57, $30, $00 ; CPU:$D586 PRG:1586 60 2F 30 00 60 37 30 00 60 3F 30 00 60 57 30 00
.byte $40, $5F, $30, $00, $40, $67, $30, $00, $40, $6F, $30, $00, $40, $57, $30, $00 ; CPU:$D596 PRG:1596 40 5F 30 00 40 67 30 00 40 6F 30 00 40 57 30 00
.byte $50, $5F, $30, $00, $50, $67, $30, $00, $50, $6F, $30, $00, $50, $57, $30, $00 ; CPU:$D5A6 PRG:15A6 50 5F 30 00 50 67 30 00 50 6F 30 00 50 57 30 00
.byte $60, $5F, $30, $00, $60, $67, $30, $00, $60, $6F, $30, $00, $60, $FF ; CPU:$D5B6 PRG:15B6 60 5F 30 00 60 67 30 00 60 6F 30 00 60 FF
MarkerSpriteTableAlt:
.byte $37, $4D ; CPU:$D5C4 PRG:15C4 37 4D
.byte $03, $D0, $37, $4D, $03, $C0, $37, $4E, $03, $B0, $37, $4E, $03, $A0, $27, $48 ; CPU:$D5C6 PRG:15C6 03 D0 37 4D 03 C0 37 4E 03 B0 37 4E 03 A0 27 48
.byte $03, $88, $37, $4C, $03, $88, $2F, $49, $03, $80, $2F, $4B, $03, $90, $67, $4D ; CPU:$D5D6 PRG:15D6 03 88 37 4C 03 88 2F 49 03 80 2F 4B 03 90 67 4D
.byte $03, $D0, $67, $4D, $03, $C0, $67, $4E, $03, $B0, $67, $4E, $03, $A0, $57, $48 ; CPU:$D5E6 PRG:15E6 03 D0 67 4D 03 C0 67 4E 03 B0 67 4E 03 A0 57 48
.byte $03, $88, $67, $4C, $03, $88, $5F, $49, $03, $80, $5F, $4B, $03, $90, $F4, $F4 ; CPU:$D5F6 PRG:15F6 03 88 67 4C 03 88 5F 49 03 80 5F 4B 03 90 F4 F4
.byte $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4, $F4 ; CPU:$D606 PRG:1606 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:$D616 PRG:1616 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:$D626 PRG:1626 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, $27, $30 ; CPU:$D636 PRG:1636 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 F4 27 30
.byte $00, $40, $2F, $30, $00, $40, $37, $30, $00, $40, $3F, $30, $00, $40, $27, $30 ; CPU:$D646 PRG:1646 00 40 2F 30 00 40 37 30 00 40 3F 30 00 40 27 30
.byte $00, $50, $2F, $30, $00, $50, $37, $30, $00, $50, $3F, $30, $00, $50, $27, $30 ; CPU:$D656 PRG:1656 00 50 2F 30 00 50 37 30 00 50 3F 30 00 50 27 30
.byte $00, $60, $2F, $30, $00, $60, $37, $30, $00, $60, $3F, $30, $00, $60, $57, $30 ; CPU:$D666 PRG:1666 00 60 2F 30 00 60 37 30 00 60 3F 30 00 60 57 30
.byte $00, $40, $5F, $30, $00, $40, $67, $30, $00, $40, $6F, $30, $00, $40, $57, $30 ; CPU:$D676 PRG:1676 00 40 5F 30 00 40 67 30 00 40 6F 30 00 40 57 30
.byte $00, $50, $5F, $30, $00, $50, $67, $30, $00, $50, $6F, $30, $00, $50, $57, $30 ; CPU:$D686 PRG:1686 00 50 5F 30 00 50 67 30 00 50 6F 30 00 50 57 30
.byte $00, $60, $5F, $30, $00, $60, $67, $30, $00, $60, $6F, $30, $00, $60, $FF ; CPU:$D696 PRG:1696 00 60 5F 30 00 60 67 30 00 60 6F 30 00 60 FF
ButtonLabelSpriteTemplate:
.byte $79 ; CPU:$D6A5 PRG:16A5 79
.byte $1D, $00, $18, $79, $0E, $00, $20, $79, $1C, $00, $28, $79, $1D, $00, $30, $79 ; CPU:$D6A6 PRG:16A6 1D 00 18 79 0E 00 20 79 1C 00 28 79 1D 00 30 79
.byte $18, $00, $40, $79, $1F, $00, $48, $79, $0E, $00, $50, $79, $1B, $00, $58 ; CPU:$D6B6 PRG:16B6 18 00 40 79 1F 00 48 79 0E 00 50 79 1B 00 58
ButtonStateSpriteTemplate:
.byte $79 ; CPU:$D6C5 PRG:16C5 79
.byte $0C, $00, $18, $79, $18, $00, $20, $79, $17, $00, $28, $79, $1D, $00, $30, $79 ; CPU:$D6C6 PRG:16C6 0C 00 18 79 18 00 20 79 17 00 28 79 1D 00 30 79
.byte $0B, $00, $40, $79, $0A, $00, $48, $79, $0D, $00, $50, $79, $24, $00, $58 ; CPU:$D6D6 PRG:16D6 0B 00 40 79 0A 00 48 79 0D 00 50 79 24 00 58
RomPadding:
.byte $FF ; CPU:$D6E5 PRG:16E5 FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D6E6 PRG:16E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D6F6 PRG:16F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D706 PRG:1706 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D716 PRG:1716 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D726 PRG:1726 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D736 PRG:1736 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D746 PRG:1746 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D756 PRG:1756 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D766 PRG:1766 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D776 PRG:1776 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D786 PRG:1786 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D796 PRG:1796 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7A6 PRG:17A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7B6 PRG:17B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7C6 PRG:17C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7D6 PRG:17D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7E6 PRG:17E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D7F6 PRG:17F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D806 PRG:1806 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D816 PRG:1816 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D826 PRG:1826 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D836 PRG:1836 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D846 PRG:1846 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D856 PRG:1856 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D866 PRG:1866 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D876 PRG:1876 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D886 PRG:1886 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D896 PRG:1896 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8A6 PRG:18A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8B6 PRG:18B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8C6 PRG:18C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8D6 PRG:18D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8E6 PRG:18E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D8F6 PRG:18F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D906 PRG:1906 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D916 PRG:1916 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D926 PRG:1926 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D936 PRG:1936 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D946 PRG:1946 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D956 PRG:1956 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D966 PRG:1966 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D976 PRG:1976 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D986 PRG:1986 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D996 PRG:1996 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9A6 PRG:19A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9B6 PRG:19B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9C6 PRG:19C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9D6 PRG:19D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9E6 PRG:19E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$D9F6 PRG:19F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA06 PRG:1A06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA16 PRG:1A16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA26 PRG:1A26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA36 PRG:1A36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA46 PRG:1A46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA56 PRG:1A56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA66 PRG:1A66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA76 PRG:1A76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA86 PRG:1A86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DA96 PRG:1A96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAA6 PRG:1AA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAB6 PRG:1AB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAC6 PRG:1AC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAD6 PRG:1AD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAE6 PRG:1AE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DAF6 PRG:1AF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB06 PRG:1B06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB16 PRG:1B16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB26 PRG:1B26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB36 PRG:1B36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB46 PRG:1B46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB56 PRG:1B56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB66 PRG:1B66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB76 PRG:1B76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB86 PRG:1B86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DB96 PRG:1B96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBA6 PRG:1BA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBB6 PRG:1BB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBC6 PRG:1BC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBD6 PRG:1BD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBE6 PRG:1BE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DBF6 PRG:1BF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC06 PRG:1C06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC16 PRG:1C16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC26 PRG:1C26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC36 PRG:1C36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC46 PRG:1C46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC56 PRG:1C56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC66 PRG:1C66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC76 PRG:1C76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC86 PRG:1C86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DC96 PRG:1C96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCA6 PRG:1CA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCB6 PRG:1CB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCC6 PRG:1CC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCD6 PRG:1CD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCE6 PRG:1CE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DCF6 PRG:1CF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD06 PRG:1D06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD16 PRG:1D16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD26 PRG:1D26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD36 PRG:1D36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD46 PRG:1D46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD56 PRG:1D56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD66 PRG:1D66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD76 PRG:1D76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD86 PRG:1D86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DD96 PRG:1D96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDA6 PRG:1DA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDB6 PRG:1DB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDC6 PRG:1DC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDD6 PRG:1DD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDE6 PRG:1DE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DDF6 PRG:1DF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE06 PRG:1E06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE16 PRG:1E16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE26 PRG:1E26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE36 PRG:1E36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE46 PRG:1E46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE56 PRG:1E56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE66 PRG:1E66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE76 PRG:1E76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE86 PRG:1E86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DE96 PRG:1E96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DEA6 PRG:1EA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DEB6 PRG:1EB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DEC6 PRG:1EC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DED6 PRG:1ED6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DEE6 PRG:1EE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DEF6 PRG:1EF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF06 PRG:1F06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF16 PRG:1F16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF26 PRG:1F26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF36 PRG:1F36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF46 PRG:1F46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF56 PRG:1F56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF66 PRG:1F66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF76 PRG:1F76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF86 PRG:1F86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DF96 PRG:1F96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFA6 PRG:1FA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFB6 PRG:1FB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFC6 PRG:1FC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFD6 PRG:1FD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFE6 PRG:1FE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$DFF6 PRG:1FF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E006 PRG:2006 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E016 PRG:2016 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E026 PRG:2026 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E036 PRG:2036 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E046 PRG:2046 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E056 PRG:2056 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E066 PRG:2066 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E076 PRG:2076 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E086 PRG:2086 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E096 PRG:2096 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0A6 PRG:20A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0B6 PRG:20B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0C6 PRG:20C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0D6 PRG:20D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0E6 PRG:20E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E0F6 PRG:20F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E106 PRG:2106 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E116 PRG:2116 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E126 PRG:2126 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E136 PRG:2136 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E146 PRG:2146 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E156 PRG:2156 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E166 PRG:2166 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E176 PRG:2176 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E186 PRG:2186 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E196 PRG:2196 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1A6 PRG:21A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1B6 PRG:21B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1C6 PRG:21C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1D6 PRG:21D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1E6 PRG:21E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E1F6 PRG:21F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E206 PRG:2206 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E216 PRG:2216 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E226 PRG:2226 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E236 PRG:2236 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E246 PRG:2246 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E256 PRG:2256 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E266 PRG:2266 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E276 PRG:2276 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E286 PRG:2286 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E296 PRG:2296 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2A6 PRG:22A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2B6 PRG:22B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2C6 PRG:22C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2D6 PRG:22D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2E6 PRG:22E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E2F6 PRG:22F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E306 PRG:2306 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E316 PRG:2316 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E326 PRG:2326 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E336 PRG:2336 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E346 PRG:2346 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E356 PRG:2356 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E366 PRG:2366 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E376 PRG:2376 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E386 PRG:2386 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E396 PRG:2396 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3A6 PRG:23A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3B6 PRG:23B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3C6 PRG:23C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3D6 PRG:23D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3E6 PRG:23E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E3F6 PRG:23F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E406 PRG:2406 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E416 PRG:2416 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E426 PRG:2426 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E436 PRG:2436 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E446 PRG:2446 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E456 PRG:2456 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E466 PRG:2466 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E476 PRG:2476 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E486 PRG:2486 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E496 PRG:2496 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4A6 PRG:24A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4B6 PRG:24B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4C6 PRG:24C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4D6 PRG:24D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4E6 PRG:24E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E4F6 PRG:24F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E506 PRG:2506 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E516 PRG:2516 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E526 PRG:2526 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E536 PRG:2536 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E546 PRG:2546 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E556 PRG:2556 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E566 PRG:2566 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E576 PRG:2576 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E586 PRG:2586 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E596 PRG:2596 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5A6 PRG:25A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5B6 PRG:25B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5C6 PRG:25C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5D6 PRG:25D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5E6 PRG:25E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E5F6 PRG:25F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E606 PRG:2606 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E616 PRG:2616 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E626 PRG:2626 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E636 PRG:2636 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E646 PRG:2646 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E656 PRG:2656 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E666 PRG:2666 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E676 PRG:2676 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E686 PRG:2686 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E696 PRG:2696 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6A6 PRG:26A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6B6 PRG:26B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6C6 PRG:26C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6D6 PRG:26D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6E6 PRG:26E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E6F6 PRG:26F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E706 PRG:2706 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E716 PRG:2716 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E726 PRG:2726 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E736 PRG:2736 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E746 PRG:2746 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E756 PRG:2756 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E766 PRG:2766 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E776 PRG:2776 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E786 PRG:2786 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E796 PRG:2796 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7A6 PRG:27A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7B6 PRG:27B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7C6 PRG:27C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7D6 PRG:27D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7E6 PRG:27E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E7F6 PRG:27F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E806 PRG:2806 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E816 PRG:2816 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E826 PRG:2826 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E836 PRG:2836 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E846 PRG:2846 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E856 PRG:2856 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E866 PRG:2866 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E876 PRG:2876 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E886 PRG:2886 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E896 PRG:2896 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8A6 PRG:28A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8B6 PRG:28B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8C6 PRG:28C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8D6 PRG:28D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8E6 PRG:28E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E8F6 PRG:28F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E906 PRG:2906 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E916 PRG:2916 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E926 PRG:2926 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E936 PRG:2936 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E946 PRG:2946 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E956 PRG:2956 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E966 PRG:2966 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E976 PRG:2976 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E986 PRG:2986 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E996 PRG:2996 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9A6 PRG:29A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9B6 PRG:29B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9C6 PRG:29C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9D6 PRG:29D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9E6 PRG:29E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$E9F6 PRG:29F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA06 PRG:2A06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA16 PRG:2A16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA26 PRG:2A26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA36 PRG:2A36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA46 PRG:2A46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA56 PRG:2A56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA66 PRG:2A66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA76 PRG:2A76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA86 PRG:2A86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EA96 PRG:2A96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAA6 PRG:2AA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAB6 PRG:2AB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAC6 PRG:2AC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAD6 PRG:2AD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAE6 PRG:2AE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EAF6 PRG:2AF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB06 PRG:2B06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB16 PRG:2B16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB26 PRG:2B26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB36 PRG:2B36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB46 PRG:2B46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB56 PRG:2B56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB66 PRG:2B66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB76 PRG:2B76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB86 PRG:2B86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EB96 PRG:2B96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBA6 PRG:2BA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBB6 PRG:2BB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBC6 PRG:2BC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBD6 PRG:2BD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBE6 PRG:2BE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EBF6 PRG:2BF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC06 PRG:2C06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC16 PRG:2C16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC26 PRG:2C26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC36 PRG:2C36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC46 PRG:2C46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC56 PRG:2C56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC66 PRG:2C66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC76 PRG:2C76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC86 PRG:2C86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EC96 PRG:2C96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECA6 PRG:2CA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECB6 PRG:2CB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECC6 PRG:2CC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECD6 PRG:2CD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECE6 PRG:2CE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ECF6 PRG:2CF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED06 PRG:2D06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED16 PRG:2D16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED26 PRG:2D26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED36 PRG:2D36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED46 PRG:2D46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED56 PRG:2D56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED66 PRG:2D66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED76 PRG:2D76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED86 PRG:2D86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$ED96 PRG:2D96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDA6 PRG:2DA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDB6 PRG:2DB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDC6 PRG:2DC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDD6 PRG:2DD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDE6 PRG:2DE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EDF6 PRG:2DF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE06 PRG:2E06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE16 PRG:2E16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE26 PRG:2E26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE36 PRG:2E36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE46 PRG:2E46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE56 PRG:2E56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE66 PRG:2E66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE76 PRG:2E76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE86 PRG:2E86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EE96 PRG:2E96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EEA6 PRG:2EA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EEB6 PRG:2EB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EEC6 PRG:2EC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EED6 PRG:2ED6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EEE6 PRG:2EE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EEF6 PRG:2EF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF06 PRG:2F06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF16 PRG:2F16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF26 PRG:2F26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF36 PRG:2F36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF46 PRG:2F46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF56 PRG:2F56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF66 PRG:2F66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF76 PRG:2F76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF86 PRG:2F86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EF96 PRG:2F96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFA6 PRG:2FA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFB6 PRG:2FB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFC6 PRG:2FC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFD6 PRG:2FD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFE6 PRG:2FE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$EFF6 PRG:2FF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F006 PRG:3006 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F016 PRG:3016 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F026 PRG:3026 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F036 PRG:3036 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F046 PRG:3046 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F056 PRG:3056 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F066 PRG:3066 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F076 PRG:3076 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F086 PRG:3086 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F096 PRG:3096 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0A6 PRG:30A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0B6 PRG:30B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0C6 PRG:30C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0D6 PRG:30D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0E6 PRG:30E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F0F6 PRG:30F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F106 PRG:3106 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F116 PRG:3116 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F126 PRG:3126 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F136 PRG:3136 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F146 PRG:3146 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F156 PRG:3156 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F166 PRG:3166 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F176 PRG:3176 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F186 PRG:3186 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F196 PRG:3196 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1A6 PRG:31A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1B6 PRG:31B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1C6 PRG:31C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1D6 PRG:31D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1E6 PRG:31E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F1F6 PRG:31F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F206 PRG:3206 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F216 PRG:3216 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F226 PRG:3226 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F236 PRG:3236 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F246 PRG:3246 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F256 PRG:3256 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F266 PRG:3266 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F276 PRG:3276 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F286 PRG:3286 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F296 PRG:3296 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2A6 PRG:32A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2B6 PRG:32B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2C6 PRG:32C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2D6 PRG:32D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2E6 PRG:32E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F2F6 PRG:32F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F306 PRG:3306 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F316 PRG:3316 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F326 PRG:3326 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F336 PRG:3336 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F346 PRG:3346 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F356 PRG:3356 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F366 PRG:3366 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F376 PRG:3376 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F386 PRG:3386 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F396 PRG:3396 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3A6 PRG:33A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3B6 PRG:33B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3C6 PRG:33C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3D6 PRG:33D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3E6 PRG:33E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F3F6 PRG:33F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F406 PRG:3406 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F416 PRG:3416 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F426 PRG:3426 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F436 PRG:3436 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F446 PRG:3446 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F456 PRG:3456 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F466 PRG:3466 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F476 PRG:3476 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F486 PRG:3486 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F496 PRG:3496 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4A6 PRG:34A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4B6 PRG:34B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4C6 PRG:34C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4D6 PRG:34D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4E6 PRG:34E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F4F6 PRG:34F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F506 PRG:3506 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F516 PRG:3516 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F526 PRG:3526 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F536 PRG:3536 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F546 PRG:3546 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F556 PRG:3556 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F566 PRG:3566 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F576 PRG:3576 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F586 PRG:3586 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F596 PRG:3596 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5A6 PRG:35A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5B6 PRG:35B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5C6 PRG:35C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5D6 PRG:35D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5E6 PRG:35E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F5F6 PRG:35F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F606 PRG:3606 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F616 PRG:3616 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F626 PRG:3626 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F636 PRG:3636 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F646 PRG:3646 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F656 PRG:3656 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F666 PRG:3666 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F676 PRG:3676 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F686 PRG:3686 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F696 PRG:3696 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6A6 PRG:36A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6B6 PRG:36B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6C6 PRG:36C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6D6 PRG:36D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6E6 PRG:36E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F6F6 PRG:36F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F706 PRG:3706 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F716 PRG:3716 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F726 PRG:3726 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F736 PRG:3736 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F746 PRG:3746 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F756 PRG:3756 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F766 PRG:3766 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F776 PRG:3776 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F786 PRG:3786 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F796 PRG:3796 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7A6 PRG:37A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7B6 PRG:37B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7C6 PRG:37C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7D6 PRG:37D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7E6 PRG:37E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F7F6 PRG:37F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F806 PRG:3806 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F816 PRG:3816 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F826 PRG:3826 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F836 PRG:3836 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F846 PRG:3846 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F856 PRG:3856 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F866 PRG:3866 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F876 PRG:3876 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F886 PRG:3886 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F896 PRG:3896 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8A6 PRG:38A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8B6 PRG:38B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8C6 PRG:38C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8D6 PRG:38D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8E6 PRG:38E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F8F6 PRG:38F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F906 PRG:3906 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F916 PRG:3916 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F926 PRG:3926 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F936 PRG:3936 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F946 PRG:3946 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F956 PRG:3956 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F966 PRG:3966 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F976 PRG:3976 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F986 PRG:3986 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F996 PRG:3996 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9A6 PRG:39A6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9B6 PRG:39B6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9C6 PRG:39C6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9D6 PRG:39D6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9E6 PRG:39E6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$F9F6 PRG:39F6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA06 PRG:3A06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA16 PRG:3A16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA26 PRG:3A26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA36 PRG:3A36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA46 PRG:3A46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA56 PRG:3A56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA66 PRG:3A66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA76 PRG:3A76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA86 PRG:3A86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FA96 PRG:3A96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAA6 PRG:3AA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAB6 PRG:3AB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAC6 PRG:3AC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAD6 PRG:3AD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAE6 PRG:3AE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FAF6 PRG:3AF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB06 PRG:3B06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB16 PRG:3B16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB26 PRG:3B26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB36 PRG:3B36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB46 PRG:3B46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB56 PRG:3B56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB66 PRG:3B66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB76 PRG:3B76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB86 PRG:3B86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FB96 PRG:3B96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBA6 PRG:3BA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBB6 PRG:3BB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBC6 PRG:3BC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBD6 PRG:3BD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBE6 PRG:3BE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FBF6 PRG:3BF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC06 PRG:3C06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC16 PRG:3C16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC26 PRG:3C26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC36 PRG:3C36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC46 PRG:3C46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC56 PRG:3C56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC66 PRG:3C66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC76 PRG:3C76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC86 PRG:3C86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FC96 PRG:3C96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCA6 PRG:3CA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCB6 PRG:3CB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCC6 PRG:3CC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCD6 PRG:3CD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCE6 PRG:3CE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FCF6 PRG:3CF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD06 PRG:3D06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD16 PRG:3D16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD26 PRG:3D26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD36 PRG:3D36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD46 PRG:3D46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD56 PRG:3D56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD66 PRG:3D66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD76 PRG:3D76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD86 PRG:3D86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FD96 PRG:3D96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDA6 PRG:3DA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDB6 PRG:3DB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDC6 PRG:3DC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDD6 PRG:3DD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDE6 PRG:3DE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FDF6 PRG:3DF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE06 PRG:3E06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE16 PRG:3E16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE26 PRG:3E26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE36 PRG:3E36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE46 PRG:3E46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE56 PRG:3E56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE66 PRG:3E66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE76 PRG:3E76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE86 PRG:3E86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FE96 PRG:3E96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FEA6 PRG:3EA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FEB6 PRG:3EB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FEC6 PRG:3EC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FED6 PRG:3ED6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FEE6 PRG:3EE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FEF6 PRG:3EF6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF06 PRG:3F06 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF16 PRG:3F16 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF26 PRG:3F26 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF36 PRG:3F36 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF46 PRG:3F46 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF56 PRG:3F56 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF66 PRG:3F66 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF76 PRG:3F76 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF86 PRG:3F86 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FF96 PRG:3F96 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FFA6 PRG:3FA6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FFB6 PRG:3FB6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FFC6 PRG:3FC6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FFD6 PRG:3FD6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; CPU:$FFE6 PRG:3FE6 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
.byte $FF, $FF, $FF, $FF ; CPU:$FFF6 PRG:3FF6 FF FF FF FF
CpuVectors:
.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