tmerritt
ad894f47f3
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
1266 lines
23 KiB
Plaintext
1266 lines
23 KiB
Plaintext
C014 Reset
|
|
C01E WaitVBlank_1
|
|
C024 WaitVBlank2_1
|
|
C041 ClearZeropage
|
|
C058 InitAPU_1
|
|
C05E InitAPU_3
|
|
C06D MainGameLoop
|
|
C070 GameLoopEntry_1
|
|
C076 NmiHandler
|
|
C083 NmiFrameUpdate
|
|
C095 NmiFrameUpdate2
|
|
C0D3 GameStateUpdate
|
|
C0FA UpdateGameState3_1
|
|
C100 UpdateGameState4
|
|
C103 UpdateGameState5
|
|
C10A UpdateGameState6
|
|
C126 GameLoopEntry_4
|
|
C138 UpdateGameState2_4
|
|
C141 UpdateGameState2_5
|
|
C148 WaitVBlankFrame2
|
|
C14E InitSprites_1
|
|
C150 CopySprites
|
|
C166 SubCC166
|
|
C1D7 SubCC1D7
|
|
C218 UpdateSprites_1
|
|
C21A UpdateSprites2_1
|
|
C2AB UpdateSprites2_3
|
|
C2B0 SubCC2B0
|
|
C38D SubCC38D
|
|
C437 CheckZp34
|
|
C44A UpdateSprites2_4
|
|
C4C0 UpdateSprites3_1
|
|
C4D7 InitSprites_3
|
|
C542 UpdateSprites_3
|
|
C5A7 UpdateSprites2_5
|
|
C5C9 SubCC5C9
|
|
C5D3 UpdateSprites3_3
|
|
C620 CheckZp14
|
|
C6FB UpdateSprites3_4
|
|
C726 CheckZp55
|
|
C728 UpdateSprites2_7
|
|
C73D UpdateSprites3_5
|
|
C777 UpdateSprites4_1
|
|
C7C1 UpdateSprites4_3
|
|
C7C5 SubCC7C5
|
|
C7F5 UpdateSprites4_4
|
|
C813 SubCC813
|
|
C81D GameLoopEntry_5
|
|
C821 InitGameState
|
|
C83D UpdateSprites2_8
|
|
C868 UpdateSprites2_9
|
|
C883 InitSprites2_1
|
|
C891 ClearSpriteRAM
|
|
C89A UpdateSprites2_10
|
|
C8A4 UpdateSprites2_11
|
|
C8E0 UpdateSprites3_6
|
|
C8EE UpdateSprites4_5
|
|
C94B UpdateSprites5_1
|
|
C9D7 UpdateSprites6
|
|
C9F8 UpdateSprites7_1
|
|
CA01 SubCCA01
|
|
CA03 SubCCA03
|
|
CA1A UpdateSprites7_3
|
|
CA29 UpdateSprites8
|
|
CA2C SubCCA2C
|
|
CA33 UpdateSprites9
|
|
CA36 UpdateSprites10
|
|
CA3D SubCCA3D
|
|
CA40 UpdateSprites11
|
|
CA44 UpdateSprites12
|
|
CA4C UpdateSprites13
|
|
CACE InitSprites_4
|
|
CAED InitSprites3
|
|
CB00 UpdateController
|
|
CB35 UpdateController2_4
|
|
CB78 UpdateSprites_4
|
|
CB81 UpdateSprites2_12
|
|
CB8C UpdateSprites4_7
|
|
CB8E UpdateSprites4_6
|
|
CB9D UpdateSprites5_4
|
|
CC05 SubCCC05
|
|
CC9E SubCCC9E
|
|
CCF6 SubCCCF6
|
|
CD13 SubCCD13
|
|
CD62 SubCCD62
|
|
CD95 SubCCD95
|
|
CDB0 SubCCDB0
|
|
CE5D SubCCE5D
|
|
CE88 SubCCE88
|
|
CE8B SubCCE8B
|
|
CEDB SubCCEDB
|
|
CEEF SubCCEEF
|
|
CF1A SubCCF1A
|
|
CF5B SubCCF5B
|
|
CFC0 SubCCFC0
|
|
CFC6 SubCCFC6
|
|
CFEF SubCCFEF
|
|
D00A SubCD00A
|
|
D021 SubCD021
|
|
D053 SubCD053
|
|
D06B SubCD06B
|
|
D07C SubCD07C
|
|
D0AA SubCD0AA
|
|
D0C5 SubCD0C5
|
|
D111 SubCD111
|
|
D117 UpdateSound4_11
|
|
D127 SubCD127
|
|
D133 SubCD133
|
|
D143 SubCD143
|
|
D160 UpdateSound6
|
|
D17C SubCD17C
|
|
D1E5 SubCD1E5
|
|
D1F9 SubCD1F9
|
|
D212 SubCD212
|
|
D2BC SubCD2BC
|
|
D2CB UpdateSound12_4
|
|
D2D9 SubCD2D9
|
|
D2F9 SubCD2F9
|
|
D2FB SubCD2FB
|
|
D301 SubCD301
|
|
D308 SubCD308
|
|
D385 SubCD385
|
|
D3AC SubCD3AC
|
|
D3B3 SubCD3B3
|
|
D421 SubCD421
|
|
D446 SubCD446
|
|
D463 SubCD463
|
|
D493 SubCD493
|
|
D4F5 SubCD4F5
|
|
D507 SubCD507
|
|
D552 SubCD552
|
|
D59C SubCD59C
|
|
D6A5 SubCD6A5
|
|
D6B9 SubCD6B9
|
|
D6E0 SubCD6E0
|
|
D724 SubCD724
|
|
D7DE SubCD7DE
|
|
D81F SubCD81F
|
|
D82F SubCD82F
|
|
D888 SubCD888
|
|
D890 SubCD890
|
|
D8AF SubCD8AF
|
|
D8EA SubCD8EA
|
|
D8FD SubCD8FD
|
|
D90F SubCD90F
|
|
D91C SubCD91C
|
|
D9AD SubCD9AD
|
|
D9CC SubCD9CC
|
|
DA4B SubCDA4B
|
|
DA85 SubCDA85
|
|
DA99 SubCDA99
|
|
DAB2 SubCDAB2
|
|
DAD5 SubCDAD5
|
|
DAF2 SubCDAF2
|
|
DB1D SubCDB1D
|
|
DB57 SubCDB57
|
|
DBB0 SubCDBB0
|
|
DBB4 SubCDBB4
|
|
DBB6 UpdateSound24_1
|
|
DC6A SubCDC6A
|
|
DC97 SubCDC97
|
|
DCB3 SubCDCB3
|
|
DCEA SubCDCEA
|
|
DCF0 SubCDCF0
|
|
DCF6 SubCDCF6
|
|
DD16 SubCDD16
|
|
DD1D SubCDD1D
|
|
DD24 SubCDD24
|
|
DD75 UpdateSound26_11
|
|
DD8F UpdateSound26_13
|
|
DDA1 SubCDDA1
|
|
DDA9 SubCDDA9
|
|
DDB6 SubCDDB6
|
|
DDBD SubCDDBD
|
|
DDC9 SubCDDC9
|
|
DDE1 SubCDDE1
|
|
DE12 SubCDE12
|
|
DE22 SubCDE22
|
|
DE44 SubCDE44
|
|
DEB2 SubCDEB2
|
|
DEB9 SubCDEB9
|
|
DEEA SubCDEEA
|
|
DFA5 SubCDFA5
|
|
DFAB SubCDFAB
|
|
DFEA SubCDFEA
|
|
DFF8 SubCDFF8
|
|
E002 SubCE002
|
|
E05E SubCE05E
|
|
E097 SubCE097
|
|
E0A7 SubCE0A7
|
|
E0B9 SubCE0B9
|
|
E0C0 SubCE0C0
|
|
E16B SubCE16B
|
|
E176 SubCE176
|
|
E189 SubCE189
|
|
E277 SubCE277
|
|
E27A SubCE27A
|
|
E29A SubCE29A
|
|
E2F8 SubCE2F8
|
|
E2FB SubCE2FB
|
|
E321 SubCE321
|
|
E33C SubCE33C
|
|
E4C2 SubCE4C2
|
|
E523 SubCE523
|
|
E573 SubCE573
|
|
E614 SubCE614
|
|
E63D SubCE63D
|
|
E640 SubCE640
|
|
E64E SubCE64E
|
|
E719 SubCE719
|
|
E72B SubCE72B
|
|
E79D SubCE79D
|
|
E7A1 SubCE7A1
|
|
E881 SubCE881
|
|
E9C5 SubCE9C5
|
|
EA4A SubCEA4A
|
|
EA55 SubCEA55
|
|
EA8E SubCEA8E
|
|
EA97 SubCEA97
|
|
EAFC SubCEAFC
|
|
EB2E SubCEB2E
|
|
EB5F SubCEB5F
|
|
EB7F SubCEB7F
|
|
EB8A SubCEB8A
|
|
EC23 SubCEC23
|
|
EC2A SubCEC2A
|
|
EC51 SubCEC51
|
|
ECBF SubCECBF
|
|
ECF0 SubCECF0
|
|
ED25 SubCED25
|
|
ED51 SubCED51
|
|
ED63 SubCED63
|
|
EDBF SubCEDBF
|
|
EDD5 SubCEDD5
|
|
EE0D SubCEE0D
|
|
EEA2 SubCEEA2
|
|
EF06 SubCEF06
|
|
EF42 SubCEF42
|
|
EF47 SubCEF47
|
|
EF4E SubCEF4E
|
|
EF56 SubCEF56
|
|
EF70 SubCEF70
|
|
EF7B SubCEF7B
|
|
EF7D SubCEF7D
|
|
EF83 SubCEF83
|
|
EF8E SubCEF8E
|
|
EF9A SubCEF9A
|
|
EFD3 UpdateMusicChannel19
|
|
EFEC SubCEFEC
|
|
EFF3 SubCEFF3
|
|
F0C9 SubCF0C9
|
|
F10B SubCF10B
|
|
F13B SubCF13B
|
|
F19E SubCF19E
|
|
F2EC SubCF2EC
|
|
F35B SubCF35B
|
|
F3BD SubCF3BD
|
|
F3D2 SubCF3D2
|
|
F504 SubCF504
|
|
F524 SubCF524
|
|
F564 SubCF564
|
|
F586 SubCF586
|
|
F630 SubCF630
|
|
F64C SubCF64C
|
|
F691 SubCF691
|
|
F6A4 SubCF6A4
|
|
F6EA SubCF6EA
|
|
F71D SubCF71D
|
|
F737 SubCF737
|
|
F78B SubCF78B
|
|
F7AB SubCF7AB
|
|
F80C SubCF80C
|
|
F838 SubCF838
|
|
F8AC SubCF8AC
|
|
F8DB SubCF8DB
|
|
F91E SubCF91E
|
|
F953 SubCF953
|
|
F95A SubCF95A
|
|
F961 SubCF961
|
|
F964 SubCF964
|
|
F978 SubCF978
|
|
F97B SubCF97B
|
|
F97F SubCF97F
|
|
F983 SubCF983
|
|
F9EB SubCF9EB
|
|
FA36 SubCFA36
|
|
FA3A SubCFA3A
|
|
FAC4 SubCFAC4
|
|
FBA1 SubCFBA1
|
|
FBFC SubCFBFC
|
|
|
|
# ---- derived internal branch-target names ----
|
|
C014 Reset
|
|
C01E WaitVBlank_1
|
|
C024 WaitVBlank2_1
|
|
C041 ClearZeropage
|
|
C058 InitAPU_1
|
|
C05E InitAPU_3
|
|
C06D MainGameLoop
|
|
C070 GameLoopEntry_1
|
|
C076 NmiHandler
|
|
C083 NmiFrameUpdate
|
|
C095 NmiFrameUpdate2
|
|
C0D3 GameStateUpdate
|
|
C0F3 SubCC0F3_OnNonzero
|
|
C0FA UpdateGameState3_1
|
|
C100 UpdateGameState4
|
|
C103 UpdateGameState5
|
|
C10A UpdateGameState6
|
|
C11A SubCC11A_Loop
|
|
C126 GameLoopEntry_4
|
|
C135 SubCC135_Loop
|
|
C138 UpdateGameState2_4
|
|
C141 UpdateGameState2_5
|
|
C148 WaitVBlankFrame2
|
|
C14E InitSprites_1
|
|
C150 CopySprites
|
|
C166 SubCC166
|
|
C17F SubCC17F_OnNonzero
|
|
C182 SubCC182_Loop
|
|
C189 SubCC189_Loop
|
|
C19B SubCC19B_Loop
|
|
C1AF SubCC1AF_OnNonnegative
|
|
C1D0 SubCC1D0_Loop
|
|
C1D6 SubCC1D6_Loop
|
|
C1D7 SubCC1D7
|
|
C1F0 SubCC1F0_Loop
|
|
C1FE SubCC1FE_OnNonnegative
|
|
C207 SubCC207_Loop
|
|
C218 UpdateSprites_1
|
|
C21A UpdateSprites2_1
|
|
C21D SubCC21D_Loop
|
|
C23B SubCC23B_Loop
|
|
C23F SubCC23F_OnNonzero
|
|
C253 SubCC253_OnNonnegative
|
|
C274 SubCC274_Loop
|
|
C279 SubCC279_OnNonnegative
|
|
C2AB UpdateSprites2_3
|
|
C2B0 SubCC2B0
|
|
C2C1 SubCC2C1_OnNonzero
|
|
C2C4 SubCC2C4_Loop
|
|
C2CE SubCC2CE_Loop
|
|
C2D9 SubCC2D9_Loop
|
|
C38D SubCC38D
|
|
C39F SubCC39F_Loop
|
|
C436 SubCC436_OnNonzero
|
|
C437 CheckZp34
|
|
C44A UpdateSprites2_4
|
|
C4C0 UpdateSprites3_1
|
|
C4C8 SubCC4C8_Loop
|
|
C4CD SubCC4CD_OnNonnegative
|
|
C4D7 InitSprites_3
|
|
C4D9 SubCC4D9_OnNonnegative
|
|
C4E8 SubCC4E8_OnNonnegative
|
|
C4F6 SubCC4F6_OnCarryClear
|
|
C508 SubCC508_Loop
|
|
C542 UpdateSprites_3
|
|
C553 SubCC553_OnNonnegative
|
|
C579 SubCC579_OnZero
|
|
C582 SubCC582_Loop
|
|
C586 SubCC586_OnNonzero
|
|
C592 SubCC592_Loop
|
|
C597 SubCC597_Loop
|
|
C5A7 UpdateSprites2_5
|
|
C5A9 SubCC5A9_OnNonzero
|
|
C5B0 SubCC5B0_OnNonnegative
|
|
C5C9 SubCC5C9
|
|
C5D2 SubCC5D2_Loop
|
|
C5D3 UpdateSprites3_3
|
|
C5DB SubCC5DB_OnNonzero
|
|
C5ED SubCC5ED_Loop
|
|
C5EF SubCC5EF_Loop
|
|
C5F9 SubCC5F9_Loop
|
|
C5FC SubCC5FC_Loop
|
|
C608 SubCC608_Loop
|
|
C60F SubCC60F_OnZero
|
|
C620 CheckZp14
|
|
C626 SubCC626_OnCarrySet
|
|
C63A SubCC63A_Loop
|
|
C664 SubCC664_Loop
|
|
C67F SubCC67F_Loop
|
|
C6FB UpdateSprites3_4
|
|
C718 SubCC718_OnNonzero
|
|
C726 CheckZp55
|
|
C728 UpdateSprites2_7
|
|
C73D UpdateSprites3_5
|
|
C759 SubCC759_OnNonzero
|
|
C76F SubCC76F_Loop
|
|
C777 UpdateSprites4_1
|
|
C77B SubCC77B_OnNonzero
|
|
C7A5 SubCC7A5_Loop
|
|
C7C1 UpdateSprites4_3
|
|
C7C5 SubCC7C5
|
|
C7CA SubCC7CA_OnNonnegative
|
|
C7CF SubCC7CF_OnNonzero
|
|
C7F5 UpdateSprites4_4
|
|
C7F7 SubCC7F7_OnNonzero
|
|
C7FD SubCC7FD_OnNonzero
|
|
C813 SubCC813
|
|
C81D GameLoopEntry_5
|
|
C821 InitGameState
|
|
C829 SubCC829_OnNonzero
|
|
C83D UpdateSprites2_8
|
|
C853 SubCC853_Loop
|
|
C868 UpdateSprites2_9
|
|
C883 InitSprites2_1
|
|
C891 ClearSpriteRAM
|
|
C89A UpdateSprites2_10
|
|
C8A4 UpdateSprites2_11
|
|
C8BF SubCC8BF_OnNonzero
|
|
C8D9 SubCC8D9_OnNonzero
|
|
C8E0 UpdateSprites3_6
|
|
C8EE UpdateSprites4_5
|
|
C92B SubCC92B_OnNonzero
|
|
C94A SubCC94A_Loop
|
|
C94B UpdateSprites5_1
|
|
C963 SubCC963_Loop
|
|
C977 SubCC977_OnZero
|
|
C995 SubCC995_Loop
|
|
C99A SubCC99A_Loop
|
|
C9BB SubCC9BB_Loop
|
|
C9C2 SubCC9C2_Loop
|
|
C9D6 SubCC9D6_Loop
|
|
C9D7 UpdateSprites6
|
|
C9E2 SubCC9E2_Loop
|
|
C9EF SubCC9EF_OnCarrySet
|
|
C9F3 SubCC9F3_Loop
|
|
C9F8 UpdateSprites7_1
|
|
CA01 SubCCA01
|
|
CA03 SubCCA03
|
|
CA0B SubCCA0B_Loop
|
|
CA17 SubCCA17_Loop
|
|
CA1A UpdateSprites7_3
|
|
CA29 UpdateSprites8
|
|
CA2C SubCCA2C
|
|
CA33 UpdateSprites9
|
|
CA36 UpdateSprites10
|
|
CA3D SubCCA3D
|
|
CA40 UpdateSprites11
|
|
CA44 UpdateSprites12
|
|
CA4C UpdateSprites13
|
|
CA61 SubCCA61_OnNonnegative
|
|
CA6B SubCCA6B_OnZero
|
|
CA94 SubCCA94_OnNonzero
|
|
CA99 SubCCA99_OnCarryClear
|
|
CAA4 SubCCAA4_OnCarryClear
|
|
CAB4 SubCCAB4_Loop
|
|
CAC0 SubCCAC0_Loop
|
|
CAC1 SubCCAC1_Loop
|
|
CAC6 SubCCAC6_Loop
|
|
CACB SubCCACB_Loop
|
|
CACE InitSprites_4
|
|
CAD8 SubCCAD8_Loop
|
|
CAE6 SubCCAE6_OnNonzero
|
|
CAED InitSprites3
|
|
CB00 UpdateController
|
|
CB02 SubCCB02_OnNonzero
|
|
CB21 SubCCB21_OnNonzero
|
|
CB2D SubCCB2D_Loop
|
|
CB35 UpdateController2_4
|
|
CB3E SubCCB3E_OnNonzero
|
|
CB54 SubCCB54_Loop
|
|
CB5E SubCCB5E_Loop
|
|
CB61 SubCCB61_OnNonzero
|
|
CB64 SubCCB64_Loop
|
|
CB78 UpdateSprites_4
|
|
CB81 UpdateSprites2_12
|
|
CB8C UpdateSprites4_7
|
|
CB8E UpdateSprites4_6
|
|
CB9C SubCCB9C_Loop
|
|
CB9D UpdateSprites5_4
|
|
CBA9 SubCCBA9_OnNonnegative
|
|
CBAF SubCCBAF_Loop
|
|
CC05 SubCCC05
|
|
CC1F SubCCC1F_Loop
|
|
CC9E SubCCC9E
|
|
CCB9 SubCCCB9_Loop
|
|
CCE1 SubCCCE1_Loop
|
|
CCE4 SubCCCE4_Loop
|
|
CCED SubCCCED_Loop
|
|
CCF6 SubCCCF6
|
|
CD0D SubCCD0D_Loop
|
|
CD12 SubCCD12_Loop
|
|
CD13 SubCCD13
|
|
CD61 SubCCD61_Loop
|
|
CD62 SubCCD62
|
|
CD68 SubCCD68_OnNonzero
|
|
CD83 SubCCD83_Loop
|
|
CD8B SubCCD8B_Loop
|
|
CD95 SubCCD95
|
|
CDAF SubCCDAF_Loop
|
|
CDB0 SubCCDB0
|
|
CDC4 SubCCDC4_Loop
|
|
CDD0 SubCCDD0_OnZero
|
|
CDDB SubCCDDB_Loop
|
|
CDDF SubCCDDF_Loop
|
|
CDE9 SubCCDE9_Loop
|
|
CDF1 SubCCDF1_Loop
|
|
CDFF SubCCDFF_Loop
|
|
CE11 SubCCE11_OnCarryClear
|
|
CE29 SubCCE29_Loop
|
|
CE3F SubCCE3F_Loop
|
|
CE43 SubCCE43_Loop
|
|
CE54 SubCCE54_Loop
|
|
CE5C SubCCE5C_Loop
|
|
CE5D SubCCE5D
|
|
CE7E SubCCE7E_Loop
|
|
CE88 SubCCE88
|
|
CE8B SubCCE8B
|
|
CE93 SubCCE93_Loop
|
|
CE9A SubCCE9A_Loop
|
|
CECD SubCCECD_Loop
|
|
CED0 SubCCED0_Loop
|
|
CEDB SubCCEDB
|
|
CEDD SubCCEDD_OnNonzero
|
|
CEE7 SubCCEE7_Loop
|
|
CEEE SubCCEEE_Loop
|
|
CEEF SubCCEEF
|
|
CF12 SubCCF12_Loop
|
|
CF15 SubCCF15_Loop
|
|
CF19 SubCCF19_Loop
|
|
CF1A SubCCF1A
|
|
CF46 SubCCF46_Loop
|
|
CF51 SubCCF51_Loop
|
|
CF55 SubCCF55_Loop
|
|
CF5B SubCCF5B
|
|
CF6D SubCCF6D_Loop
|
|
CF7C SubCCF7C_Loop
|
|
CF89 SubCCF89_Loop
|
|
CF99 SubCCF99_Loop
|
|
CFA4 SubCCFA4_Loop
|
|
CFA7 SubCCFA7_Loop
|
|
CFA9 SubCCFA9_Loop
|
|
CFBD SubCCFBD_Loop
|
|
CFC0 SubCCFC0
|
|
CFC6 SubCCFC6
|
|
CFD1 SubCCFD1_Loop
|
|
CFD3 SubCCFD3_Loop
|
|
CFEB SubCCFEB_Loop
|
|
CFEF SubCCFEF
|
|
CFFB SubCCFFB_OnZero
|
|
CFFC SubCCFFC_Loop
|
|
D00A SubCD00A
|
|
D018 SubCD018_Loop
|
|
D01E SubCD01E_Loop
|
|
D021 SubCD021
|
|
D025 SubCD025_OnNonzero
|
|
D02D SubCD02D_OnNonzero
|
|
D04F SubCD04F_Loop
|
|
D053 SubCD053
|
|
D05A SubCD05A_Loop
|
|
D06B SubCD06B
|
|
D077 SubCD077_Loop
|
|
D079 SubCD079_Loop
|
|
D07C SubCD07C
|
|
D0AA SubCD0AA
|
|
D0B8 SubCD0B8_Loop
|
|
D0C0 SubCD0C0_Loop
|
|
D0C5 SubCD0C5
|
|
D0C7 SubCD0C7_Loop
|
|
D0CA SubCD0CA_Loop
|
|
D0F4 SubCD0F4_Loop
|
|
D0F7 SubCD0F7_OnCarryClear
|
|
D111 SubCD111
|
|
D117 UpdateSound4_11
|
|
D123 SubCD123_Loop
|
|
D126 SubCD126_Loop
|
|
D127 SubCD127
|
|
D133 SubCD133
|
|
D143 SubCD143
|
|
D151 SubCD151_Loop
|
|
D160 UpdateSound6
|
|
D16A SubCD16A_Loop
|
|
D171 SubCD171_Loop
|
|
D17B SubCD17B_Loop
|
|
D17C SubCD17C
|
|
D192 SubCD192_Loop
|
|
D1A7 SubCD1A7_Loop
|
|
D1AB SubCD1AB_Loop
|
|
D1C4 SubCD1C4_Loop
|
|
D1D2 SubCD1D2_Loop
|
|
D1DB SubCD1DB_Loop
|
|
D1E5 SubCD1E5
|
|
D1E7 SubCD1E7_OnNonnegative
|
|
D1F5 SubCD1F5_Loop
|
|
D1F9 SubCD1F9
|
|
D1FB SubCD1FB_OnNonzero
|
|
D206 SubCD206_Loop
|
|
D211 SubCD211_OnZero
|
|
D212 SubCD212
|
|
D249 SubCD249_Loop
|
|
D24B SubCD24B_Loop
|
|
D252 SubCD252_Loop
|
|
D25A SubCD25A_Loop
|
|
D264 SubCD264_Loop
|
|
D266 SubCD266_Loop
|
|
D269 SubCD269_Loop
|
|
D282 SubCD282_Loop
|
|
D284 SubCD284_Loop
|
|
D29E SubCD29E_OnNonnegative
|
|
D2A8 SubCD2A8_Loop
|
|
D2B5 SubCD2B5_Loop
|
|
D2B6 SubCD2B6_Loop
|
|
D2BC SubCD2BC
|
|
D2C7 SubCD2C7_Loop
|
|
D2CB UpdateSound12_4
|
|
D2D2 SubCD2D2_Loop
|
|
D2D9 SubCD2D9
|
|
D2F8 SubCD2F8_Loop
|
|
D2F9 SubCD2F9
|
|
D2FB SubCD2FB
|
|
D300 SubCD300_Loop
|
|
D301 SubCD301
|
|
D308 SubCD308
|
|
D32E SubCD32E_OnCarryClear
|
|
D33C SubCD33C_Loop
|
|
D367 SubCD367_Loop
|
|
D371 SubCD371_Loop
|
|
D372 SubCD372_Loop
|
|
D37F SubCD37F_Loop
|
|
D383 SubCD383_Loop
|
|
D385 SubCD385
|
|
D390 SubCD390_Loop
|
|
D393 SubCD393_Loop
|
|
D3AB SubCD3AB_Loop
|
|
D3AC SubCD3AC
|
|
D3B3 SubCD3B3
|
|
D3CF SubCD3CF_OnNonnegative
|
|
D3D9 SubCD3D9_Loop
|
|
D3DF SubCD3DF_Loop
|
|
D3EB SubCD3EB_Loop
|
|
D3F2 SubCD3F2_Loop
|
|
D3F5 SubCD3F5_OnZero
|
|
D3F6 SubCD3F6_Loop
|
|
D400 SubCD400_Loop
|
|
D421 SubCD421
|
|
D431 SubCD431_Loop
|
|
D43C SubCD43C_Loop
|
|
D441 SubCD441_Loop
|
|
D446 SubCD446
|
|
D463 SubCD463
|
|
D465 SubCD465_OnNonzero
|
|
D483 SubCD483_Loop
|
|
D487 SubCD487_Loop
|
|
D48C SubCD48C_OnNonzero
|
|
D493 SubCD493
|
|
D495 SubCD495_OnNonnegative
|
|
D49D SubCD49D_OnNonnegative
|
|
D4A9 SubCD4A9_Loop
|
|
D4AE SubCD4AE_Loop
|
|
D4C0 SubCD4C0_Loop
|
|
D4CE SubCD4CE_Loop
|
|
D4D2 SubCD4D2_Loop
|
|
D4E4 SubCD4E4_Loop
|
|
D4EE SubCD4EE_Loop
|
|
D4F5 SubCD4F5
|
|
D507 SubCD507
|
|
D547 SubCD547_Loop
|
|
D552 SubCD552
|
|
D561 SubCD561_Loop
|
|
D564 SubCD564_Loop
|
|
D567 SubCD567_Loop
|
|
D587 SubCD587_Loop
|
|
D58D SubCD58D_Loop
|
|
D594 SubCD594_Loop
|
|
D59C SubCD59C
|
|
D5B0 SubCD5B0_Loop
|
|
D5B4 SubCD5B4_Loop
|
|
D5C5 SubCD5C5_Loop
|
|
D5D5 SubCD5D5_OnNonzero
|
|
D603 SubCD603_Loop
|
|
D617 SubCD617_Loop
|
|
D62F SubCD62F_Loop
|
|
D639 SubCD639_Loop
|
|
D63B SubCD63B_Loop
|
|
D648 SubCD648_Loop
|
|
D669 SubCD669_Loop
|
|
D680 SubCD680_Loop
|
|
D684 SubCD684_Loop
|
|
D686 SubCD686_OnNonzero
|
|
D68F SubCD68F_Loop
|
|
D697 SubCD697_Loop
|
|
D699 SubCD699_OnNonzero
|
|
D6A3 SubCD6A3_Loop
|
|
D6A5 SubCD6A5
|
|
D6B9 SubCD6B9
|
|
D6BF SubCD6BF_Loop
|
|
D6C9 SubCD6C9_Loop
|
|
D6CB SubCD6CB_Loop
|
|
D6CC SubCD6CC_Loop
|
|
D6DC SubCD6DC_Loop
|
|
D6E0 SubCD6E0
|
|
D6E8 SubCD6E8_OnNonzero
|
|
D715 SubCD715_Loop
|
|
D71A SubCD71A_Loop
|
|
D71B SubCD71B_Loop
|
|
D723 SubCD723_OnNonzero
|
|
D724 SubCD724
|
|
D726 SubCD726_OnNonnegative
|
|
D74C SubCD74C_Loop
|
|
D7DE SubCD7DE
|
|
D7F1 SubCD7F1_Loop
|
|
D7F8 SubCD7F8_Loop
|
|
D7FC SubCD7FC_Loop
|
|
D7FE SubCD7FE_OnNonnegative
|
|
D80A SubCD80A_Loop
|
|
D80F SubCD80F_Loop
|
|
D816 SubCD816_Loop
|
|
D819 SubCD819_Loop
|
|
D81F SubCD81F
|
|
D82E SubCD82E_Loop
|
|
D82F SubCD82F
|
|
D863 SubCD863_OnNonnegative
|
|
D884 SubCD884_Loop
|
|
D887 SubCD887_Loop
|
|
D888 SubCD888
|
|
D890 SubCD890
|
|
D896 SubCD896_OnNonnegative
|
|
D8A2 SubCD8A2_Loop
|
|
D8A5 SubCD8A5_OnZero
|
|
D8A6 SubCD8A6_Loop
|
|
D8AF SubCD8AF
|
|
D8C6 SubCD8C6_Loop
|
|
D8C8 SubCD8C8_Loop
|
|
D8DC SubCD8DC_Loop
|
|
D8EA SubCD8EA
|
|
D8FC SubCD8FC_Loop
|
|
D8FD SubCD8FD
|
|
D905 SubCD905_Loop
|
|
D90E SubCD90E_OnCarrySet
|
|
D90F SubCD90F
|
|
D91C SubCD91C
|
|
D942 SubCD942_Loop
|
|
D946 SubCD946_OnCarryClear
|
|
D957 SubCD957_Loop
|
|
D964 SubCD964_Loop
|
|
D967 SubCD967_Loop
|
|
D988 SubCD988_Loop
|
|
D9A5 SubCD9A5_Loop
|
|
D9A8 SubCD9A8_Loop
|
|
D9AD SubCD9AD
|
|
D9C3 SubCD9C3_Loop
|
|
D9CC SubCD9CC
|
|
D9CE SubCD9CE_OnNonnegative
|
|
DA11 SubCDA11_Loop
|
|
DA3A SubCDA3A_Loop
|
|
DA44 SubCDA44_Loop
|
|
DA4B SubCDA4B
|
|
DA4D SubCDA4D_OnNonnegative
|
|
DA64 SubCDA64_Loop
|
|
DA85 SubCDA85
|
|
DA87 SubCDA87_Loop
|
|
DA8F SubCDA8F_Loop
|
|
DA93 SubCDA93_Loop
|
|
DA99 SubCDA99
|
|
DAB2 SubCDAB2
|
|
DAB7 SubCDAB7_OnCarrySet
|
|
DABC SubCDABC_Loop
|
|
DAD3 SubCDAD3_OnCarrySet
|
|
DAD4 SubCDAD4_Loop
|
|
DAD5 SubCDAD5
|
|
DAF0 SubCDAF0_OnZero
|
|
DAF2 SubCDAF2
|
|
DB0E SubCDB0E_Loop
|
|
DB1B SubCDB1B_Loop
|
|
DB1D SubCDB1D
|
|
DB2C SubCDB2C_Loop
|
|
DB31 SubCDB31_Loop
|
|
DB4B SubCDB4B_Loop
|
|
DB54 SubCDB54_Loop
|
|
DB57 SubCDB57
|
|
DB65 SubCDB65_Loop
|
|
DB81 SubCDB81_Loop
|
|
DB86 SubCDB86_Loop
|
|
DB9C SubCDB9C_Loop
|
|
DBA2 SubCDBA2_OnCarryClear
|
|
DBA4 SubCDBA4_Loop
|
|
DBA6 SubCDBA6_Loop
|
|
DBAD SubCDBAD_OnCarrySet
|
|
DBB0 SubCDBB0
|
|
DBB4 SubCDBB4
|
|
DBB6 UpdateSound24_1
|
|
DBCB SubCDBCB_Loop
|
|
DBFD SubCDBFD_Loop
|
|
DC0C SubCDC0C_Loop
|
|
DC18 SubCDC18_Loop
|
|
DC2B SubCDC2B_Loop
|
|
DC34 SubCDC34_Loop
|
|
DC36 SubCDC36_Loop
|
|
DC43 SubCDC43_Loop
|
|
DC4D SubCDC4D_Loop
|
|
DC53 SubCDC53_OnNonzero
|
|
DC56 SubCDC56_Loop
|
|
DC58 SubCDC58_OnZero
|
|
DC59 SubCDC59_Loop
|
|
DC5E SubCDC5E_Loop
|
|
DC6A SubCDC6A
|
|
DC80 SubCDC80_Loop
|
|
DC97 SubCDC97
|
|
DCA4 SubCDCA4_Loop
|
|
DCAD SubCDCAD_Loop
|
|
DCB3 SubCDCB3
|
|
DCEA SubCDCEA
|
|
DCF0 SubCDCF0
|
|
DCF6 SubCDCF6
|
|
DCFA SubCDCFA_Loop
|
|
DCFE SubCDCFE_OnNonnegative
|
|
DD0B SubCDD0B_OnZero
|
|
DD16 SubCDD16
|
|
DD1D SubCDD1D
|
|
DD22 SubCDD22_Loop
|
|
DD24 SubCDD24
|
|
DD50 SubCDD50_OnCarryClear
|
|
DD75 UpdateSound26_11
|
|
DD8F UpdateSound26_13
|
|
DD91 SubCDD91_Loop
|
|
DD94 SubCDD94_Loop
|
|
DD97 SubCDD97_Loop
|
|
DDA1 SubCDDA1
|
|
DDA9 SubCDDA9
|
|
DDB6 SubCDDB6
|
|
DDBD SubCDDBD
|
|
DDBF SubCDDBF_OnNonzero
|
|
DDC9 SubCDDC9
|
|
DDE1 SubCDDE1
|
|
DDEC SubCDDEC_Loop
|
|
DE07 SubCDE07_Loop
|
|
DE10 SubCDE10_Loop
|
|
DE11 SubCDE11_Loop
|
|
DE12 SubCDE12
|
|
DE1D SubCDE1D_Loop
|
|
DE22 SubCDE22
|
|
DE2E SubCDE2E_OnCarryClear
|
|
DE44 SubCDE44
|
|
DE7B SubCDE7B_Loop
|
|
DE7D SubCDE7D_Loop
|
|
DE83 SubCDE83_Loop
|
|
DE90 SubCDE90_Loop
|
|
DE9C SubCDE9C_Loop
|
|
DEA5 SubCDEA5_Loop
|
|
DEA9 SubCDEA9_Loop
|
|
DEB2 SubCDEB2
|
|
DEB9 SubCDEB9
|
|
DEE4 SubCDEE4_Loop
|
|
DEEA SubCDEEA
|
|
DEEC SubCDEEC_OnNonzero
|
|
DFA5 SubCDFA5
|
|
DFAB SubCDFAB
|
|
DFB1 SubCDFB1_OnNonzero
|
|
DFCF SubCDFCF_OnNonnegative
|
|
DFE1 SubCDFE1_Loop
|
|
DFE9 SubCDFE9_Loop
|
|
DFEA SubCDFEA
|
|
DFF8 SubCDFF8
|
|
E002 SubCE002
|
|
E004 SubCE004_OnNonnegative
|
|
E01B SubCE01B_OnNonzero
|
|
E054 SubCE054_Loop
|
|
E05D SubCE05D_OnZero
|
|
E05E SubCE05E
|
|
E069 SubCE069_OnNonzero
|
|
E08F SubCE08F_Loop
|
|
E097 SubCE097
|
|
E0A7 SubCE0A7
|
|
E0B9 SubCE0B9
|
|
E0C0 SubCE0C0
|
|
E0E2 SubCE0E2_OnCarryClear
|
|
E110 SubCE110_Loop
|
|
E115 SubCE115_Loop
|
|
E11A SubCE11A_Loop
|
|
E11B SubCE11B_Loop
|
|
E12C SubCE12C_Loop
|
|
E12E SubCE12E_Loop
|
|
E12F SubCE12F_Loop
|
|
E13D SubCE13D_Loop
|
|
E142 SubCE142_Loop
|
|
E153 SubCE153_Loop
|
|
E158 SubCE158_Loop
|
|
E165 SubCE165_Loop
|
|
E16B SubCE16B
|
|
E176 SubCE176
|
|
E17E SubCE17E_Loop
|
|
E184 SubCE184_Loop
|
|
E189 SubCE189
|
|
E196 SubCE196_OnNonnegative
|
|
E1C6 SubCE1C6_OnZero
|
|
E1E0 SubCE1E0_Loop
|
|
E1E1 SubCE1E1_Loop
|
|
E1E4 SubCE1E4_OnNonzero
|
|
E1EE SubCE1EE_Loop
|
|
E202 SubCE202_Loop
|
|
E214 SubCE214_OnZero
|
|
E215 SubCE215_Loop
|
|
E21A SubCE21A_Loop
|
|
E225 SubCE225_Loop
|
|
E234 SubCE234_Loop
|
|
E235 SubCE235_Loop
|
|
E23E SubCE23E_Loop
|
|
E243 SubCE243_Loop
|
|
E250 SubCE250_OnNonzero
|
|
E251 SubCE251_Loop
|
|
E265 SubCE265_Loop
|
|
E277 SubCE277
|
|
E27A SubCE27A
|
|
E27C SubCE27C_OnNonnegative
|
|
E296 SubCE296_Loop
|
|
E29A SubCE29A
|
|
E2A3 SubCE2A3_OnNonnegative
|
|
E2B0 SubCE2B0_OnNonnegative
|
|
E2BE SubCE2BE_Loop
|
|
E2C5 SubCE2C5_OnNonnegative
|
|
E2D0 SubCE2D0_Loop
|
|
E2E6 SubCE2E6_Loop
|
|
E2EC SubCE2EC_Loop
|
|
E2F4 SubCE2F4_Loop
|
|
E2F8 SubCE2F8
|
|
E2FB SubCE2FB
|
|
E303 SubCE303_OnNonnegative
|
|
E31A SubCE31A_Loop
|
|
E321 SubCE321
|
|
E325 SubCE325_OnNonnegative
|
|
E33C SubCE33C
|
|
E343 SubCE343_OnNonnegative
|
|
E362 SubCE362_Loop
|
|
E367 SubCE367_OnNonnegative
|
|
E372 SubCE372_Loop
|
|
E37E SubCE37E_Loop
|
|
E4C2 SubCE4C2
|
|
E4CC SubCE4CC_OnNonzero
|
|
E4EC SubCE4EC_Loop
|
|
E502 SubCE502_Loop
|
|
E517 SubCE517_OnNonzero
|
|
E523 SubCE523
|
|
E527 SubCE527_OnNonnegative
|
|
E52F SubCE52F_OnNonnegative
|
|
E573 SubCE573
|
|
E583 SubCE583_Loop
|
|
E587 SubCE587_OnNonnegative
|
|
E58F SubCE58F_Loop
|
|
E59B SubCE59B_Loop
|
|
E5A9 SubCE5A9_Loop
|
|
E5BB SubCE5BB_Loop
|
|
E5C8 SubCE5C8_Loop
|
|
E5D2 SubCE5D2_OnNonzero
|
|
E5F2 SubCE5F2_Loop
|
|
E5FF SubCE5FF_Loop
|
|
E614 SubCE614
|
|
E635 SubCE635_Loop
|
|
E63D SubCE63D
|
|
E640 SubCE640
|
|
E64D SubCE64D_Loop
|
|
E64E SubCE64E
|
|
E662 SubCE662_Loop
|
|
E668 SubCE668_OnNonnegative
|
|
E678 SubCE678_Loop
|
|
E69B SubCE69B_Loop
|
|
E6A5 SubCE6A5_Loop
|
|
E6AD SubCE6AD_Loop
|
|
E6BE SubCE6BE_OnNonzero
|
|
E6D3 SubCE6D3_Loop
|
|
E6D7 SubCE6D7_OnNonzero
|
|
E6E9 SubCE6E9_Loop
|
|
E6F1 SubCE6F1_Loop
|
|
E719 SubCE719
|
|
E720 SubCE720_OnNonnegative
|
|
E726 SubCE726_Loop
|
|
E72B SubCE72B
|
|
E747 SubCE747_OnNonzero
|
|
E74B SubCE74B_OnNonnegative
|
|
E75E SubCE75E_Loop
|
|
E779 SubCE779_Loop
|
|
E77C SubCE77C_Loop
|
|
E79D SubCE79D
|
|
E7A1 SubCE7A1
|
|
E7B2 SubCE7B2_Loop
|
|
E7B8 SubCE7B8_Loop
|
|
E7CB SubCE7CB_OnNonzero
|
|
E7E7 SubCE7E7_Loop
|
|
E7F7 SubCE7F7_OnNonzero
|
|
E80D SubCE80D_Loop
|
|
E815 SubCE815_OnNonnegative
|
|
E81C SubCE81C_Loop
|
|
E833 SubCE833_Loop
|
|
E837 SubCE837_OnNonnegative
|
|
E843 SubCE843_OnNonzero
|
|
E875 SubCE875_Loop
|
|
E881 SubCE881
|
|
E88B SubCE88B_Loop
|
|
E999 SubCE999_OnNonnegative
|
|
E9AA SubCE9AA_Loop
|
|
E9C3 SubCE9C3_Loop
|
|
E9C5 SubCE9C5
|
|
EA49 SubCEA49_OnCarryClear
|
|
EA4A SubCEA4A
|
|
EA4C SubCEA4C_OnNonzero
|
|
EA55 SubCEA55
|
|
EA8E SubCEA8E
|
|
EA96 SubCEA96_Loop
|
|
EA97 SubCEA97
|
|
EAA1 SubCEAA1_Loop
|
|
EAFC SubCEAFC
|
|
EB2E SubCEB2E
|
|
EB30 SubCEB30_OnNonnegative
|
|
EB56 SubCEB56_Loop
|
|
EB5F SubCEB5F
|
|
EB62 SubCEB62_Loop
|
|
EB68 SubCEB68_Loop
|
|
EB6B SubCEB6B_OnNonzero
|
|
EB6C SubCEB6C_Loop
|
|
EB7F SubCEB7F
|
|
EB8A SubCEB8A
|
|
EBCE SubCEBCE_Loop
|
|
EBD3 SubCEBD3_OnCarrySet
|
|
EBDD SubCEBDD_Loop
|
|
EBE9 SubCEBE9_Loop
|
|
EBFE SubCEBFE_OnCarryClear
|
|
EC07 SubCEC07_Loop
|
|
EC12 SubCEC12_Loop
|
|
EC23 SubCEC23
|
|
EC2A SubCEC2A
|
|
EC42 SubCEC42_Loop
|
|
EC50 SubCEC50_Loop
|
|
EC51 SubCEC51
|
|
EC53 SubCEC53_OnNonnegative
|
|
EC63 SubCEC63_Loop
|
|
EC74 SubCEC74_Loop
|
|
EC82 SubCEC82_Loop
|
|
EC92 SubCEC92_Loop
|
|
EC9F SubCEC9F_OnNonzero
|
|
ECA8 SubCECA8_Loop
|
|
ECBF SubCECBF
|
|
ECC1 SubCECC1_OnNonnegative
|
|
ECC7 SubCECC7_Loop
|
|
ECDD SubCECDD_Loop
|
|
ECE2 SubCECE2_OnNonnegative
|
|
ECEA SubCECEA_OnOverflowSet
|
|
ECF0 SubCECF0
|
|
ED08 SubCED08_Loop
|
|
ED25 SubCED25
|
|
ED2C SubCED2C_OnNonzero
|
|
ED4B SubCED4B_Loop
|
|
ED51 SubCED51
|
|
ED63 SubCED63
|
|
EDBF SubCEDBF
|
|
EDD5 SubCEDD5
|
|
EDDF SubCEDDF_OnNonnegative
|
|
EE0D SubCEE0D
|
|
EE0F SubCEE0F_OnNonnegative
|
|
EE26 SubCEE26_Loop
|
|
EE31 SubCEE31_Loop
|
|
EE38 SubCEE38_Loop
|
|
EE44 SubCEE44_Loop
|
|
EE4A SubCEE4A_OnNonzero
|
|
EE54 SubCEE54_Loop
|
|
EE58 SubCEE58_Loop
|
|
EE82 SubCEE82_Loop
|
|
EE8D SubCEE8D_Loop
|
|
EE9D SubCEE9D_Loop
|
|
EEA2 SubCEEA2
|
|
EEA7 SubCEEA7_Loop
|
|
EEAA SubCEEAA_Loop
|
|
EEBD SubCEEBD_OnZero
|
|
EEC2 SubCEEC2_OnNonzero
|
|
EEC5 SubCEEC5_Loop
|
|
EF03 SubCEF03_Loop
|
|
EF06 SubCEF06
|
|
EF19 SubCEF19_Loop
|
|
EF3A SubCEF3A_Loop
|
|
EF42 SubCEF42
|
|
EF47 SubCEF47
|
|
EF4E SubCEF4E
|
|
EF56 SubCEF56
|
|
EF62 SubCEF62_Loop
|
|
EF6A SubCEF6A_Loop
|
|
EF6F SubCEF6F_Loop
|
|
EF70 SubCEF70
|
|
EF7B SubCEF7B
|
|
EF7D SubCEF7D
|
|
EF83 SubCEF83
|
|
EF8E SubCEF8E
|
|
EF9A SubCEF9A
|
|
EFA8 SubCEFA8_Loop
|
|
EFB6 SubCEFB6_Loop
|
|
EFB7 SubCEFB7_Loop
|
|
EFCB SubCEFCB_Loop
|
|
EFD3 UpdateMusicChannel19
|
|
EFDF SubCEFDF_Loop
|
|
EFE1 SubCEFE1_Loop
|
|
EFEC SubCEFEC
|
|
EFF3 SubCEFF3
|
|
F014 SubCF014_Loop
|
|
F015 SubCF015_Loop
|
|
F03B SubCF03B_Loop
|
|
F043 SubCF043_Loop
|
|
F04F SubCF04F_Loop
|
|
F075 SubCF075_Loop
|
|
F07F SubCF07F_Loop
|
|
F092 SubCF092_Loop
|
|
F0C8 SubCF0C8_Loop
|
|
F0C9 SubCF0C9
|
|
F0DC SubCF0DC_OnCarryClear
|
|
F0F9 SubCF0F9_Loop
|
|
F10B SubCF10B
|
|
F11C SubCF11C_Loop
|
|
F137 SubCF137_Loop
|
|
F13A SubCF13A_Loop
|
|
F13B SubCF13B
|
|
F19E SubCF19E
|
|
F2EC SubCF2EC
|
|
F305 SubCF305_Loop
|
|
F309 SubCF309_OnNonnegative
|
|
F327 SubCF327_OnNonnegative
|
|
F32E SubCF32E_Loop
|
|
F33A SubCF33A_OnNonnegative
|
|
F343 SubCF343_Loop
|
|
F34A SubCF34A_Loop
|
|
F34E SubCF34E_OnNonzero
|
|
F35A SubCF35A_Loop
|
|
F35B SubCF35B
|
|
F362 SubCF362_OnNonnegative
|
|
F38D SubCF38D_OnCarrySet
|
|
F395 SubCF395_Loop
|
|
F39F SubCF39F_OnNonzero
|
|
F3A1 SubCF3A1_OnNonnegative
|
|
F3BD SubCF3BD
|
|
F3C6 SubCF3C6_Loop
|
|
F3D1 SubCF3D1_Loop
|
|
F3D2 SubCF3D2
|
|
F3F8 SubCF3F8_OnNonnegative
|
|
F42A SubCF42A_Loop
|
|
F430 SubCF430_Loop
|
|
F436 SubCF436_Loop
|
|
F45B SubCF45B_Loop
|
|
F465 SubCF465_Loop
|
|
F504 SubCF504
|
|
F517 SubCF517_Loop
|
|
F524 SubCF524
|
|
F52D SubCF52D_OnNonnegative
|
|
F537 SubCF537_Loop
|
|
F564 SubCF564
|
|
F566 SubCF566_OnNonnegative
|
|
F586 SubCF586
|
|
F5B1 SubCF5B1_Loop
|
|
F5BB SubCF5BB_OnNonnegative
|
|
F5C4 SubCF5C4_Loop
|
|
F630 SubCF630
|
|
F64C SubCF64C
|
|
F660 SubCF660_OnNonzero
|
|
F671 SubCF671_OnNonzero
|
|
F691 SubCF691
|
|
F6A4 SubCF6A4
|
|
F6BD SubCF6BD_Loop
|
|
F6DA SubCF6DA_Loop
|
|
F6DB SubCF6DB_Loop
|
|
F6EA SubCF6EA
|
|
F71D SubCF71D
|
|
F71F SubCF71F_OnNonnegative
|
|
F72C SubCF72C_Loop
|
|
F737 SubCF737
|
|
F74F SubCF74F_Loop
|
|
F773 SubCF773_OnNonnegative
|
|
F77D SubCF77D_Loop
|
|
F783 SubCF783_Loop
|
|
F78A SubCF78A_OnNonzero
|
|
F78B SubCF78B
|
|
F793 SubCF793_Loop
|
|
F7A2 SubCF7A2_Loop
|
|
F7AB SubCF7AB
|
|
F80C SubCF80C
|
|
F82F SubCF82F_Loop
|
|
F838 SubCF838
|
|
F85C SubCF85C_Loop
|
|
F86B SubCF86B_OnNonzero
|
|
F877 SubCF877_Loop
|
|
F87C SubCF87C_Loop
|
|
F889 SubCF889_Loop
|
|
F898 SubCF898_Loop
|
|
F899 SubCF899_Loop
|
|
F8A8 SubCF8A8_Loop
|
|
F8AC SubCF8AC
|
|
F8BE SubCF8BE_Loop
|
|
F8CB SubCF8CB_Loop
|
|
F8D7 SubCF8D7_Loop
|
|
F8DB SubCF8DB
|
|
F8E2 SubCF8E2_OnNegative
|
|
F8F1 SubCF8F1_Loop
|
|
F8F4 SubCF8F4_Loop
|
|
F911 SubCF911_Loop
|
|
F919 SubCF919_Loop
|
|
F91E SubCF91E
|
|
F949 SubCF949_Loop
|
|
F94F SubCF94F_Loop
|
|
F953 SubCF953
|
|
F95A SubCF95A
|
|
F961 SubCF961
|
|
F964 SubCF964
|
|
F966 SubCF966_OnNonzero
|
|
F977 SubCF977_Loop
|
|
F978 SubCF978
|
|
F97B SubCF97B
|
|
F97F SubCF97F
|
|
F983 SubCF983
|
|
F9AB SubCF9AB_OnCarrySet
|
|
F9B1 SubCF9B1_OnCarrySet
|
|
F9C8 SubCF9C8_OnCarrySet
|
|
F9D0 SubCF9D0_OnCarrySet
|
|
F9D6 SubCF9D6_Loop
|
|
F9EB SubCF9EB
|
|
FA0C SubCFA0C_Loop
|
|
FA1B SubCFA1B_Loop
|
|
FA27 SubCFA27_Loop
|
|
FA2F SubCFA2F_Loop
|
|
FA32 SubCFA32_Loop
|
|
FA36 SubCFA36
|
|
FA3A SubCFA3A
|
|
FA3F SubCFA3F_Loop
|
|
FA40 SubCFA40_Loop
|
|
FA4A SubCFA4A_Loop
|
|
FA52 SubCFA52_Loop
|
|
FA64 SubCFA64_OnCarrySet
|
|
FA6B SubCFA6B_OnCarrySet
|
|
FA70 SubCFA70_OnNonzero
|
|
FA7C SubCFA7C_OnNonzero
|
|
FA83 SubCFA83_OnCarrySet
|
|
FA94 SubCFA94_OnCarrySet
|
|
FAA1 SubCFAA1_Loop
|
|
FAAC SubCFAAC_Loop
|
|
FAB2 SubCFAB2_Loop
|
|
FAB5 SubCFAB5_Loop
|
|
FAC3 SubCFAC3_Loop
|
|
FAC4 SubCFAC4
|
|
FAEC SubCFAEC_Loop
|
|
FAF9 SubCFAF9_Loop
|
|
FB09 SubCFB09_Loop
|
|
FB17 SubCFB17_Loop
|
|
FB38 SubCFB38_Loop
|
|
FB71 SubCFB71_OnCarrySet
|
|
FB78 SubCFB78_OnCarrySet
|
|
FB8C SubCFB8C_OnNonzero
|
|
FBA0 SubCFBA0_Loop
|
|
FBA1 SubCFBA1
|
|
FBBB SubCFBBB_Loop
|
|
FBCB SubCFBCB_Loop
|
|
FBDB SubCFBDB_Loop
|
|
FBEB SubCFBEB_Loop
|
|
FBFC SubCFBFC
|
|
FC05 SubCFC05_Loop
|
|
FC11 SubCFC11_OnZero
|
|
FC17 SubCFC17_OnCarryClear
|
|
FC51 SubCFC51_Loop
|
|
FC68 SubCFC68_Loop
|
|
FC79 SubCFC79_Loop
|
|
FC84 SubCFC84_Loop
|
|
FC99 SubCFC99_Loop
|
|
FCA7 SubCFCA7_Loop
|
|
FCAC SubCFCAC_Loop
|
|
FCBE SubCFCBE_Loop
|
|
FCC4 SubCFCC4_Loop
|
|
FCCD SubCFCCD_OnNonzero
|
|
FCE0 SubCFCE0_Loop
|
|
FCF2 SubCFCF2_Loop
|
|
FCF4 SubCFCF4_Loop
|
|
FCFA SubCFCFA_Loop
|
|
FD16 SubCFD16_Loop
|
|
FD21 SubCFD21_Loop
|