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
1298 lines
22 KiB
Plaintext
1298 lines
22 KiB
Plaintext
8000 Reset
|
|
805A NmiHandler
|
|
810F SubC810F
|
|
8111 SubC8111
|
|
8159 SubC8159
|
|
8171 SubC8171
|
|
8188 SubC8188
|
|
8194 SubC8194
|
|
81C5 SubC81C5
|
|
821B SubC821B
|
|
824A SubC824A
|
|
8254 SubC8254
|
|
8282 SubC8282
|
|
82E6 SubC82E6
|
|
82F9 SubC82F9
|
|
8359 SubC8359
|
|
836E SubC836E
|
|
8376 SubC8376
|
|
837D SubC837D
|
|
8517 SubC8517
|
|
853C SubC853C
|
|
8601 SubC8601
|
|
86BD SubC86BD
|
|
86CA SubC86CA
|
|
86E5 SubC86E5
|
|
8730 SubC8730
|
|
873A SubC873A
|
|
87A4 SubC87A4
|
|
87C7 SubC87C7
|
|
87E8 SubC87E8
|
|
8843 SubC8843
|
|
88EE SubC88EE
|
|
8995 SubC8995
|
|
8A14 SubC8A14
|
|
8A2B SubC8A2B
|
|
8A68 SubC8A68
|
|
8A89 SubC8A89
|
|
8A98 SubC8A98
|
|
8AA7 SubC8AA7
|
|
8AB6 SubC8AB6
|
|
8AC5 SubC8AC5
|
|
8ACC SubC8ACC
|
|
8AD8 SubC8AD8
|
|
8B4C SubC8B4C
|
|
8CF2 SubC8CF2
|
|
8D8F SubC8D8F
|
|
8DE1 SubC8DE1
|
|
8E20 SubC8E20
|
|
8EB0 SubC8EB0
|
|
8F52 SubC8F52
|
|
90CB SubC90CB
|
|
9109 SubC9109
|
|
92CA SubC92CA
|
|
92F5 SubC92F5
|
|
9314 SubC9314
|
|
9430 SubC9430
|
|
A3CE SubCA3CE
|
|
A756 SubCA756
|
|
A792 SubCA792
|
|
A7B2 SubCA7B2
|
|
A836 SubCA836
|
|
A87B SubCA87B
|
|
A892 SubCA892
|
|
A8BA SubCA8BA
|
|
A8CC SubCA8CC
|
|
A905 SubCA905
|
|
A921 SubCA921
|
|
A933 SubCA933
|
|
A934 SubCA934
|
|
A946 SubCA946
|
|
A947 SubCA947
|
|
A959 SubCA959
|
|
A96D SubCA96D
|
|
A981 SubCA981
|
|
A999 SubCA999
|
|
A9B4 SubCA9B4
|
|
A9E1 SubCA9E1
|
|
A9E7 SubCA9E7
|
|
AA17 SubCAA17
|
|
AA47 SubCAA47
|
|
AA5D SubCAA5D
|
|
AAE8 SubCAAE8
|
|
AB0F SubCAB0F
|
|
AB10 SubCAB10
|
|
AB4F SubCAB4F
|
|
ABCD SubCABCD
|
|
ABE5 SubCABE5
|
|
AC79 SubCAC79
|
|
ACE7 SubCACE7
|
|
ACF0 SubCACF0
|
|
ACF9 SubCACF9
|
|
AD0D SubCAD0D
|
|
AD21 SubCAD21
|
|
ADE4 SubCADE4
|
|
AE08 SubCAE08
|
|
AE1E SubCAE1E
|
|
AE49 SubCAE49
|
|
AE86 SubCAE86
|
|
AEB8 SubCAEB8
|
|
AEBC SubCAEBC
|
|
AEE0 SubCAEE0
|
|
AF0D SubCAF0D
|
|
AF35 SubCAF35
|
|
AFC2 SubCAFC2
|
|
AFE5 SubCAFE5
|
|
B008 SubCB008
|
|
B009 SubCB009
|
|
B01C SubCB01C
|
|
B0A8 SubCB0A8
|
|
B0C5 SubCB0C5
|
|
B0F8 SubCB0F8
|
|
B153 SubCB153
|
|
B159 SubCB159
|
|
B15B SubCB15B
|
|
B15F SubCB15F
|
|
B17E SubCB17E
|
|
B21A SubCB21A
|
|
B221 SubCB221
|
|
B233 SubCB233
|
|
B24E SubCB24E
|
|
B25A SubCB25A
|
|
B27C SubCB27C
|
|
B2A3 SubCB2A3
|
|
B2B4 SubCB2B4
|
|
B2CC SubCB2CC
|
|
B31D SubCB31D
|
|
B33F SubCB33F
|
|
B39A SubCB39A
|
|
B3BE SubCB3BE
|
|
B41B SubCB41B
|
|
B45A SubCB45A
|
|
B475 SubCB475
|
|
B481 SubCB481
|
|
B49A SubCB49A
|
|
B4BA SubCB4BA
|
|
B4E4 SubCB4E4
|
|
B54B SubCB54B
|
|
B574 SubCB574
|
|
B587 SubCB587
|
|
B5CE SubCB5CE
|
|
B5E5 SubCB5E5
|
|
B664 SubCB664
|
|
B73B SubCB73B
|
|
B7C7 SubCB7C7
|
|
B7D3 SubCB7D3
|
|
B849 SubCB849
|
|
B873 SubCB873
|
|
B89B SubCB89B
|
|
B8F0 SubCB8F0
|
|
B901 SubCB901
|
|
B915 SubCB915
|
|
B932 SubCB932
|
|
B9A7 SubCB9A7
|
|
BA0D SubCBA0D
|
|
BA57 SubCBA57
|
|
BAA1 SubCBAA1
|
|
BB14 SubCBB14
|
|
BB55 SubCBB55
|
|
BB59 SubCBB59
|
|
BBB4 SubCBBB4
|
|
BBEC SubCBBEC
|
|
BC0D SubCBC0D
|
|
BC55 SubCBC55
|
|
BC8C SubCBC8C
|
|
BCA4 SubCBCA4
|
|
BCC2 SubCBCC2
|
|
BCC3 SubCBCC3
|
|
BCF6 SubCBCF6
|
|
BDC6 SubCBDC6
|
|
BE27 SubCBE27
|
|
BEB6 SubCBEB6
|
|
BEFA SubCBEFA
|
|
BF1A SubCBF1A
|
|
BF90 SubCBF90
|
|
BFF8 SubCBFF8
|
|
C027 SubCC027
|
|
C0F5 SubCC0F5
|
|
C606 SubCC606
|
|
C693 SubCC693
|
|
C6D2 SubCC6D2
|
|
C6E1 SubCC6E1
|
|
C6F3 SubCC6F3
|
|
C714 SubCC714
|
|
C987 SubCC987
|
|
C98C SubCC98C
|
|
C9CB SubCC9CB
|
|
CA0A SubCCA0A
|
|
CBA0 SubCCBA0
|
|
CC0A SubCCC0A
|
|
CC66 SubCCC66
|
|
CDF2 SubCCDF2
|
|
CE0E SubCCE0E
|
|
CE0F SubCCE0F
|
|
CE2E SubCCE2E
|
|
CE81 SubCCE81
|
|
CEB1 SubCCEB1
|
|
CF1F SubCCF1F
|
|
CF2A SubCCF2A
|
|
CF4E SubCCF4E
|
|
CF6A SubCCF6A
|
|
CF9F SubCCF9F
|
|
CFA9 SubCCFA9
|
|
CFB3 SubCCFB3
|
|
CFC8 SubCCFC8
|
|
CFDD SubCCFDD
|
|
D06E SubCD06E
|
|
D09E SubCD09E
|
|
D0C3 SubCD0C3
|
|
D0D8 SubCD0D8
|
|
D0F5 SubCD0F5
|
|
D154 SubCD154
|
|
D1AE SubCD1AE
|
|
D224 SubCD224
|
|
D31D SubCD31D
|
|
D3BD SubCD3BD
|
|
D3C2 SubCD3C2
|
|
D3D0 SubCD3D0
|
|
D3F0 SubCD3F0
|
|
D406 SubCD406
|
|
D635 SubCD635
|
|
D69E SubCD69E
|
|
D702 SubCD702
|
|
D773 SubCD773
|
|
D7FE SubCD7FE
|
|
D871 SubCD871
|
|
ED00 SubCED00
|
|
EEB4 SubCEEB4
|
|
F900 SubCF900
|
|
F9D3 SubCF9D3
|
|
F9ED SubCF9ED
|
|
F9FF SubCF9FF
|
|
FA10 SubCFA10
|
|
FA19 SubCFA19
|
|
FA2E SubCFA2E
|
|
FA4E SubCFA4E
|
|
FA71 SubCFA71
|
|
FB40 SubCFB40
|
|
FBD8 SubCFBD8
|
|
FBE0 SubCFBE0
|
|
FC41 SubCFC41
|
|
FCAE SubCFCAE
|
|
FCE4 SubCFCE4
|
|
FCFB SubCFCFB
|
|
FD34 SubCFD34
|
|
FD37 SubCFD37
|
|
FD9B SubCFD9B
|
|
FDFF SubCFDFF
|
|
FE7B SubCFE7B
|
|
FF0A SubCFF0A
|
|
FF15 SubCFF15
|
|
FF24 SubCFF24
|
|
FF70 SubCFF70
|
|
FF77 SubCFF77
|
|
FF7E SubCFF7E
|
|
FF84 SubCFF84
|
|
FFD0 SubCFFD0
|
|
FFD6 SubCFFD6
|
|
FFDA SubCFFDA
|
|
|
|
# ---- derived internal branch-target names ----
|
|
8000 Reset
|
|
800B SubC800B_OnNonnegative
|
|
8010 SubC8010_OnNonnegative
|
|
8050 SubC8050_Loop
|
|
805A NmiHandler
|
|
8062 SubC8062_Loop
|
|
80A4 SubC80A4_Loop
|
|
80D1 SubC80D1_Loop
|
|
80EC SubC80EC_OnNonzero
|
|
80F5 SubC80F5_Loop
|
|
80F9 SubC80F9_Loop
|
|
8108 SubC8108_Loop
|
|
810F SubC810F
|
|
8111 SubC8111
|
|
8113 SubC8113_OnNonzero
|
|
811C SubC811C_OnNonzero
|
|
812B SubC812B_OnNonzero
|
|
8135 SubC8135_OnNonzero
|
|
8142 SubC8142_Loop
|
|
814B SubC814B_Loop
|
|
814F SubC814F_OnNonzero
|
|
8159 SubC8159
|
|
8167 SubC8167_OnNonzero
|
|
8171 SubC8171
|
|
817D SubC817D_Loop
|
|
8188 SubC8188
|
|
8194 SubC8194
|
|
81AA SubC81AA_OnNonzero
|
|
81C4 SubC81C4_Loop
|
|
81C5 SubC81C5
|
|
81D2 SubC81D2_Loop
|
|
81E6 SubC81E6_Loop
|
|
81F6 SubC81F6_Loop
|
|
81FF SubC81FF_Loop
|
|
8208 SubC8208_Loop
|
|
820E SubC820E_Loop
|
|
8212 SubC8212_Loop
|
|
821B SubC821B
|
|
8229 SubC8229_OnNonzero
|
|
823F SubC823F_OnNonzero
|
|
824A SubC824A
|
|
8254 SubC8254
|
|
8260 SubC8260_Loop
|
|
8265 SubC8265_OnNonzero
|
|
826D SubC826D_Loop
|
|
8271 SubC8271_OnNonzero
|
|
827A SubC827A_Loop
|
|
8281 SubC8281_Loop
|
|
8282 SubC8282
|
|
828C SubC828C_Loop
|
|
8297 SubC8297_Loop
|
|
82A3 SubC82A3_OnNonzero
|
|
82C2 SubC82C2_OnNonzero
|
|
82E6 SubC82E6
|
|
82F9 SubC82F9
|
|
8304 SubC8304_OnNonzero
|
|
8306 SubC8306_OnNonzero
|
|
830D SubC830D_Loop
|
|
831B SubC831B_OnNonzero
|
|
833E SubC833E_Loop
|
|
8342 SubC8342_Loop
|
|
8352 SubC8352_Loop
|
|
8358 SubC8358_Loop
|
|
8359 SubC8359
|
|
836E SubC836E
|
|
8376 SubC8376
|
|
837D SubC837D
|
|
83E1 SubC83E1_OnNonzero
|
|
8517 SubC8517
|
|
851F SubC851F_OnNonzero
|
|
853C SubC853C
|
|
8548 SubC8548_Loop
|
|
8601 SubC8601
|
|
8603 SubC8603_OnNonnegative
|
|
860B SubC860B_Loop
|
|
8624 SubC8624_Loop
|
|
86BD SubC86BD
|
|
86CA SubC86CA
|
|
86E5 SubC86E5
|
|
86EC SubC86EC_OnNonnegative
|
|
870F SubC870F_Loop
|
|
872A SubC872A_Loop
|
|
872F SubC872F_Loop
|
|
8730 SubC8730
|
|
873A SubC873A
|
|
8748 SubC8748_Loop
|
|
875A SubC875A_Loop
|
|
87A4 SubC87A4
|
|
87C7 SubC87C7
|
|
87D2 SubC87D2_Loop
|
|
87E2 SubC87E2_Loop
|
|
87E8 SubC87E8
|
|
87F3 SubC87F3_Loop
|
|
8803 SubC8803_Loop
|
|
8843 SubC8843
|
|
88EE SubC88EE
|
|
88F5 SubC88F5_OnNonzero
|
|
8964 SubC8964_OnNonzero
|
|
8995 SubC8995
|
|
89A0 SubC89A0_Loop
|
|
89B0 SubC89B0_Loop
|
|
89CB SubC89CB_OnNonzero
|
|
89DC SubC89DC_Loop
|
|
89E8 SubC89E8_Loop
|
|
89F1 SubC89F1_Loop
|
|
89FC SubC89FC_Loop
|
|
8A05 SubC8A05_Loop
|
|
8A0E SubC8A0E_Loop
|
|
8A14 SubC8A14
|
|
8A1B SubC8A1B_Loop
|
|
8A2B SubC8A2B
|
|
8A4E SubC8A4E_Loop
|
|
8A62 SubC8A62_Loop
|
|
8A68 SubC8A68
|
|
8A85 SubC8A85_Loop
|
|
8A89 SubC8A89
|
|
8A91 SubC8A91_Loop
|
|
8A97 SubC8A97_Loop
|
|
8A98 SubC8A98
|
|
8AA7 SubC8AA7
|
|
8AB6 SubC8AB6
|
|
8AC5 SubC8AC5
|
|
8ACC SubC8ACC
|
|
8AD8 SubC8AD8
|
|
8B4C SubC8B4C
|
|
8B4E SubC8B4E_OnNonzero
|
|
8CF2 SubC8CF2
|
|
8D8F SubC8D8F
|
|
8DE1 SubC8DE1
|
|
8DE9 SubC8DE9_OnNonzero
|
|
8DF6 SubC8DF6_Loop
|
|
8DFE SubC8DFE_Loop
|
|
8E20 SubC8E20
|
|
8E32 SubC8E32_Loop
|
|
8E3D SubC8E3D_OnNonzero
|
|
8E43 SubC8E43_Loop
|
|
8E47 SubC8E47_Loop
|
|
8E4A SubC8E4A_Loop
|
|
8E51 SubC8E51_Loop
|
|
8E58 SubC8E58_Loop
|
|
8E60 SubC8E60_Loop
|
|
8E64 SubC8E64_Loop
|
|
8E6A SubC8E6A_Loop
|
|
8E6C SubC8E6C_Loop
|
|
8E72 SubC8E72_OnNonzero
|
|
8E8C SubC8E8C_Loop
|
|
8EB0 SubC8EB0
|
|
8EC4 SubC8EC4_Loop
|
|
8ECE SubC8ECE_Loop
|
|
8EE5 SubC8EE5_Loop
|
|
8EF1 SubC8EF1_Loop
|
|
8F52 SubC8F52
|
|
8F67 SubC8F67_OnNonzero
|
|
8F96 SubC8F96_Loop
|
|
90CB SubC90CB
|
|
90CD SubC90CD_OnNonzero
|
|
90D7 SubC90D7_Loop
|
|
90DD SubC90DD_OnNonzero
|
|
90E7 SubC90E7_Loop
|
|
90ED SubC90ED_OnNonzero
|
|
90F4 SubC90F4_Loop
|
|
9109 SubC9109
|
|
92CA SubC92CA
|
|
92D6 SubC92D6_Loop
|
|
92E5 SubC92E5_Loop
|
|
92F5 SubC92F5
|
|
9314 SubC9314
|
|
9316 SubC9316_OnNonzero
|
|
9328 SubC9328_Loop
|
|
9329 SubC9329_Loop
|
|
932E SubC932E_Loop
|
|
9430 SubC9430
|
|
944A SubC944A_Loop
|
|
9458 SubC9458_Loop
|
|
9466 SubC9466_Loop
|
|
946B SubC946B_Loop
|
|
946E SubC946E_Loop
|
|
A3CE SubCA3CE
|
|
A3E4 SubCA3E4_Loop
|
|
A3E9 SubCA3E9_Loop
|
|
A3F6 SubCA3F6_Loop
|
|
A3FC SubCA3FC_Loop
|
|
A400 SubCA400_Loop
|
|
A40E SubCA40E_Loop
|
|
A42B SubCA42B_Loop
|
|
A42E SubCA42E_Loop
|
|
A440 SubCA440_Loop
|
|
A44E SubCA44E_Loop
|
|
A456 SubCA456_Loop
|
|
A470 SubCA470_Loop
|
|
A485 SubCA485_Loop
|
|
A487 SubCA487_Loop
|
|
A493 SubCA493_Loop
|
|
A4A1 SubCA4A1_Loop
|
|
A756 SubCA756
|
|
A778 SubCA778_Loop
|
|
A784 SubCA784_Loop
|
|
A788 SubCA788_Loop
|
|
A792 SubCA792
|
|
A7AE SubCA7AE_Loop
|
|
A7B2 SubCA7B2
|
|
A7C1 SubCA7C1_OnNonzero
|
|
A7D6 SubCA7D6_Loop
|
|
A7E5 SubCA7E5_Loop
|
|
A7F5 SubCA7F5_Loop
|
|
A809 SubCA809_OnNonzero
|
|
A817 SubCA817_Loop
|
|
A82F SubCA82F_Loop
|
|
A836 SubCA836
|
|
A840 SubCA840_OnNonzero
|
|
A84B SubCA84B_Loop
|
|
A859 SubCA859_Loop
|
|
A862 SubCA862_OnNonnegative
|
|
A866 SubCA866_OnCarryClear
|
|
A870 SubCA870_Loop
|
|
A87A SubCA87A_Loop
|
|
A87B SubCA87B
|
|
A892 SubCA892
|
|
A89A SubCA89A_Loop
|
|
A8A0 SubCA8A0_Loop
|
|
A8B1 SubCA8B1_Loop
|
|
A8B7 SubCA8B7_Loop
|
|
A8BA SubCA8BA
|
|
A8CC SubCA8CC
|
|
A8D4 SubCA8D4_OnNonzero
|
|
A8E6 SubCA8E6_Loop
|
|
A8F9 SubCA8F9_Loop
|
|
A904 SubCA904_Loop
|
|
A905 SubCA905
|
|
A919 SubCA919_Loop
|
|
A920 SubCA920_Loop
|
|
A921 SubCA921
|
|
A92E SubCA92E_Loop
|
|
A933 SubCA933
|
|
A934 SubCA934
|
|
A941 SubCA941_Loop
|
|
A946 SubCA946
|
|
A947 SubCA947
|
|
A954 SubCA954_Loop
|
|
A959 SubCA959
|
|
A96D SubCA96D
|
|
A981 SubCA981
|
|
A999 SubCA999
|
|
A9B2 SubCA9B2_Loop
|
|
A9B4 SubCA9B4
|
|
A9C4 SubCA9C4_OnCarryClear
|
|
A9CE SubCA9CE_Loop
|
|
A9DA SubCA9DA_Loop
|
|
A9E0 SubCA9E0_Loop
|
|
A9E1 SubCA9E1
|
|
A9E7 SubCA9E7
|
|
AA0E SubCAA0E_Loop
|
|
AA14 SubCAA14_Loop
|
|
AA17 SubCAA17
|
|
AA31 SubCAA31_Loop
|
|
AA33 SubCAA33_Loop
|
|
AA3A SubCAA3A_Loop
|
|
AA43 SubCAA43_Loop
|
|
AA46 SubCAA46_Loop
|
|
AA47 SubCAA47
|
|
AA54 SubCAA54_Loop
|
|
AA5D SubCAA5D
|
|
AA70 SubCAA70_Loop
|
|
AA81 SubCAA81_Loop
|
|
AA93 SubCAA93_Loop
|
|
AA9E SubCAA9E_Loop
|
|
AAA5 SubCAAA5_Loop
|
|
AAAC SubCAAAC_Loop
|
|
AAB8 SubCAAB8_OnNonzero
|
|
AAC0 SubCAAC0_OnNonzero
|
|
AAC6 SubCAAC6_Loop
|
|
AACC SubCAACC_OnNonzero
|
|
AAD4 SubCAAD4_OnNonzero
|
|
AADA SubCAADA_Loop
|
|
AADE SubCAADE_Loop
|
|
AAE5 SubCAAE5_Loop
|
|
AAE8 SubCAAE8
|
|
AAFA SubCAAFA_Loop
|
|
AB00 SubCAB00_Loop
|
|
AB03 SubCAB03_Loop
|
|
AB0C SubCAB0C_Loop
|
|
AB0F SubCAB0F
|
|
AB10 SubCAB10
|
|
AB1F SubCAB1F_Loop
|
|
AB27 SubCAB27_Loop
|
|
AB31 SubCAB31_OnNonzero
|
|
AB3A SubCAB3A_Loop
|
|
AB44 SubCAB44_OnNonzero
|
|
AB4B SubCAB4B_Loop
|
|
AB4F SubCAB4F
|
|
AB5D SubCAB5D_Loop
|
|
AB60 SubCAB60_Loop
|
|
AB75 SubCAB75_Loop
|
|
AB78 SubCAB78_Loop
|
|
AB84 SubCAB84_Loop
|
|
AB8A SubCAB8A_Loop
|
|
AB97 SubCAB97_Loop
|
|
AB9E SubCAB9E_OnNonzero
|
|
ABA7 SubCABA7_Loop
|
|
ABAB SubCABAB_Loop
|
|
ABB2 SubCABB2_OnNonzero
|
|
ABB9 SubCABB9_Loop
|
|
ABCC SubCABCC_Loop
|
|
ABCD SubCABCD
|
|
ABE1 SubCABE1_Loop
|
|
ABE5 SubCABE5
|
|
ABED SubCABED_Loop
|
|
ABF9 SubCABF9_Loop
|
|
AC09 SubCAC09_Loop
|
|
AC0B SubCAC0B_Loop
|
|
AC0E SubCAC0E_Loop
|
|
AC15 SubCAC15_Loop
|
|
AC28 SubCAC28_Loop
|
|
AC2C SubCAC2C_Loop
|
|
AC45 SubCAC45_Loop
|
|
AC5C SubCAC5C_Loop
|
|
AC61 SubCAC61_Loop
|
|
AC78 SubCAC78_Loop
|
|
AC79 SubCAC79
|
|
AC86 SubCAC86_Loop
|
|
AC9C SubCAC9C_Loop
|
|
ACB2 SubCACB2_Loop
|
|
ACBC SubCACBC_Loop
|
|
ACCC SubCACCC_Loop
|
|
ACD6 SubCACD6_Loop
|
|
ACD7 SubCACD7_Loop
|
|
ACE7 SubCACE7
|
|
ACEF SubCACEF_Loop
|
|
ACF0 SubCACF0
|
|
ACF8 SubCACF8_Loop
|
|
ACF9 SubCACF9
|
|
AD04 SubCAD04_Loop
|
|
AD0A SubCAD0A_Loop
|
|
AD0C SubCAD0C_Loop
|
|
AD0D SubCAD0D
|
|
AD18 SubCAD18_Loop
|
|
AD1E SubCAD1E_Loop
|
|
AD20 SubCAD20_Loop
|
|
AD21 SubCAD21
|
|
AD2D SubCAD2D_Loop
|
|
AD4F SubCAD4F_Loop
|
|
AD5B SubCAD5B_Loop
|
|
AD65 SubCAD65_Loop
|
|
AD7B SubCAD7B_Loop
|
|
AD7D SubCAD7D_OnNonnegative
|
|
AD90 SubCAD90_Loop
|
|
AD9B SubCAD9B_Loop
|
|
AD9F SubCAD9F_Loop
|
|
ADB3 SubCADB3_Loop
|
|
ADBE SubCADBE_Loop
|
|
ADC1 SubCADC1_Loop
|
|
ADC6 SubCADC6_Loop
|
|
ADE4 SubCADE4
|
|
ADEF SubCADEF_OnNonzero
|
|
AE05 SubCAE05_Loop
|
|
AE08 SubCAE08
|
|
AE1E SubCAE1E
|
|
AE40 SubCAE40_Loop
|
|
AE49 SubCAE49
|
|
AE52 SubCAE52_Loop
|
|
AE5F SubCAE5F_OnNonzero
|
|
AE80 SubCAE80_Loop
|
|
AE83 SubCAE83_Loop
|
|
AE86 SubCAE86
|
|
AEA9 SubCAEA9_Loop
|
|
AEAF SubCAEAF_Loop
|
|
AEB8 SubCAEB8
|
|
AEBC SubCAEBC
|
|
AEC4 SubCAEC4_Loop
|
|
AED6 SubCAED6_Loop
|
|
AEDA SubCAEDA_Loop
|
|
AEDF SubCAEDF_Loop
|
|
AEE0 SubCAEE0
|
|
AF0C SubCAF0C_Loop
|
|
AF0D SubCAF0D
|
|
AF35 SubCAF35
|
|
AF3F SubCAF3F_OnNonzero
|
|
AF4A SubCAF4A_OnNonzero
|
|
AF5E SubCAF5E_Loop
|
|
AF6E SubCAF6E_Loop
|
|
AF86 SubCAF86_Loop
|
|
AF9F SubCAF9F_Loop
|
|
AFA5 SubCAFA5_Loop
|
|
AFA8 SubCAFA8_Loop
|
|
AFAC SubCAFAC_Loop
|
|
AFAF SubCAFAF_Loop
|
|
AFBC SubCAFBC_Loop
|
|
AFC1 SubCAFC1_Loop
|
|
AFC2 SubCAFC2
|
|
AFE0 SubCAFE0_Loop
|
|
AFE5 SubCAFE5
|
|
AFF6 SubCAFF6_Loop
|
|
B005 SubCB005_Loop
|
|
B008 SubCB008
|
|
B009 SubCB009
|
|
B01B SubCB01B_Loop
|
|
B01C SubCB01C
|
|
B048 SubCB048_Loop
|
|
B05E SubCB05E_Loop
|
|
B0A8 SubCB0A8
|
|
B0B7 SubCB0B7_Loop
|
|
B0C5 SubCB0C5
|
|
B0CF SubCB0CF_Loop
|
|
B0D2 SubCB0D2_Loop
|
|
B0EE SubCB0EE_Loop
|
|
B0F8 SubCB0F8
|
|
B122 SubCB122_Loop
|
|
B12C SubCB12C_Loop
|
|
B134 SubCB134_Loop
|
|
B142 SubCB142_Loop
|
|
B153 SubCB153
|
|
B159 SubCB159
|
|
B15B SubCB15B
|
|
B15F SubCB15F
|
|
B17E SubCB17E
|
|
B1A5 SubCB1A5_Loop
|
|
B1B7 SubCB1B7_Loop
|
|
B1F7 SubCB1F7_Loop
|
|
B211 SubCB211_Loop
|
|
B219 SubCB219_Loop
|
|
B21A SubCB21A
|
|
B221 SubCB221
|
|
B233 SubCB233
|
|
B24D SubCB24D_Loop
|
|
B24E SubCB24E
|
|
B25A SubCB25A
|
|
B277 SubCB277_Loop
|
|
B27C SubCB27C
|
|
B2A2 SubCB2A2_Loop
|
|
B2A3 SubCB2A3
|
|
B2B3 SubCB2B3_Loop
|
|
B2B4 SubCB2B4
|
|
B2C1 SubCB2C1_Loop
|
|
B2CC SubCB2CC
|
|
B2CE SubCB2CE_OnNonnegative
|
|
B2DE SubCB2DE_Loop
|
|
B2E0 SubCB2E0_Loop
|
|
B2F1 SubCB2F1_Loop
|
|
B2FA SubCB2FA_Loop
|
|
B303 SubCB303_Loop
|
|
B30C SubCB30C_Loop
|
|
B314 SubCB314_Loop
|
|
B317 SubCB317_Loop
|
|
B31D SubCB31D
|
|
B333 SubCB333_OnNonzero
|
|
B33A SubCB33A_Loop
|
|
B33F SubCB33F
|
|
B34B SubCB34B_OnNonzero
|
|
B356 SubCB356_Loop
|
|
B35C SubCB35C_OnNonzero
|
|
B380 SubCB380_Loop
|
|
B389 SubCB389_Loop
|
|
B39A SubCB39A
|
|
B3BD SubCB3BD_Loop
|
|
B3BE SubCB3BE
|
|
B3DB SubCB3DB_OnNonzero
|
|
B3E6 SubCB3E6_Loop
|
|
B3F2 SubCB3F2_Loop
|
|
B406 SubCB406_OnNonzero
|
|
B412 SubCB412_Loop
|
|
B417 SubCB417_Loop
|
|
B41A SubCB41A_Loop
|
|
B41B SubCB41B
|
|
B42D SubCB42D_OnNonzero
|
|
B437 SubCB437_OnZero
|
|
B43F SubCB43F_Loop
|
|
B450 SubCB450_Loop
|
|
B459 SubCB459_Loop
|
|
B45A SubCB45A
|
|
B468 SubCB468_OnNonzero
|
|
B472 SubCB472_Loop
|
|
B475 SubCB475
|
|
B481 SubCB481
|
|
B499 SubCB499_Loop
|
|
B49A SubCB49A
|
|
B4B9 SubCB4B9_Loop
|
|
B4BA SubCB4BA
|
|
B4CF SubCB4CF_Loop
|
|
B4E4 SubCB4E4
|
|
B4F5 SubCB4F5_OnNonzero
|
|
B506 SubCB506_Loop
|
|
B515 SubCB515_Loop
|
|
B51E SubCB51E_Loop
|
|
B540 SubCB540_OnNonzero
|
|
B54A SubCB54A_Loop
|
|
B54B SubCB54B
|
|
B55B SubCB55B_Loop
|
|
B566 SubCB566_Loop
|
|
B56F SubCB56F_Loop
|
|
B574 SubCB574
|
|
B576 SubCB576_OnNonzero
|
|
B587 SubCB587
|
|
B592 SubCB592_Loop
|
|
B59B SubCB59B_Loop
|
|
B5A4 SubCB5A4_Loop
|
|
B5AC SubCB5AC_Loop
|
|
B5B5 SubCB5B5_Loop
|
|
B5BE SubCB5BE_Loop
|
|
B5C7 SubCB5C7_Loop
|
|
B5CD SubCB5CD_Loop
|
|
B5CE SubCB5CE
|
|
B5E4 SubCB5E4_Loop
|
|
B5E5 SubCB5E5
|
|
B664 SubCB664
|
|
B67E SubCB67E_Loop
|
|
B688 SubCB688_Loop
|
|
B69A SubCB69A_Loop
|
|
B69D SubCB69D_Loop
|
|
B6A0 SubCB6A0_Loop
|
|
B6A3 SubCB6A3_Loop
|
|
B6A6 SubCB6A6_Loop
|
|
B6A9 SubCB6A9_Loop
|
|
B6AC SubCB6AC_Loop
|
|
B73B SubCB73B
|
|
B757 SubCB757_Loop
|
|
B764 SubCB764_Loop
|
|
B779 SubCB779_Loop
|
|
B780 SubCB780_Loop
|
|
B79F SubCB79F_Loop
|
|
B7C3 SubCB7C3_Loop
|
|
B7C7 SubCB7C7
|
|
B7D2 SubCB7D2_Loop
|
|
B7D3 SubCB7D3
|
|
B7DE SubCB7DE_Loop
|
|
B7F6 SubCB7F6_Loop
|
|
B802 SubCB802_Loop
|
|
B804 SubCB804_Loop
|
|
B81A SubCB81A_Loop
|
|
B828 SubCB828_Loop
|
|
B83F SubCB83F_Loop
|
|
B844 SubCB844_Loop
|
|
B848 SubCB848_Loop
|
|
B849 SubCB849
|
|
B857 SubCB857_Loop
|
|
B860 SubCB860_Loop
|
|
B872 SubCB872_Loop
|
|
B873 SubCB873
|
|
B889 SubCB889_Loop
|
|
B89B SubCB89B
|
|
B8CA SubCB8CA_Loop
|
|
B8EB SubCB8EB_Loop
|
|
B8EF SubCB8EF_Loop
|
|
B8F0 SubCB8F0
|
|
B900 SubCB900_Loop
|
|
B901 SubCB901
|
|
B912 SubCB912_Loop
|
|
B915 SubCB915
|
|
B920 SubCB920_Loop
|
|
B92F SubCB92F_Loop
|
|
B931 SubCB931_Loop
|
|
B932 SubCB932
|
|
B9A7 SubCB9A7
|
|
B9B4 SubCB9B4_Loop
|
|
B9D1 SubCB9D1_Loop
|
|
B9D9 SubCB9D9_Loop
|
|
B9E6 SubCB9E6_Loop
|
|
B9F6 SubCB9F6_Loop
|
|
BA00 SubCBA00_Loop
|
|
BA0D SubCBA0D
|
|
BA0E SubCBA0E_Loop
|
|
BA57 SubCBA57
|
|
BA79 SubCBA79_Loop
|
|
BA88 SubCBA88_Loop
|
|
BA8C SubCBA8C_Loop
|
|
BA9D SubCBA9D_Loop
|
|
BAA1 SubCBAA1
|
|
BAB8 SubCBAB8_OnNonzero
|
|
BACB SubCBACB_Loop
|
|
BAD4 SubCBAD4_Loop
|
|
BADB SubCBADB_Loop
|
|
BADD SubCBADD_OnNonzero
|
|
BAF0 SubCBAF0_Loop
|
|
BAF7 SubCBAF7_Loop
|
|
BAFE SubCBAFE_Loop
|
|
BB13 SubCBB13_Loop
|
|
BB14 SubCBB14
|
|
BB28 SubCBB28_Loop
|
|
BB2F SubCBB2F_Loop
|
|
BB3C SubCBB3C_Loop
|
|
BB47 SubCBB47_Loop
|
|
BB4E SubCBB4E_Loop
|
|
BB55 SubCBB55
|
|
BB59 SubCBB59
|
|
BB6F SubCBB6F_Loop
|
|
BBB4 SubCBBB4
|
|
BBC5 SubCBBC5_Loop
|
|
BBD6 SubCBBD6_Loop
|
|
BBD9 SubCBBD9_Loop
|
|
BBE0 SubCBBE0_Loop
|
|
BBE7 SubCBBE7_Loop
|
|
BBEC SubCBBEC
|
|
BBF7 SubCBBF7_Loop
|
|
BC00 SubCBC00_Loop
|
|
BC09 SubCBC09_Loop
|
|
BC0C SubCBC0C_Loop
|
|
BC0D SubCBC0D
|
|
BC2F SubCBC2F_Loop
|
|
BC36 SubCBC36_Loop
|
|
BC3E SubCBC3E_Loop
|
|
BC55 SubCBC55
|
|
BC61 SubCBC61_Loop
|
|
BC7C SubCBC7C_Loop
|
|
BC83 SubCBC83_OnCarryClear
|
|
BC8C SubCBC8C
|
|
BC9B SubCBC9B_Loop
|
|
BC9D SubCBC9D_Loop
|
|
BCA3 SubCBCA3_Loop
|
|
BCA4 SubCBCA4
|
|
BCB9 SubCBCB9_Loop
|
|
BCC2 SubCBCC2
|
|
BCC3 SubCBCC3
|
|
BCD0 SubCBCD0_Loop
|
|
BCF5 SubCBCF5_Loop
|
|
BCF6 SubCBCF6
|
|
BCFD SubCBCFD_Loop
|
|
BD17 SubCBD17_Loop
|
|
BD24 SubCBD24_Loop
|
|
BD2F SubCBD2F_Loop
|
|
BD3B SubCBD3B_Loop
|
|
BD46 SubCBD46_Loop
|
|
BD56 SubCBD56_Loop
|
|
BD5C SubCBD5C_Loop
|
|
BD6C SubCBD6C_Loop
|
|
BD8A SubCBD8A_Loop
|
|
BD8E SubCBD8E_Loop
|
|
BDA8 SubCBDA8_Loop
|
|
BDAC SubCBDAC_Loop
|
|
BDB4 SubCBDB4_Loop
|
|
BDB6 SubCBDB6_Loop
|
|
BDBD SubCBDBD_Loop
|
|
BDC4 SubCBDC4_Loop
|
|
BDC6 SubCBDC6
|
|
BE27 SubCBE27
|
|
BE30 SubCBE30_Loop
|
|
BE3D SubCBE3D_Loop
|
|
BE3F SubCBE3F_Loop
|
|
BE4E SubCBE4E_OnNonzero
|
|
BE5D SubCBE5D_Loop
|
|
BE82 SubCBE82_Loop
|
|
BE87 SubCBE87_Loop
|
|
BE95 SubCBE95_Loop
|
|
BE9A SubCBE9A_Loop
|
|
BEAD SubCBEAD_Loop
|
|
BEB3 SubCBEB3_Loop
|
|
BEB5 SubCBEB5_Loop
|
|
BEB6 SubCBEB6
|
|
BEE3 SubCBEE3_Loop
|
|
BEF9 SubCBEF9_Loop
|
|
BEFA SubCBEFA
|
|
BF19 SubCBF19_Loop
|
|
BF1A SubCBF1A
|
|
BF1E SubCBF1E_OnNonzero
|
|
BF2C SubCBF2C_Loop
|
|
BF2E SubCBF2E_OnNonzero
|
|
BF32 SubCBF32_OnNonzero
|
|
BF3A SubCBF3A_Loop
|
|
BF42 SubCBF42_OnNonzero
|
|
BF6C SubCBF6C_Loop
|
|
BF76 SubCBF76_Loop
|
|
BF7B SubCBF7B_Loop
|
|
BF87 SubCBF87_Loop
|
|
BF90 SubCBF90
|
|
BF92 SubCBF92_OnNonzero
|
|
BF96 SubCBF96_OnNonzero
|
|
BF9E SubCBF9E_Loop
|
|
BFA8 SubCBFA8_OnNonzero
|
|
BFD2 SubCBFD2_Loop
|
|
BFDC SubCBFDC_Loop
|
|
BFE3 SubCBFE3_Loop
|
|
BFEF SubCBFEF_Loop
|
|
BFF8 SubCBFF8
|
|
C01E SubCC01E_Loop
|
|
C022 SubCC022_Loop
|
|
C026 SubCC026_Loop
|
|
C027 SubCC027
|
|
C05C SubCC05C_Loop
|
|
C067 SubCC067_Loop
|
|
C06D SubCC06D_Loop
|
|
C094 SubCC094_Loop
|
|
C0F5 SubCC0F5
|
|
C11F SubCC11F_Loop
|
|
C139 SubCC139_Loop
|
|
C14B SubCC14B_OnNonzero
|
|
C169 SubCC169_Loop
|
|
C171 SubCC171_Loop
|
|
C17E SubCC17E_Loop
|
|
C606 SubCC606
|
|
C615 SubCC615_Loop
|
|
C61E SubCC61E_Loop
|
|
C635 SubCC635_Loop
|
|
C646 SubCC646_Loop
|
|
C64C SubCC64C_Loop
|
|
C64F SubCC64F_Loop
|
|
C661 SubCC661_Loop
|
|
C665 SubCC665_Loop
|
|
C667 SubCC667_Loop
|
|
C66C SubCC66C_Loop
|
|
C677 SubCC677_Loop
|
|
C684 SubCC684_Loop
|
|
C692 SubCC692_Loop
|
|
C693 SubCC693
|
|
C6AD SubCC6AD_Loop
|
|
C6B1 SubCC6B1_Loop
|
|
C6B4 SubCC6B4_Loop
|
|
C6C8 SubCC6C8_Loop
|
|
C6CF SubCC6CF_Loop
|
|
C6D2 SubCC6D2
|
|
C6E0 SubCC6E0_Loop
|
|
C6E1 SubCC6E1
|
|
C6F3 SubCC6F3
|
|
C704 SubCC704_Loop
|
|
C711 SubCC711_Loop
|
|
C714 SubCC714
|
|
C71D SubCC71D_Loop
|
|
C729 SubCC729_Loop
|
|
C734 SubCC734_Loop
|
|
C749 SubCC749_Loop
|
|
C74F SubCC74F_Loop
|
|
C762 SubCC762_Loop
|
|
C766 SubCC766_Loop
|
|
C987 SubCC987
|
|
C98C SubCC98C
|
|
C99D SubCC99D_Loop
|
|
C9B7 SubCC9B7_Loop
|
|
C9C2 SubCC9C2_Loop
|
|
C9CB SubCC9CB
|
|
C9F2 SubCC9F2_Loop
|
|
C9FC SubCC9FC_Loop
|
|
CA06 SubCCA06_Loop
|
|
CA09 SubCCA09_Loop
|
|
CA0A SubCCA0A
|
|
CA38 SubCCA38_Loop
|
|
CA6D SubCCA6D_Loop
|
|
CA87 SubCCA87_Loop
|
|
CBA0 SubCCBA0
|
|
CBBF SubCCBBF_Loop
|
|
CBCA SubCCBCA_Loop
|
|
CC0A SubCCC0A
|
|
CC12 SubCCC12_Loop
|
|
CC28 SubCCC28_Loop
|
|
CC34 SubCCC34_Loop
|
|
CC36 SubCCC36_Loop
|
|
CC66 SubCCC66
|
|
CCB4 SubCCCB4_Loop
|
|
CCD8 SubCCCD8_Loop
|
|
CCE7 SubCCCE7_Loop
|
|
CCEC SubCCCEC_Loop
|
|
CD05 SubCCD05_Loop
|
|
CD0D SubCCD0D_Loop
|
|
CD0F SubCCD0F_Loop
|
|
CD1C SubCCD1C_Loop
|
|
CDF2 SubCCDF2
|
|
CE08 SubCCE08_Loop
|
|
CE0E SubCCE0E
|
|
CE0F SubCCE0F
|
|
CE1F SubCCE1F_Loop
|
|
CE2D SubCCE2D_Loop
|
|
CE2E SubCCE2E
|
|
CE50 SubCCE50_Loop
|
|
CE81 SubCCE81
|
|
CE96 SubCCE96_OnZero
|
|
CEB1 SubCCEB1
|
|
CEC1 SubCCEC1_Loop
|
|
CED8 SubCCED8_Loop
|
|
CEE0 SubCCEE0_OnNonzero
|
|
CEE8 SubCCEE8_Loop
|
|
CEEB SubCCEEB_Loop
|
|
CF06 SubCCF06_Loop
|
|
CF17 SubCCF17_Loop
|
|
CF1A SubCCF1A_Loop
|
|
CF1E SubCCF1E_Loop
|
|
CF1F SubCCF1F
|
|
CF23 SubCCF23_OnNonzero
|
|
CF2A SubCCF2A
|
|
CF4D SubCCF4D_Loop
|
|
CF4E SubCCF4E
|
|
CF6A SubCCF6A
|
|
CF8F SubCCF8F_Loop
|
|
CF9E SubCCF9E_Loop
|
|
CF9F SubCCF9F
|
|
CFA1 SubCCFA1_OnNonnegative
|
|
CFA9 SubCCFA9
|
|
CFAB SubCCFAB_OnNonnegative
|
|
CFB3 SubCCFB3
|
|
CFC8 SubCCFC8
|
|
CFDD SubCCFDD
|
|
CFE4 SubCCFE4_Loop
|
|
CFF1 SubCCFF1_OnZero
|
|
CFF4 SubCCFF4_OnNonzero
|
|
CFFD SubCCFFD_Loop
|
|
D001 SubCD001_OnNonzero
|
|
D00C SubCD00C_Loop
|
|
D013 SubCD013_Loop
|
|
D015 SubCD015_OnNonnegative
|
|
D026 SubCD026_Loop
|
|
D06E SubCD06E
|
|
D070 SubCD070_OnNonzero
|
|
D079 SubCD079_Loop
|
|
D089 SubCD089_OnCarrySet
|
|
D091 SubCD091_Loop
|
|
D093 SubCD093_Loop
|
|
D09E SubCD09E
|
|
D0A5 SubCD0A5_OnNonzero
|
|
D0B6 SubCD0B6_OnNonzero
|
|
D0C3 SubCD0C3
|
|
D0D4 SubCD0D4_Loop
|
|
D0D7 SubCD0D7_Loop
|
|
D0D8 SubCD0D8
|
|
D0ED SubCD0ED_OnNonzero
|
|
D0F4 SubCD0F4_Loop
|
|
D0F5 SubCD0F5
|
|
D100 SubCD100_OnNonzero
|
|
D131 SubCD131_Loop
|
|
D142 SubCD142_Loop
|
|
D154 SubCD154
|
|
D184 SubCD184_Loop
|
|
D18B SubCD18B_Loop
|
|
D1A0 SubCD1A0_Loop
|
|
D1A5 SubCD1A5_Loop
|
|
D1AE SubCD1AE
|
|
D1C0 SubCD1C0_Loop
|
|
D1CC SubCD1CC_Loop
|
|
D1D6 SubCD1D6_Loop
|
|
D1E6 SubCD1E6_Loop
|
|
D1FA SubCD1FA_Loop
|
|
D200 SubCD200_Loop
|
|
D215 SubCD215_Loop
|
|
D224 SubCD224
|
|
D31D SubCD31D
|
|
D32C SubCD32C_Loop
|
|
D33F SubCD33F_Loop
|
|
D359 SubCD359_Loop
|
|
D372 SubCD372_Loop
|
|
D3B2 SubCD3B2_Loop
|
|
D3BA SubCD3BA_Loop
|
|
D3BD SubCD3BD
|
|
D3C2 SubCD3C2
|
|
D3D0 SubCD3D0
|
|
D3DB SubCD3DB_Loop
|
|
D3EA SubCD3EA_Loop
|
|
D3F0 SubCD3F0
|
|
D403 SubCD403_Loop
|
|
D406 SubCD406
|
|
D635 SubCD635
|
|
D643 SubCD643_Loop
|
|
D652 SubCD652_Loop
|
|
D66C SubCD66C_Loop
|
|
D66F SubCD66F_Loop
|
|
D678 SubCD678_Loop
|
|
D682 SubCD682_Loop
|
|
D698 SubCD698_Loop
|
|
D69E SubCD69E
|
|
D6AC SubCD6AC_Loop
|
|
D6CF SubCD6CF_OnNonzero
|
|
D6E3 SubCD6E3_Loop
|
|
D6F1 SubCD6F1_Loop
|
|
D6FD SubCD6FD_Loop
|
|
D701 SubCD701_Loop
|
|
D702 SubCD702
|
|
D720 SubCD720_Loop
|
|
D72C SubCD72C_Loop
|
|
D73A SubCD73A_Loop
|
|
D764 SubCD764_OnNonnegative
|
|
D773 SubCD773
|
|
D77E SubCD77E_Loop
|
|
D79D SubCD79D_Loop
|
|
D7A9 SubCD7A9_Loop
|
|
D7B5 SubCD7B5_OnCarryClear
|
|
D7C3 SubCD7C3_Loop
|
|
D7CB SubCD7CB_Loop
|
|
D7D7 SubCD7D7_Loop
|
|
D7DC SubCD7DC_Loop
|
|
D7E9 SubCD7E9_Loop
|
|
D7F5 SubCD7F5_Loop
|
|
D7FC SubCD7FC_Loop
|
|
D7FE SubCD7FE
|
|
D810 SubCD810_OnNonzero
|
|
D827 SubCD827_Loop
|
|
D843 SubCD843_Loop
|
|
D848 SubCD848_Loop
|
|
D851 SubCD851_Loop
|
|
D86F SubCD86F_Loop
|
|
D870 SubCD870_Loop
|
|
D871 SubCD871
|
|
D88C SubCD88C_OnNonzero
|
|
D897 SubCD897_Loop
|
|
D8A6 SubCD8A6_Loop
|
|
D8D1 SubCD8D1_Loop
|
|
D8D8 SubCD8D8_Loop
|
|
ED00 SubCED00
|
|
ED0A SubCED0A_Loop
|
|
ED1F SubCED1F_Loop
|
|
ED21 SubCED21_OnNonnegative
|
|
ED56 SubCED56_Loop
|
|
ED61 SubCED61_Loop
|
|
EEB4 SubCEEB4
|
|
EEC4 SubCEEC4_OnNonzero
|
|
EECF SubCEECF_OnZero
|
|
EEDD SubCEEDD_OnNonzero
|
|
EEEC SubCEEEC_Loop
|
|
F900 SubCF900
|
|
F915 SubCF915_Loop
|
|
F93B SubCF93B_OnZero
|
|
F93F SubCF93F_Loop
|
|
F94D SubCF94D_Loop
|
|
F94F SubCF94F_Loop
|
|
F956 SubCF956_Loop
|
|
F96A SubCF96A_Loop
|
|
F971 SubCF971_Loop
|
|
F985 SubCF985_Loop
|
|
F9D3 SubCF9D3
|
|
F9ED SubCF9ED
|
|
F9FF SubCF9FF
|
|
FA10 SubCFA10
|
|
FA19 SubCFA19
|
|
FA2A SubCFA2A_Loop
|
|
FA2E SubCFA2E
|
|
FA31 SubCFA31_Loop
|
|
FA33 SubCFA33_Loop
|
|
FA36 SubCFA36_Loop
|
|
FA4A SubCFA4A_Loop
|
|
FA4C SubCFA4C_Loop
|
|
FA4E SubCFA4E
|
|
FA51 SubCFA51_OnCarrySet
|
|
FA5D SubCFA5D_Loop
|
|
FA61 SubCFA61_Loop
|
|
FA63 SubCFA63_Loop
|
|
FA70 SubCFA70_Loop
|
|
FA71 SubCFA71
|
|
FAA3 SubCFAA3_Loop
|
|
FABC SubCFABC_Loop
|
|
FABD SubCFABD_Loop
|
|
FAC0 SubCFAC0_Loop
|
|
FAC3 SubCFAC3_Loop
|
|
FAC6 SubCFAC6_Loop
|
|
FAC9 SubCFAC9_Loop
|
|
FACC SubCFACC_Loop
|
|
FACF SubCFACF_Loop
|
|
FAD2 SubCFAD2_OnCarrySet
|
|
FAD5 SubCFAD5_Loop
|
|
FADD SubCFADD_Loop
|
|
FAE2 SubCFAE2_OnNonzero
|
|
FAF3 SubCFAF3_Loop
|
|
FAFF SubCFAFF_Loop
|
|
FB02 SubCFB02_Loop
|
|
FB09 SubCFB09_Loop
|
|
FB11 SubCFB11_Loop
|
|
FB19 SubCFB19_Loop
|
|
FB40 SubCFB40
|
|
FB4B SubCFB4B_Loop
|
|
FB53 SubCFB53_Loop
|
|
FB63 SubCFB63_Loop
|
|
FB66 SubCFB66_Loop
|
|
FB6B SubCFB6B_Loop
|
|
FB7B SubCFB7B_Loop
|
|
FBD8 SubCFBD8
|
|
FBE0 SubCFBE0
|
|
FBEB SubCFBEB_OnCarrySet
|
|
FBF3 SubCFBF3_OnCarrySet
|
|
FBFC SubCFBFC_Loop
|
|
FC07 SubCFC07_OnNonzero
|
|
FC11 SubCFC11_Loop
|
|
FC12 SubCFC12_OnCarrySet
|
|
FC1A SubCFC1A_OnCarrySet
|
|
FC27 SubCFC27_Loop
|
|
FC2C SubCFC2C_Loop
|
|
FC3E SubCFC3E_OnNegative
|
|
FC41 SubCFC41
|
|
FC61 SubCFC61_Loop
|
|
FC73 SubCFC73_Loop
|
|
FC76 SubCFC76_Loop
|
|
FCA1 SubCFCA1_Loop
|
|
FCAE SubCFCAE
|
|
FCC4 SubCFCC4_Loop
|
|
FCD0 SubCFCD0_Loop
|
|
FCE1 SubCFCE1_Loop
|
|
FCE4 SubCFCE4
|
|
FCF2 SubCFCF2_Loop
|
|
FCF6 SubCFCF6_Loop
|
|
FCF7 SubCFCF7_Loop
|
|
FCF8 SubCFCF8_OnNonzero
|
|
FCFB SubCFCFB
|
|
FD0E SubCFD0E_Loop
|
|
FD18 SubCFD18_OnCarryClear
|
|
FD34 SubCFD34
|
|
FD37 SubCFD37
|
|
FD48 SubCFD48_Loop
|
|
FD50 SubCFD50_OnCarryClear
|
|
FD54 SubCFD54_Loop
|
|
FD9B SubCFD9B
|
|
FDAE SubCFDAE_Loop
|
|
FDBE SubCFDBE_Loop
|
|
FDCF SubCFDCF_Loop
|
|
FDD2 SubCFDD2_Loop
|
|
FDD5 SubCFDD5_Loop
|
|
FDE3 SubCFDE3_Loop
|
|
FDF7 SubCFDF7_Loop
|
|
FDFF SubCFDFF
|
|
FE05 SubCFE05_Loop
|
|
FE10 SubCFE10_Loop
|
|
FE22 SubCFE22_Loop
|
|
FE42 SubCFE42_Loop
|
|
FE64 SubCFE64_Loop
|
|
FE73 SubCFE73_Loop
|
|
FE7B SubCFE7B
|
|
FE81 SubCFE81_Loop
|
|
FE8C SubCFE8C_Loop
|
|
FE9C SubCFE9C_Loop
|
|
FEAE SubCFEAE_Loop
|
|
FEC1 SubCFEC1_Loop
|
|
FEEC SubCFEEC_Loop
|
|
FEFE SubCFEFE_Loop
|
|
FF00 SubCFF00_Loop
|
|
FF03 SubCFF03_Loop
|
|
FF0A SubCFF0A
|
|
FF15 SubCFF15
|
|
FF1D SubCFF1D_Loop
|
|
FF1F SubCFF1F_Loop
|
|
FF24 SubCFF24
|
|
FF2F SubCFF2F_Loop
|
|
FF32 SubCFF32_Loop
|
|
FF33 SubCFF33_Loop
|
|
FF3C SubCFF3C_Loop
|
|
FF3F SubCFF3F_Loop
|
|
FF70 SubCFF70
|
|
FF77 SubCFF77
|
|
FF7E SubCFF7E
|
|
FF84 SubCFF84
|
|
FF86 SubCFF86_OnNonzero
|
|
FF92 SubCFF92_Loop
|
|
FF9B SubCFF9B_OnNonnegative
|
|
FFA3 SubCFFA3_Loop
|
|
FFB1 SubCFFB1_OnNonzero
|
|
FFC1 SubCFFC1_Loop
|
|
FFD0 SubCFFD0
|
|
FFD6 SubCFFD6
|
|
FFDA SubCFFDA
|