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
1379 lines
22 KiB
Plaintext
1379 lines
22 KiB
Plaintext
C79E Reset
|
|
C7E1 SubCC7E1
|
|
C7E7 SubCC7E7
|
|
C807 SubCC807
|
|
C815 SubCC815
|
|
C823 SubCC823
|
|
C831 SubCC831
|
|
C847 SubCC847
|
|
C853 SubCC853
|
|
C85F NmiHandler
|
|
C8F3 SubCC8F3
|
|
C9B1 SubCC9B1
|
|
CA30 SubCCA30
|
|
CA53 SubCCA53
|
|
CAA9 SubCCAA9
|
|
CAB9 SubCCAB9
|
|
CAC9 SubCCAC9
|
|
CB1B SubCCB1B
|
|
CBAE SubCCBAE
|
|
CBB7 SubCCBB7
|
|
CBBD SubCCBBD
|
|
CBCA SubCCBCA
|
|
CBDF SubCCBDF
|
|
CBF5 SubCCBF5
|
|
CBF7 SubCCBF7
|
|
CC04 SubCCC04
|
|
CC24 SubCCC24
|
|
CC34 SubCCC34
|
|
CC47 SubCCC47
|
|
CCC1 SubCCCC1
|
|
CCF4 SubCCCF4
|
|
CD22 SubCCD22
|
|
CD6F SubCCD6F
|
|
CD7F SubCCD7F
|
|
CD89 SubCCD89
|
|
CD9D SubCCD9D
|
|
CDB1 SubCCDB1
|
|
CDCA SubCCDCA
|
|
CE0E SubCCE0E
|
|
CE24 SubCCE24
|
|
CE7C SubCCE7C
|
|
CF13 SubCCF13
|
|
CF19 SubCCF19
|
|
CF1C SubCCF1C
|
|
CF2B SubCCF2B
|
|
CF42 SubCCF42
|
|
CF87 SubCCF87
|
|
CFA8 SubCCFA8
|
|
CFC6 SubCCFC6
|
|
D008 SubCD008
|
|
D032 SubCD032
|
|
D041 SubCD041
|
|
D04C SubCD04C
|
|
D086 SubCD086
|
|
D0B5 SubCD0B5
|
|
D0C0 SubCD0C0
|
|
D175 SubCD175
|
|
D19A SubCD19A
|
|
D1A4 SubCD1A4
|
|
D1AA SubCD1AA
|
|
D1CF SubCD1CF
|
|
D208 SubCD208
|
|
D25D SubCD25D
|
|
D275 SubCD275
|
|
D28B SubCD28B
|
|
D2CB SubCD2CB
|
|
D2DF SubCD2DF
|
|
D2FD SubCD2FD
|
|
D326 SubCD326
|
|
D32F SubCD32F
|
|
D360 SubCD360
|
|
D36A SubCD36A
|
|
D37B SubCD37B
|
|
D37E SubCD37E
|
|
D40D SubCD40D
|
|
D42C SubCD42C
|
|
D432 SubCD432
|
|
D478 SubCD478
|
|
D4B1 SubCD4B1
|
|
D4CC SubCD4CC
|
|
D4CF SubCD4CF
|
|
D4EE SubCD4EE
|
|
D4F9 SubCD4F9
|
|
D501 SubCD501
|
|
D50A SubCD50A
|
|
D547 SubCD547
|
|
D56C SubCD56C
|
|
D5B3 SubCD5B3
|
|
D5F6 SubCD5F6
|
|
D60D SubCD60D
|
|
D697 SubCD697
|
|
D6B7 SubCD6B7
|
|
D6C6 SubCD6C6
|
|
D705 SubCD705
|
|
D713 SubCD713
|
|
D753 SubCD753
|
|
D769 SubCD769
|
|
D79B SubCD79B
|
|
D7AD SubCD7AD
|
|
D7BA SubCD7BA
|
|
D7BF SubCD7BF
|
|
D7DA SubCD7DA
|
|
D7F2 SubCD7F2
|
|
D800 SubCD800
|
|
D87D SubCD87D
|
|
D8AD SubCD8AD
|
|
D8B9 SubCD8B9
|
|
D8E8 SubCD8E8
|
|
D8EB SubCD8EB
|
|
D91A SubCD91A
|
|
D92D SubCD92D
|
|
D93C SubCD93C
|
|
D98D SubCD98D
|
|
D990 SubCD990
|
|
D9D4 SubCD9D4
|
|
D9E6 SubCD9E6
|
|
D9E8 SubCD9E8
|
|
D9F9 SubCD9F9
|
|
DA0F SubCDA0F
|
|
DA16 SubCDA16
|
|
DA4C SubCDA4C
|
|
DA9C SubCDA9C
|
|
DAD5 SubCDAD5
|
|
DAF7 SubCDAF7
|
|
DB00 SubCDB00
|
|
DB2B SubCDB2B
|
|
DB2C SubCDB2C
|
|
DB50 SubCDB50
|
|
DBE7 SubCDBE7
|
|
DBEE SubCDBEE
|
|
DC2D SubCDC2D
|
|
DC30 SubCDC30
|
|
DC51 SubCDC51
|
|
DC69 SubCDC69
|
|
DCD0 SubCDCD0
|
|
DCF3 SubCDCF3
|
|
DD06 SubCDD06
|
|
DD32 SubCDD32
|
|
DD7F SubCDD7F
|
|
DD8B SubCDD8B
|
|
DDB2 SubCDDB2
|
|
DE0D SubCDE0D
|
|
DE1A SubCDE1A
|
|
DE27 SubCDE27
|
|
DE6A SubCDE6A
|
|
DE73 SubCDE73
|
|
DE82 SubCDE82
|
|
DE86 SubCDE86
|
|
DEA5 SubCDEA5
|
|
DF07 SubCDF07
|
|
DF27 SubCDF27
|
|
DF40 SubCDF40
|
|
DF72 SubCDF72
|
|
DFAD SubCDFAD
|
|
DFC3 SubCDFC3
|
|
DFE4 SubCDFE4
|
|
DFE8 SubCDFE8
|
|
DFFB SubCDFFB
|
|
E011 SubCE011
|
|
E016 SubCE016
|
|
E02F SubCE02F
|
|
E048 SubCE048
|
|
E05A SubCE05A
|
|
E06A SubCE06A
|
|
E07B SubCE07B
|
|
E090 SubCE090
|
|
E0A1 SubCE0A1
|
|
E0AE SubCE0AE
|
|
E0EC SubCE0EC
|
|
E0F1 SubCE0F1
|
|
E10F SubCE10F
|
|
E112 SubCE112
|
|
E116 SubCE116
|
|
E12B SubCE12B
|
|
E130 SubCE130
|
|
E141 SubCE141
|
|
E166 SubCE166
|
|
E172 SubCE172
|
|
E19A SubCE19A
|
|
E1D7 SubCE1D7
|
|
E1E0 SubCE1E0
|
|
E1E5 SubCE1E5
|
|
E1E9 SubCE1E9
|
|
E21F SubCE21F
|
|
E250 SubCE250
|
|
E254 SubCE254
|
|
E280 SubCE280
|
|
E29C SubCE29C
|
|
E2B6 SubCE2B6
|
|
E2F6 SubCE2F6
|
|
E2F9 SubCE2F9
|
|
E325 SubCE325
|
|
E34B SubCE34B
|
|
E365 SubCE365
|
|
E368 SubCE368
|
|
E387 SubCE387
|
|
E39B SubCE39B
|
|
E3AF SubCE3AF
|
|
E3C0 SubCE3C0
|
|
E413 SubCE413
|
|
E41B SubCE41B
|
|
E44B SubCE44B
|
|
E4D6 SubCE4D6
|
|
E532 SubCE532
|
|
E538 SubCE538
|
|
E572 SubCE572
|
|
E592 SubCE592
|
|
E594 SubCE594
|
|
E59F SubCE59F
|
|
E5DB SubCE5DB
|
|
E5E8 SubCE5E8
|
|
E5FA SubCE5FA
|
|
E611 SubCE611
|
|
E626 SubCE626
|
|
E66D SubCE66D
|
|
E697 SubCE697
|
|
E69E SubCE69E
|
|
E6A5 SubCE6A5
|
|
E6C6 SubCE6C6
|
|
E6DE SubCE6DE
|
|
E702 SubCE702
|
|
E72D SubCE72D
|
|
E73C SubCE73C
|
|
E747 SubCE747
|
|
E758 SubCE758
|
|
E770 SubCE770
|
|
E7A3 SubCE7A3
|
|
E7E2 SubCE7E2
|
|
E806 SubCE806
|
|
E819 SubCE819
|
|
E82F SubCE82F
|
|
E834 SubCE834
|
|
E84F SubCE84F
|
|
E918 SubCE918
|
|
E945 SubCE945
|
|
E968 SubCE968
|
|
E971 SubCE971
|
|
E97A SubCE97A
|
|
E981 SubCE981
|
|
E986 SubCE986
|
|
E9EA SubCE9EA
|
|
EA01 SubCEA01
|
|
EA34 SubCEA34
|
|
EA5F SubCEA5F
|
|
EA8A SubCEA8A
|
|
EAA1 SubCEAA1
|
|
EAB2 SubCEAB2
|
|
EAC8 SubCEAC8
|
|
EACD SubCEACD
|
|
EAD1 SubCEAD1
|
|
EAD4 SubCEAD4
|
|
EAD6 SubCEAD6
|
|
EADB SubCEADB
|
|
EAE1 SubCEAE1
|
|
EAEC SubCEAEC
|
|
EAF7 SubCEAF7
|
|
EB06 SubCEB06
|
|
EB2B SubCEB2B
|
|
EB85 SubCEB85
|
|
EB89 SubCEB89
|
|
EB8E SubCEB8E
|
|
EB92 SubCEB92
|
|
EB97 SubCEB97
|
|
EB9C SubCEB9C
|
|
EBA1 SubCEBA1
|
|
EBA6 SubCEBA6
|
|
EBA8 SubCEBA8
|
|
EBB6 SubCEBB6
|
|
EBDA SubCEBDA
|
|
EC29 SubCEC29
|
|
EC44 SubCEC44
|
|
EC48 SubCEC48
|
|
ECBF SubCECBF
|
|
ECD3 SubCECD3
|
|
ECFD SubCECFD
|
|
ED07 SubCED07
|
|
ED16 SubCED16
|
|
ED38 SubCED38
|
|
ED87 SubCED87
|
|
ED8A SubCED8A
|
|
ED93 SubCED93
|
|
EDC5 SubCEDC5
|
|
EDEB SubCEDEB
|
|
EE0C SubCEE0C
|
|
EE29 SubCEE29
|
|
EE6C SubCEE6C
|
|
EE79 SubCEE79
|
|
EE8D SubCEE8D
|
|
EEF7 SubCEEF7
|
|
EF38 SubCEF38
|
|
EF51 SubCEF51
|
|
EF72 SubCEF72
|
|
EF89 SubCEF89
|
|
EFA2 SubCEFA2
|
|
EFAD SubCEFAD
|
|
EFD5 SubCEFD5
|
|
EFD7 SubCEFD7
|
|
EFDD SubCEFDD
|
|
EFE2 SubCEFE2
|
|
EFE8 SubCEFE8
|
|
EFEB SubCEFEB
|
|
EFEF SubCEFEF
|
|
EFF3 SubCEFF3
|
|
F059 SubCF059
|
|
F062 SubCF062
|
|
F063 SubCF063
|
|
F069 SubCF069
|
|
F070 SubCF070
|
|
F075 SubCF075
|
|
F078 SubCF078
|
|
F080 SubCF080
|
|
F082 SubCF082
|
|
F086 SubCF086
|
|
F088 SubCF088
|
|
F08C SubCF08C
|
|
F08E SubCF08E
|
|
F092 SubCF092
|
|
F094 SubCF094
|
|
F0E9 SubCF0E9
|
|
F0F2 SubCF0F2
|
|
F10A SubCF10A
|
|
F11E SubCF11E
|
|
F139 SubCF139
|
|
F161 SubCF161
|
|
F195 SubCF195
|
|
F1B4 SubCF1B4
|
|
F228 SubCF228
|
|
F23C SubCF23C
|
|
F24E SubCF24E
|
|
F2D7 SubCF2D7
|
|
F32D SubCF32D
|
|
F32F SubCF32F
|
|
F33E SubCF33E
|
|
F342 SubCF342
|
|
F35E SubCF35E
|
|
F3E3 SubCF3E3
|
|
F404 SubCF404
|
|
F426 SubCF426
|
|
F435 SubCF435
|
|
F4AC SubCF4AC
|
|
F4C2 SubCF4C2
|
|
F4ED SubCF4ED
|
|
F50E SubCF50E
|
|
F522 SubCF522
|
|
FA48 SubCFA48
|
|
FA86 SubCFA86
|
|
FA8F SubCFA8F
|
|
FA93 SubCFA93
|
|
FA95 SubCFA95
|
|
FA9F SubCFA9F
|
|
FAB3 SubCFAB3
|
|
FABA SubCFABA
|
|
FAC4 SubCFAC4
|
|
FACA SubCFACA
|
|
FAD5 SubCFAD5
|
|
FAD7 SubCFAD7
|
|
FAE0 SubCFAE0
|
|
FBF2 SubCFBF2
|
|
FC90 SubCFC90
|
|
FD67 SubCFD67
|
|
FFF0 IrqHandler
|
|
|
|
# ---- derived internal branch-target names ----
|
|
C79E Reset
|
|
C7A8 SubCC7A8_OnZero
|
|
C7B9 SubCC7B9_OnNonzero
|
|
C7E1 SubCC7E1
|
|
C7E7 SubCC7E7
|
|
C807 SubCC807
|
|
C815 SubCC815
|
|
C823 SubCC823
|
|
C831 SubCC831
|
|
C847 SubCC847
|
|
C853 SubCC853
|
|
C85F NmiHandler
|
|
C8A5 SubCC8A5_Loop
|
|
C8C1 SubCC8C1_Loop
|
|
C8CB SubCC8CB_Loop
|
|
C8D4 SubCC8D4_Loop
|
|
C8D7 SubCC8D7_Loop
|
|
C8E8 SubCC8E8_Loop
|
|
C8F3 SubCC8F3
|
|
C8FE SubCC8FE_Loop
|
|
C914 SubCC914_Loop
|
|
C940 SubCC940_Loop
|
|
C95C SubCC95C_Loop
|
|
C95D SubCC95D_Loop
|
|
C976 SubCC976_Loop
|
|
C985 SubCC985_Loop
|
|
C989 SubCC989_Loop
|
|
C98A SubCC98A_Loop
|
|
C991 SubCC991_OnNonzero
|
|
C9AD SubCC9AD_Loop
|
|
C9B1 SubCC9B1
|
|
CA06 SubCCA06_Loop
|
|
CA26 SubCCA26_Loop
|
|
CA30 SubCCA30
|
|
CA4A SubCCA4A_Loop
|
|
CA53 SubCCA53
|
|
CA5A SubCCA5A_Loop
|
|
CA5F SubCCA5F_Loop
|
|
CA64 SubCCA64_Loop
|
|
CA79 SubCCA79_Loop
|
|
CA94 SubCCA94_Loop
|
|
CA99 SubCCA99_Loop
|
|
CAA9 SubCCAA9
|
|
CAAB SubCCAAB_OnNonzero
|
|
CAB9 SubCCAB9
|
|
CABB SubCCABB_OnNonzero
|
|
CAC9 SubCCAC9
|
|
CAD8 SubCCAD8_Loop
|
|
CAE7 SubCCAE7_Loop
|
|
CAF6 SubCCAF6_Loop
|
|
CAFA SubCCAFA_Loop
|
|
CB02 SubCCB02_Loop
|
|
CB15 SubCCB15_Loop
|
|
CB18 SubCCB18_Loop
|
|
CB1B SubCCB1B
|
|
CB30 SubCCB30_Loop
|
|
CB36 SubCCB36_Loop
|
|
CB39 SubCCB39_Loop
|
|
CB46 SubCCB46_Loop
|
|
CB47 SubCCB47_Loop
|
|
CB58 SubCCB58_Loop
|
|
CB7B SubCCB7B_Loop
|
|
CB9E SubCCB9E_Loop
|
|
CBAE SubCCBAE
|
|
CBB7 SubCCBB7
|
|
CBBD SubCCBBD
|
|
CBCA SubCCBCA
|
|
CBDF SubCCBDF
|
|
CBEB SubCCBEB_Loop
|
|
CBF4 SubCCBF4_Loop
|
|
CBF5 SubCCBF5
|
|
CBF7 SubCCBF7
|
|
CC03 SubCCC03_Loop
|
|
CC04 SubCCC04
|
|
CC23 SubCCC23_Loop
|
|
CC24 SubCCC24
|
|
CC34 SubCCC34
|
|
CC47 SubCCC47
|
|
CC4A SubCCC4A_OnNonzero
|
|
CC99 SubCCC99_Loop
|
|
CCA6 SubCCCA6_Loop
|
|
CCC1 SubCCCC1
|
|
CCD6 SubCCCD6_OnNonzero
|
|
CCF3 SubCCCF3_Loop
|
|
CCF4 SubCCCF4
|
|
CD07 SubCCD07_Loop
|
|
CD13 SubCCD13_Loop
|
|
CD22 SubCCD22
|
|
CD45 SubCCD45_Loop
|
|
CD4A SubCCD4A_Loop
|
|
CD4F SubCCD4F_Loop
|
|
CD58 SubCCD58_Loop
|
|
CD61 SubCCD61_Loop
|
|
CD66 SubCCD66_Loop
|
|
CD69 SubCCD69_Loop
|
|
CD6C SubCCD6C_Loop
|
|
CD6F SubCCD6F
|
|
CD76 SubCCD76_OnNonnegative
|
|
CD7F SubCCD7F
|
|
CD89 SubCCD89
|
|
CD9D SubCCD9D
|
|
CDAE SubCCDAE_Loop
|
|
CDB1 SubCCDB1
|
|
CDCA SubCCDCA
|
|
CDD7 SubCCDD7_Loop
|
|
CDEF SubCCDEF_Loop
|
|
CDF3 SubCCDF3_Loop
|
|
CE0E SubCCE0E
|
|
CE1F SubCCE1F_Loop
|
|
CE24 SubCCE24
|
|
CE2F SubCCE2F_Loop
|
|
CE7C SubCCE7C
|
|
CE8B SubCCE8B_Loop
|
|
CE94 SubCCE94_Loop
|
|
CEA2 SubCCEA2_Loop
|
|
CEAE SubCCEAE_Loop
|
|
CEB1 SubCCEB1_Loop
|
|
CEB8 SubCCEB8_Loop
|
|
CEC1 SubCCEC1_Loop
|
|
CED3 SubCCED3_Loop
|
|
CED6 SubCCED6_Loop
|
|
CF01 SubCCF01_Loop
|
|
CF0D SubCCF0D_Loop
|
|
CF13 SubCCF13
|
|
CF19 SubCCF19
|
|
CF1C SubCCF1C
|
|
CF2A SubCCF2A_Loop
|
|
CF2B SubCCF2B
|
|
CF42 SubCCF42
|
|
CF55 SubCCF55_Loop
|
|
CF79 SubCCF79_Loop
|
|
CF7A SubCCF7A_Loop
|
|
CF87 SubCCF87
|
|
CF8F SubCCF8F_Loop
|
|
CF92 SubCCF92_Loop
|
|
CF9B SubCCF9B_Loop
|
|
CFA1 SubCCFA1_Loop
|
|
CFA8 SubCCFA8
|
|
CFAC SubCCFAC_OnNegative
|
|
CFB8 SubCCFB8_Loop
|
|
CFC6 SubCCFC6
|
|
CFCD SubCCFCD_OnNegative
|
|
CFF9 SubCCFF9_Loop
|
|
D008 SubCD008
|
|
D02A SubCD02A_Loop
|
|
D032 SubCD032
|
|
D041 SubCD041
|
|
D04B SubCD04B_Loop
|
|
D04C SubCD04C
|
|
D063 SubCD063_Loop
|
|
D065 SubCD065_OnNonzero
|
|
D074 SubCD074_Loop
|
|
D086 SubCD086
|
|
D092 SubCD092_Loop
|
|
D0A5 SubCD0A5_Loop
|
|
D0AA SubCD0AA_Loop
|
|
D0B5 SubCD0B5
|
|
D0BF SubCD0BF_Loop
|
|
D0C0 SubCD0C0
|
|
D0DD SubCD0DD_Loop
|
|
D0E4 SubCD0E4_Loop
|
|
D0F4 SubCD0F4_Loop
|
|
D0F8 SubCD0F8_Loop
|
|
D101 SubCD101_Loop
|
|
D115 SubCD115_Loop
|
|
D11D SubCD11D_Loop
|
|
D11F SubCD11F_Loop
|
|
D130 SubCD130_Loop
|
|
D138 SubCD138_Loop
|
|
D139 SubCD139_Loop
|
|
D14B SubCD14B_Loop
|
|
D166 SubCD166_Loop
|
|
D169 SubCD169_Loop
|
|
D175 SubCD175
|
|
D189 SubCD189_Loop
|
|
D199 SubCD199_Loop
|
|
D19A SubCD19A
|
|
D1A4 SubCD1A4
|
|
D1AA SubCD1AA
|
|
D1BB SubCD1BB_Loop
|
|
D1C3 SubCD1C3_Loop
|
|
D1C6 SubCD1C6_Loop
|
|
D1C9 SubCD1C9_Loop
|
|
D1CC SubCD1CC_Loop
|
|
D1CF SubCD1CF
|
|
D1E2 SubCD1E2_Loop
|
|
D1E5 SubCD1E5_Loop
|
|
D1F3 SubCD1F3_Loop
|
|
D1F9 SubCD1F9_Loop
|
|
D205 SubCD205_Loop
|
|
D208 SubCD208
|
|
D227 SubCD227_Loop
|
|
D233 SubCD233_Loop
|
|
D23E SubCD23E_Loop
|
|
D25B SubCD25B_Loop
|
|
D25D SubCD25D
|
|
D262 SubCD262_Loop
|
|
D26D SubCD26D_Loop
|
|
D275 SubCD275
|
|
D288 SubCD288_Loop
|
|
D28B SubCD28B
|
|
D2CA SubCD2CA_Loop
|
|
D2CB SubCD2CB
|
|
D2DD SubCD2DD_Loop
|
|
D2DF SubCD2DF
|
|
D2F0 SubCD2F0_Loop
|
|
D2FD SubCD2FD
|
|
D323 SubCD323_Loop
|
|
D326 SubCD326
|
|
D32F SubCD32F
|
|
D34E SubCD34E_Loop
|
|
D353 SubCD353_Loop
|
|
D35E SubCD35E_Loop
|
|
D360 SubCD360
|
|
D365 SubCD365_Loop
|
|
D36A SubCD36A
|
|
D373 SubCD373_Loop
|
|
D37B SubCD37B
|
|
D37E SubCD37E
|
|
D38B SubCD38B_Loop
|
|
D38E SubCD38E_Loop
|
|
D39C SubCD39C_Loop
|
|
D3AF SubCD3AF_Loop
|
|
D3BB SubCD3BB_Loop
|
|
D3CD SubCD3CD_Loop
|
|
D3D0 SubCD3D0_Loop
|
|
D3D2 SubCD3D2_Loop
|
|
D3E7 SubCD3E7_Loop
|
|
D3F9 SubCD3F9_Loop
|
|
D3FB SubCD3FB_Loop
|
|
D40D SubCD40D
|
|
D426 SubCD426_Loop
|
|
D42C SubCD42C
|
|
D432 SubCD432
|
|
D445 SubCD445_Loop
|
|
D45A SubCD45A_Loop
|
|
D471 SubCD471_Loop
|
|
D476 SubCD476_Loop
|
|
D478 SubCD478
|
|
D48B SubCD48B_Loop
|
|
D49D SubCD49D_Loop
|
|
D49F SubCD49F_Loop
|
|
D4B1 SubCD4B1
|
|
D4C6 SubCD4C6_Loop
|
|
D4CC SubCD4CC
|
|
D4CF SubCD4CF
|
|
D4ED SubCD4ED_Loop
|
|
D4EE SubCD4EE
|
|
D4F9 SubCD4F9
|
|
D501 SubCD501
|
|
D509 SubCD509_Loop
|
|
D50A SubCD50A
|
|
D544 SubCD544_Loop
|
|
D547 SubCD547
|
|
D551 SubCD551_Loop
|
|
D55A SubCD55A_Loop
|
|
D56A SubCD56A_Loop
|
|
D56C SubCD56C
|
|
D570 SubCD570_Loop
|
|
D58C SubCD58C_Loop
|
|
D59A SubCD59A_Loop
|
|
D5A1 SubCD5A1_Loop
|
|
D5AF SubCD5AF_Loop
|
|
D5B3 SubCD5B3
|
|
D5CC SubCD5CC_Loop
|
|
D5E2 SubCD5E2_Loop
|
|
D5F1 SubCD5F1_Loop
|
|
D5F6 SubCD5F6
|
|
D60D SubCD60D
|
|
D642 SubCD642_Loop
|
|
D64F SubCD64F_Loop
|
|
D697 SubCD697
|
|
D6B1 SubCD6B1_Loop
|
|
D6B7 SubCD6B7
|
|
D6C5 SubCD6C5_Loop
|
|
D6C6 SubCD6C6
|
|
D6CD SubCD6CD_Loop
|
|
D6D9 SubCD6D9_Loop
|
|
D6E8 SubCD6E8_Loop
|
|
D6F2 SubCD6F2_Loop
|
|
D6FE SubCD6FE_Loop
|
|
D703 SubCD703_Loop
|
|
D705 SubCD705
|
|
D70A SubCD70A_Loop
|
|
D710 SubCD710_Loop
|
|
D713 SubCD713
|
|
D732 SubCD732_Loop
|
|
D73E SubCD73E_Loop
|
|
D74F SubCD74F_Loop
|
|
D753 SubCD753
|
|
D767 SubCD767_Loop
|
|
D769 SubCD769
|
|
D786 SubCD786_Loop
|
|
D795 SubCD795_Loop
|
|
D79B SubCD79B
|
|
D7AD SubCD7AD
|
|
D7B8 SubCD7B8_Loop
|
|
D7BA SubCD7BA
|
|
D7BF SubCD7BF
|
|
D7D3 SubCD7D3_Loop
|
|
D7DA SubCD7DA
|
|
D7F2 SubCD7F2
|
|
D800 SubCD800
|
|
D805 SubCD805_Loop
|
|
D80E SubCD80E_Loop
|
|
D81E SubCD81E_Loop
|
|
D827 SubCD827_Loop
|
|
D849 SubCD849_Loop
|
|
D856 SubCD856_Loop
|
|
D867 SubCD867_Loop
|
|
D86F SubCD86F_Loop
|
|
D87D SubCD87D
|
|
D8A7 SubCD8A7_Loop
|
|
D8A8 SubCD8A8_Loop
|
|
D8AD SubCD8AD
|
|
D8B9 SubCD8B9
|
|
D8E1 SubCD8E1_Loop
|
|
D8E6 SubCD8E6_Loop
|
|
D8E8 SubCD8E8
|
|
D8EB SubCD8EB
|
|
D904 SubCD904_Loop
|
|
D911 SubCD911_Loop
|
|
D914 SubCD914_Loop
|
|
D917 SubCD917_Loop
|
|
D91A SubCD91A
|
|
D92D SubCD92D
|
|
D938 SubCD938_Loop
|
|
D93B SubCD93B_Loop
|
|
D93C SubCD93C
|
|
D964 SubCD964_OnNonzero
|
|
D986 SubCD986_Loop
|
|
D98B SubCD98B_Loop
|
|
D98D SubCD98D
|
|
D990 SubCD990
|
|
D99D SubCD99D_Loop
|
|
D9AF SubCD9AF_Loop
|
|
D9D0 SubCD9D0_Loop
|
|
D9D4 SubCD9D4
|
|
D9E0 SubCD9E0_Loop
|
|
D9E3 SubCD9E3_Loop
|
|
D9E6 SubCD9E6
|
|
D9E8 SubCD9E8
|
|
D9F5 SubCD9F5_Loop
|
|
D9F9 SubCD9F9
|
|
DA06 SubCDA06_Loop
|
|
DA0F SubCDA0F
|
|
DA13 SubCDA13_Loop
|
|
DA16 SubCDA16
|
|
DA1D SubCDA1D_OnNonzero
|
|
DA3D SubCDA3D_Loop
|
|
DA40 SubCDA40_Loop
|
|
DA4C SubCDA4C
|
|
DA7D SubCDA7D_Loop
|
|
DA80 SubCDA80_Loop
|
|
DA83 SubCDA83_Loop
|
|
DA86 SubCDA86_Loop
|
|
DA89 SubCDA89_Loop
|
|
DA8F SubCDA8F_Loop
|
|
DA92 SubCDA92_Loop
|
|
DA95 SubCDA95_Loop
|
|
DA98 SubCDA98_Loop
|
|
DA9C SubCDA9C
|
|
DAC3 SubCDAC3_Loop
|
|
DAD5 SubCDAD5
|
|
DAF2 SubCDAF2_Loop
|
|
DAF7 SubCDAF7
|
|
DAFF SubCDAFF_Loop
|
|
DB00 SubCDB00
|
|
DB21 SubCDB21_Loop
|
|
DB2B SubCDB2B
|
|
DB2C SubCDB2C
|
|
DB34 SubCDB34_Loop
|
|
DB4E SubCDB4E_Loop
|
|
DB50 SubCDB50
|
|
DBA3 SubCDBA3_Loop
|
|
DBAC SubCDBAC_Loop
|
|
DBB6 SubCDBB6_Loop
|
|
DBCD SubCDBCD_Loop
|
|
DBE7 SubCDBE7
|
|
DBED SubCDBED_Loop
|
|
DBEE SubCDBEE
|
|
DBFB SubCDBFB_Loop
|
|
DC16 SubCDC16_Loop
|
|
DC1B SubCDC1B_Loop
|
|
DC2B SubCDC2B_Loop
|
|
DC2D SubCDC2D
|
|
DC30 SubCDC30
|
|
DC4F SubCDC4F_Loop
|
|
DC51 SubCDC51
|
|
DC68 SubCDC68_Loop
|
|
DC69 SubCDC69
|
|
DC71 SubCDC71_Loop
|
|
DC8E SubCDC8E_Loop
|
|
DC90 SubCDC90_Loop
|
|
DCBC SubCDCBC_Loop
|
|
DCC9 SubCDCC9_Loop
|
|
DCCF SubCDCCF_Loop
|
|
DCD0 SubCDCD0
|
|
DCD8 SubCDCD8_Loop
|
|
DCF3 SubCDCF3
|
|
DD00 SubCDD00_Loop
|
|
DD06 SubCDD06
|
|
DD13 SubCDD13_Loop
|
|
DD25 SubCDD25_Loop
|
|
DD32 SubCDD32
|
|
DD3A SubCDD3A_Loop
|
|
DD59 SubCDD59_Loop
|
|
DD60 SubCDD60_Loop
|
|
DD6A SubCDD6A_Loop
|
|
DD73 SubCDD73_Loop
|
|
DD7F SubCDD7F
|
|
DD8B SubCDD8B
|
|
DD98 SubCDD98_Loop
|
|
DDAB SubCDDAB_Loop
|
|
DDB0 SubCDDB0_Loop
|
|
DDB2 SubCDDB2
|
|
DDC9 SubCDDC9_Loop
|
|
DDD7 SubCDDD7_Loop
|
|
DDF5 SubCDDF5_Loop
|
|
DE0B SubCDE0B_Loop
|
|
DE0D SubCDE0D
|
|
DE10 SubCDE10_Loop
|
|
DE13 SubCDE13_Loop
|
|
DE1A SubCDE1A
|
|
DE27 SubCDE27
|
|
DE36 SubCDE36_Loop
|
|
DE50 SubCDE50_Loop
|
|
DE56 SubCDE56_Loop
|
|
DE68 SubCDE68_Loop
|
|
DE6A SubCDE6A
|
|
DE73 SubCDE73
|
|
DE82 SubCDE82
|
|
DE85 SubCDE85_Loop
|
|
DE86 SubCDE86
|
|
DE90 SubCDE90_OnNonzero
|
|
DE9F SubCDE9F_Loop
|
|
DEA4 SubCDEA4_Loop
|
|
DEA5 SubCDEA5
|
|
DEDC SubCDEDC_OnZero
|
|
DEE8 SubCDEE8_Loop
|
|
DEED SubCDEED_Loop
|
|
DEF2 SubCDEF2_Loop
|
|
DEFB SubCDEFB_Loop
|
|
DF07 SubCDF07
|
|
DF0F SubCDF0F_Loop
|
|
DF25 SubCDF25_Loop
|
|
DF27 SubCDF27
|
|
DF35 SubCDF35_Loop
|
|
DF40 SubCDF40
|
|
DF45 SubCDF45_Loop
|
|
DF4C SubCDF4C_Loop
|
|
DF55 SubCDF55_Loop
|
|
DF5E SubCDF5E_Loop
|
|
DF60 SubCDF60_OnNonzero
|
|
DF6C SubCDF6C_Loop
|
|
DF72 SubCDF72
|
|
DF7B SubCDF7B_Loop
|
|
DF7D SubCDF7D_OnNonzero
|
|
DF89 SubCDF89_Loop
|
|
DF8F SubCDF8F_Loop
|
|
DFAD SubCDFAD
|
|
DFB8 SubCDFB8_Loop
|
|
DFC3 SubCDFC3
|
|
DFE3 SubCDFE3_Loop
|
|
DFE4 SubCDFE4
|
|
DFE8 SubCDFE8
|
|
DFF7 SubCDFF7_Loop
|
|
DFFB SubCDFFB
|
|
E008 SubCE008_Loop
|
|
E011 SubCE011
|
|
E015 SubCE015_Loop
|
|
E016 SubCE016
|
|
E02F SubCE02F
|
|
E041 SubCE041_Loop
|
|
E045 SubCE045_Loop
|
|
E048 SubCE048
|
|
E057 SubCE057_Loop
|
|
E05A SubCE05A
|
|
E06A SubCE06A
|
|
E079 SubCE079_Loop
|
|
E07B SubCE07B
|
|
E08A SubCE08A_Loop
|
|
E08D SubCE08D_Loop
|
|
E090 SubCE090
|
|
E09F SubCE09F_Loop
|
|
E0A1 SubCE0A1
|
|
E0AB SubCE0AB_Loop
|
|
E0AE SubCE0AE
|
|
E0CB SubCE0CB_Loop
|
|
E0D1 SubCE0D1_Loop
|
|
E0DD SubCE0DD_Loop
|
|
E0E9 SubCE0E9_Loop
|
|
E0EC SubCE0EC
|
|
E0F1 SubCE0F1
|
|
E107 SubCE107_Loop
|
|
E109 SubCE109_Loop
|
|
E10F SubCE10F
|
|
E112 SubCE112
|
|
E116 SubCE116
|
|
E124 SubCE124_Loop
|
|
E129 SubCE129_Loop
|
|
E12B SubCE12B
|
|
E130 SubCE130
|
|
E13E SubCE13E_Loop
|
|
E141 SubCE141
|
|
E166 SubCE166
|
|
E16A SubCE16A_OnNonnegative
|
|
E172 SubCE172
|
|
E17F SubCE17F_Loop
|
|
E187 SubCE187_Loop
|
|
E199 SubCE199_Loop
|
|
E19A SubCE19A
|
|
E19F SubCE19F_Loop
|
|
E1BF SubCE1BF_Loop
|
|
E1D5 SubCE1D5_Loop
|
|
E1D7 SubCE1D7
|
|
E1E0 SubCE1E0
|
|
E1E4 SubCE1E4_Loop
|
|
E1E5 SubCE1E5
|
|
E1E9 SubCE1E9
|
|
E200 SubCE200_Loop
|
|
E213 SubCE213_Loop
|
|
E21F SubCE21F
|
|
E225 SubCE225_Loop
|
|
E228 SubCE228_Loop
|
|
E237 SubCE237_Loop
|
|
E24F SubCE24F_Loop
|
|
E250 SubCE250
|
|
E254 SubCE254
|
|
E278 SubCE278_Loop
|
|
E280 SubCE280
|
|
E28A SubCE28A_Loop
|
|
E28C SubCE28C_Loop
|
|
E28F SubCE28F_Loop
|
|
E292 SubCE292_Loop
|
|
E295 SubCE295_Loop
|
|
E29A SubCE29A_Loop
|
|
E29C SubCE29C
|
|
E2A1 SubCE2A1_Loop
|
|
E2B3 SubCE2B3_Loop
|
|
E2B6 SubCE2B6
|
|
E2D9 SubCE2D9_Loop
|
|
E2DD SubCE2DD_Loop
|
|
E2EB SubCE2EB_Loop
|
|
E2F4 SubCE2F4_Loop
|
|
E2F6 SubCE2F6
|
|
E2F9 SubCE2F9
|
|
E305 SubCE305_Loop
|
|
E31A SubCE31A_Loop
|
|
E323 SubCE323_Loop
|
|
E325 SubCE325
|
|
E33B SubCE33B_Loop
|
|
E340 SubCE340_Loop
|
|
E349 SubCE349_Loop
|
|
E34B SubCE34B
|
|
E363 SubCE363_Loop
|
|
E365 SubCE365
|
|
E368 SubCE368
|
|
E374 SubCE374_Loop
|
|
E385 SubCE385_Loop
|
|
E387 SubCE387
|
|
E396 SubCE396_Loop
|
|
E39B SubCE39B
|
|
E3AA SubCE3AA_Loop
|
|
E3AF SubCE3AF
|
|
E3BA SubCE3BA_Loop
|
|
E3C0 SubCE3C0
|
|
E3CE SubCE3CE_Loop
|
|
E3DD SubCE3DD_Loop
|
|
E3E6 SubCE3E6_Loop
|
|
E3ED SubCE3ED_Loop
|
|
E403 SubCE403_Loop
|
|
E408 SubCE408_Loop
|
|
E411 SubCE411_Loop
|
|
E413 SubCE413
|
|
E41B SubCE41B
|
|
E429 SubCE429_OnCarryClear
|
|
E436 SubCE436_Loop
|
|
E44B SubCE44B
|
|
E451 SubCE451_Loop
|
|
E466 SubCE466_Loop
|
|
E46D SubCE46D_Loop
|
|
E47A SubCE47A_Loop
|
|
E48E SubCE48E_Loop
|
|
E49B SubCE49B_Loop
|
|
E4A8 SubCE4A8_Loop
|
|
E4B5 SubCE4B5_Loop
|
|
E4C0 SubCE4C0_Loop
|
|
E4D3 SubCE4D3_Loop
|
|
E4D6 SubCE4D6
|
|
E4F9 SubCE4F9_Loop
|
|
E50C SubCE50C_Loop
|
|
E522 SubCE522_Loop
|
|
E527 SubCE527_Loop
|
|
E530 SubCE530_Loop
|
|
E532 SubCE532
|
|
E538 SubCE538
|
|
E545 SubCE545_Loop
|
|
E548 SubCE548_Loop
|
|
E553 SubCE553_Loop
|
|
E564 SubCE564_Loop
|
|
E570 SubCE570_Loop
|
|
E572 SubCE572
|
|
E592 SubCE592
|
|
E594 SubCE594
|
|
E59F SubCE59F
|
|
E5B4 SubCE5B4_Loop
|
|
E5BE SubCE5BE_Loop
|
|
E5D9 SubCE5D9_Loop
|
|
E5DB SubCE5DB
|
|
E5E5 SubCE5E5_Loop
|
|
E5E8 SubCE5E8
|
|
E5FA SubCE5FA
|
|
E609 SubCE609_Loop
|
|
E60C SubCE60C_Loop
|
|
E60F SubCE60F_Loop
|
|
E611 SubCE611
|
|
E620 SubCE620_Loop
|
|
E623 SubCE623_Loop
|
|
E626 SubCE626
|
|
E62F SubCE62F_Loop
|
|
E640 SubCE640_Loop
|
|
E64D SubCE64D_Loop
|
|
E65D SubCE65D_Loop
|
|
E66D SubCE66D
|
|
E67A SubCE67A_Loop
|
|
E68A SubCE68A_Loop
|
|
E697 SubCE697
|
|
E69E SubCE69E
|
|
E6A5 SubCE6A5
|
|
E6BC SubCE6BC_Loop
|
|
E6C3 SubCE6C3_Loop
|
|
E6C6 SubCE6C6
|
|
E6DB SubCE6DB_Loop
|
|
E6DE SubCE6DE
|
|
E6E3 SubCE6E3_Loop
|
|
E6F3 SubCE6F3_Loop
|
|
E6FB SubCE6FB_Loop
|
|
E702 SubCE702
|
|
E719 SubCE719_Loop
|
|
E721 SubCE721_Loop
|
|
E72D SubCE72D
|
|
E72E SubCE72E_Loop
|
|
E735 SubCE735_Loop
|
|
E73C SubCE73C
|
|
E747 SubCE747
|
|
E755 SubCE755_Loop
|
|
E758 SubCE758
|
|
E75C SubCE75C_Loop
|
|
E769 SubCE769_Loop
|
|
E770 SubCE770
|
|
E790 SubCE790_Loop
|
|
E79D SubCE79D_Loop
|
|
E7A0 SubCE7A0_Loop
|
|
E7A3 SubCE7A3
|
|
E7AE SubCE7AE_Loop
|
|
E7E2 SubCE7E2
|
|
E7F2 SubCE7F2_Loop
|
|
E7F9 SubCE7F9_Loop
|
|
E806 SubCE806
|
|
E815 SubCE815_Loop
|
|
E819 SubCE819
|
|
E826 SubCE826_Loop
|
|
E82F SubCE82F
|
|
E833 SubCE833_Loop
|
|
E834 SubCE834
|
|
E84B SubCE84B_Loop
|
|
E84F SubCE84F
|
|
E86A SubCE86A_Loop
|
|
E889 SubCE889_Loop
|
|
E890 SubCE890_Loop
|
|
E89B SubCE89B_Loop
|
|
E8A4 SubCE8A4_Loop
|
|
E8A9 SubCE8A9_Loop
|
|
E8C4 SubCE8C4_Loop
|
|
E8E3 SubCE8E3_Loop
|
|
E8EA SubCE8EA_Loop
|
|
E8F8 SubCE8F8_Loop
|
|
E8FC SubCE8FC_Loop
|
|
E901 SubCE901_Loop
|
|
E90E SubCE90E_Loop
|
|
E918 SubCE918
|
|
E92E SubCE92E_Loop
|
|
E93B SubCE93B_Loop
|
|
E945 SubCE945
|
|
E95B SubCE95B_Loop
|
|
E967 SubCE967_Loop
|
|
E968 SubCE968
|
|
E971 SubCE971
|
|
E97A SubCE97A
|
|
E981 SubCE981
|
|
E986 SubCE986
|
|
E9B4 SubCE9B4_Loop
|
|
E9BE SubCE9BE_Loop
|
|
E9DA SubCE9DA_Loop
|
|
E9EA SubCE9EA
|
|
E9F0 SubCE9F0_Loop
|
|
E9F3 SubCE9F3_Loop
|
|
EA00 SubCEA00_Loop
|
|
EA01 SubCEA01
|
|
EA11 SubCEA11_Loop
|
|
EA2A SubCEA2A_Loop
|
|
EA2F SubCEA2F_Loop
|
|
EA34 SubCEA34
|
|
EA5E SubCEA5E_Loop
|
|
EA5F SubCEA5F
|
|
EA64 SubCEA64_Loop
|
|
EA72 SubCEA72_Loop
|
|
EA88 SubCEA88_Loop
|
|
EA8A SubCEA8A
|
|
EAA0 SubCEAA0_Loop
|
|
EAA1 SubCEAA1
|
|
EAAE SubCEAAE_Loop
|
|
EAB2 SubCEAB2
|
|
EABF SubCEABF_Loop
|
|
EAC8 SubCEAC8
|
|
EACC SubCEACC_Loop
|
|
EACD SubCEACD
|
|
EAD1 SubCEAD1
|
|
EAD4 SubCEAD4
|
|
EAD6 SubCEAD6
|
|
EADB SubCEADB
|
|
EAE1 SubCEAE1
|
|
EAEC SubCEAEC
|
|
EAF7 SubCEAF7
|
|
EB05 SubCEB05_Loop
|
|
EB06 SubCEB06
|
|
EB0C SubCEB0C_Loop
|
|
EB2B SubCEB2B
|
|
EB32 SubCEB32_Loop
|
|
EB39 SubCEB39_Loop
|
|
EB40 SubCEB40_Loop
|
|
EB47 SubCEB47_Loop
|
|
EB4E SubCEB4E_Loop
|
|
EB4F SubCEB4F_Loop
|
|
EB54 SubCEB54_Loop
|
|
EB6F SubCEB6F_Loop
|
|
EB74 SubCEB74_Loop
|
|
EB7B SubCEB7B_Loop
|
|
EB85 SubCEB85
|
|
EB89 SubCEB89
|
|
EB8E SubCEB8E
|
|
EB92 SubCEB92
|
|
EB97 SubCEB97
|
|
EB9C SubCEB9C
|
|
EBA1 SubCEBA1
|
|
EBA6 SubCEBA6
|
|
EBA8 SubCEBA8
|
|
EBB6 SubCEBB6
|
|
EBBB SubCEBBB_Loop
|
|
EBC4 SubCEBC4_Loop
|
|
EBDA SubCEBDA
|
|
EBED SubCEBED_Loop
|
|
EC03 SubCEC03_Loop
|
|
EC0A SubCEC0A_Loop
|
|
EC12 SubCEC12_Loop
|
|
EC16 SubCEC16_Loop
|
|
EC29 SubCEC29
|
|
EC3B SubCEC3B_Loop
|
|
EC3E SubCEC3E_Loop
|
|
EC44 SubCEC44
|
|
EC48 SubCEC48
|
|
EC5B SubCEC5B_Loop
|
|
EC76 SubCEC76_Loop
|
|
EC80 SubCEC80_Loop
|
|
EC97 SubCEC97_Loop
|
|
ECA7 SubCECA7_Loop
|
|
ECAF SubCECAF_Loop
|
|
ECBE SubCECBE_Loop
|
|
ECBF SubCECBF
|
|
ECC6 SubCECC6_Loop
|
|
ECD1 SubCECD1_Loop
|
|
ECD3 SubCECD3
|
|
ECE8 SubCECE8_Loop
|
|
ECF7 SubCECF7_Loop
|
|
ECFD SubCECFD
|
|
ED07 SubCED07
|
|
ED16 SubCED16
|
|
ED34 SubCED34_Loop
|
|
ED38 SubCED38
|
|
ED57 SubCED57_Loop
|
|
ED74 SubCED74_Loop
|
|
ED85 SubCED85_Loop
|
|
ED87 SubCED87
|
|
ED8A SubCED8A
|
|
ED93 SubCED93
|
|
EDAD SubCEDAD_Loop
|
|
EDB5 SubCEDB5_Loop
|
|
EDC4 SubCEDC4_Loop
|
|
EDC5 SubCEDC5
|
|
EDD2 SubCEDD2_Loop
|
|
EDEB SubCEDEB
|
|
EE07 SubCEE07_Loop
|
|
EE0B SubCEE0B_Loop
|
|
EE0C SubCEE0C
|
|
EE1A SubCEE1A_Loop
|
|
EE26 SubCEE26_Loop
|
|
EE29 SubCEE29
|
|
EE38 SubCEE38_Loop
|
|
EE51 SubCEE51_Loop
|
|
EE5C SubCEE5C_Loop
|
|
EE6C SubCEE6C
|
|
EE79 SubCEE79
|
|
EE80 SubCEE80_Loop
|
|
EE8D SubCEE8D
|
|
EED8 SubCEED8_Loop
|
|
EED9 SubCEED9_Loop
|
|
EEE6 SubCEEE6_Loop
|
|
EEE7 SubCEEE7_Loop
|
|
EEF0 SubCEEF0_Loop
|
|
EEF7 SubCEEF7
|
|
EF2E SubCEF2E_OnZero
|
|
EF2F SubCEF2F_Loop
|
|
EF38 SubCEF38
|
|
EF51 SubCEF51
|
|
EF71 SubCEF71_Loop
|
|
EF72 SubCEF72
|
|
EF87 SubCEF87_Loop
|
|
EF89 SubCEF89
|
|
EF94 SubCEF94_Loop
|
|
EFA0 SubCEFA0_Loop
|
|
EFA2 SubCEFA2
|
|
EFAD SubCEFAD
|
|
EFD5 SubCEFD5
|
|
EFD7 SubCEFD7
|
|
EFDD SubCEFDD
|
|
EFE2 SubCEFE2
|
|
EFE8 SubCEFE8
|
|
EFEB SubCEFEB
|
|
EFEF SubCEFEF
|
|
EFF3 SubCEFF3
|
|
EFF5 SubCEFF5_Loop
|
|
F018 SubCF018_Loop
|
|
F057 SubCF057_Loop
|
|
F059 SubCF059
|
|
F062 SubCF062
|
|
F063 SubCF063
|
|
F069 SubCF069
|
|
F070 SubCF070
|
|
F075 SubCF075
|
|
F078 SubCF078
|
|
F080 SubCF080
|
|
F082 SubCF082
|
|
F086 SubCF086
|
|
F088 SubCF088
|
|
F08C SubCF08C
|
|
F08E SubCF08E
|
|
F092 SubCF092
|
|
F094 SubCF094
|
|
F096 SubCF096_Loop
|
|
F0CB SubCF0CB_OnNonzero
|
|
F0DC SubCF0DC_Loop
|
|
F0E6 SubCF0E6_Loop
|
|
F0E9 SubCF0E9
|
|
F0EF SubCF0EF_Loop
|
|
F0F2 SubCF0F2
|
|
F10A SubCF10A
|
|
F10E SubCF10E_OnNonzero
|
|
F11E SubCF11E
|
|
F124 SubCF124_OnNonzero
|
|
F139 SubCF139
|
|
F13B SubCF13B_OnNonzero
|
|
F141 SubCF141_OnNonzero
|
|
F161 SubCF161
|
|
F16A SubCF16A_OnNonnegative
|
|
F16F SubCF16F_OnNonzero
|
|
F195 SubCF195
|
|
F197 SubCF197_OnNonzero
|
|
F19F SubCF19F_OnNonzero
|
|
F1B4 SubCF1B4
|
|
F1CE SubCF1CE_OnNonzero
|
|
F1E5 SubCF1E5_OnNonzero
|
|
F1EC SubCF1EC_OnNonzero
|
|
F202 SubCF202_Loop
|
|
F20E SubCF20E_Loop
|
|
F211 SubCF211_OnNonzero
|
|
F214 SubCF214_Loop
|
|
F228 SubCF228
|
|
F23C SubCF23C
|
|
F23F SubCF23F_OnNonnegative
|
|
F248 SubCF248_Loop
|
|
F24E SubCF24E
|
|
F28E SubCF28E_OnNonzero
|
|
F296 SubCF296_Loop
|
|
F29A SubCF29A_Loop
|
|
F2B0 SubCF2B0_Loop
|
|
F2B4 SubCF2B4_Loop
|
|
F2BE SubCF2BE_Loop
|
|
F2C4 SubCF2C4_Loop
|
|
F2D6 SubCF2D6_Loop
|
|
F2D7 SubCF2D7
|
|
F2EA SubCF2EA_OnNonzero
|
|
F303 SubCF303_OnNonzero
|
|
F32D SubCF32D
|
|
F32F SubCF32F
|
|
F33D SubCF33D_Loop
|
|
F33E SubCF33E
|
|
F342 SubCF342
|
|
F344 SubCF344_Loop
|
|
F355 SubCF355_Loop
|
|
F35E SubCF35E
|
|
F36B SubCF36B_OnZero
|
|
F38E SubCF38E_Loop
|
|
F392 SubCF392_Loop
|
|
F3C0 SubCF3C0_Loop
|
|
F3C6 SubCF3C6_Loop
|
|
F3E2 SubCF3E2_Loop
|
|
F3E3 SubCF3E3
|
|
F3EE SubCF3EE_Loop
|
|
F3FB SubCF3FB_OnCarrySet
|
|
F3FF SubCF3FF_Loop
|
|
F404 SubCF404
|
|
F417 SubCF417_Loop
|
|
F423 SubCF423_Loop
|
|
F426 SubCF426
|
|
F435 SubCF435
|
|
F44A SubCF44A_OnNonnegative
|
|
F453 SubCF453_OnZero
|
|
F479 SubCF479_OnNonzero
|
|
F47E SubCF47E_OnCarryClear
|
|
F493 SubCF493_Loop
|
|
F49F SubCF49F_Loop
|
|
F4A0 SubCF4A0_Loop
|
|
F4A4 SubCF4A4_Loop
|
|
F4A9 SubCF4A9_Loop
|
|
F4AC SubCF4AC
|
|
F4B8 SubCF4B8_OnNonnegative
|
|
F4BE SubCF4BE_Loop
|
|
F4C2 SubCF4C2
|
|
F4ED SubCF4ED
|
|
F4FD SubCF4FD_Loop
|
|
F50E SubCF50E
|
|
F522 SubCF522
|
|
F524 SubCF524_OnNonzero
|
|
F549 SubCF549_Loop
|
|
F55A SubCF55A_Loop
|
|
FA48 SubCFA48
|
|
FA64 SubCFA64_Loop
|
|
FA6B SubCFA6B_Loop
|
|
FA7F SubCFA7F_Loop
|
|
FA82 SubCFA82_Loop
|
|
FA86 SubCFA86
|
|
FA88 SubCFA88_OnNonzero
|
|
FA8E SubCFA8E_Loop
|
|
FA8F SubCFA8F
|
|
FA93 SubCFA93
|
|
FA95 SubCFA95
|
|
FA9F SubCFA9F
|
|
FAA1 SubCFAA1_OnNonzero
|
|
FAB2 SubCFAB2_Loop
|
|
FAB3 SubCFAB3
|
|
FABA SubCFABA
|
|
FAC4 SubCFAC4
|
|
FACA SubCFACA
|
|
FAD5 SubCFAD5
|
|
FAD7 SubCFAD7
|
|
FAE0 SubCFAE0
|
|
FB75 SubCFB75_OnZero
|
|
FB7E SubCFB7E_OnCarrySet
|
|
FB89 SubCFB89_OnCarrySet
|
|
FBA0 SubCFBA0_Loop
|
|
FBA7 SubCFBA7_Loop
|
|
FBAF SubCFBAF_Loop
|
|
FBB2 SubCFBB2_Loop
|
|
FBB7 SubCFBB7_OnCarrySet
|
|
FBC2 SubCFBC2_OnCarrySet
|
|
FBD4 SubCFBD4_Loop
|
|
FBD9 SubCFBD9_Loop
|
|
FBF2 SubCFBF2
|
|
FC16 SubCFC16_OnZero
|
|
FC19 SubCFC19_Loop
|
|
FC28 SubCFC28_Loop
|
|
FC30 SubCFC30_Loop
|
|
FC41 SubCFC41_OnNonzero
|
|
FC44 SubCFC44_Loop
|
|
FC4B SubCFC4B_Loop
|
|
FC51 SubCFC51_Loop
|
|
FC62 SubCFC62_Loop
|
|
FC73 SubCFC73_OnNegative
|
|
FC7F SubCFC7F_OnNonzero
|
|
FC90 SubCFC90
|
|
FC9D SubCFC9D_Loop
|
|
FCBA SubCFCBA_Loop
|
|
FCBE SubCFCBE_Loop
|
|
FCC6 SubCFCC6_Loop
|
|
FCD1 SubCFCD1_OnZero
|
|
FCDB SubCFCDB_Loop
|
|
FCDD SubCFCDD_Loop
|
|
FCF0 SubCFCF0_Loop
|
|
FD00 SubCFD00_Loop
|
|
FD0B SubCFD0B_Loop
|
|
FD18 SubCFD18_Loop
|
|
FD1D SubCFD1D_OnZero
|
|
FD35 SubCFD35_Loop
|
|
FD3A SubCFD3A_Loop
|
|
FD58 SubCFD58_Loop
|
|
FD62 SubCFD62_Loop
|
|
FD67 SubCFD67
|
|
FD9B SubCFD9B_Loop
|
|
FDA4 SubCFDA4_Loop
|
|
FDB8 SubCFDB8_Loop
|
|
FDC1 SubCFDC1_Loop
|
|
FDCF SubCFDCF_Loop
|
|
FDD8 SubCFDD8_Loop
|
|
FDE9 SubCFDE9_Loop
|
|
FE00 SubCFE00_Loop
|
|
FE03 SubCFE03_Loop
|
|
FE09 SubCFE09_Loop
|
|
FE1D SubCFE1D_Loop
|
|
FE2E SubCFE2E_Loop
|
|
FE31 SubCFE31_Loop
|
|
FE4F SubCFE4F_Loop
|
|
FE55 SubCFE55_Loop
|
|
FE58 SubCFE58_Loop
|
|
FFF0 IrqHandler
|