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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PROMPTS.md gains two Pass 3 requirements:

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

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

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

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

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

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

All seven projects still build byte-identical.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Three lessons from the seven re-splits:

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

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

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

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

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

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

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

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

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

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

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

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

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

derive_routine_docs.py: describe what each routine actually does

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

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

Rewrite the routine headers across the promoted tier

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

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

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

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

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

CHANGELOG: record the tier-wide routine header rewrite

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

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

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

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

make still prints Byte-identical ROM verified.

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

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

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

Two real bugs are fixed on the way:

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

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

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

Complete Pass 2 across the tier: no Label_ residue left

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

Three more real defects in the tools are fixed:

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

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

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

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

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

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

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

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

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

apply_pass2_map.py: do not write the same equate twice

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

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

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

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

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

All 61 promoted projects now carry the section.

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

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

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

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

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

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

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

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

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

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

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

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

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

Repair the damaged audit trails across the tier

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

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

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

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

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

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

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

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

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

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

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

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

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

Give every routine header a contract that is its own

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Interpret the data tables across the tier

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

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

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

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

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

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

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

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

Every project still prints Byte-identical ROM verified.

CHANGELOG: move the committed entries into History

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

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

Root README: refresh the coverage column of the project inventory

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

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

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

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

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

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

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

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

TODO.md: bring the handoff up to date

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

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

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

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

Three gaps it found, now closed:

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

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

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

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

Every project still prints Byte-identical ROM verified.

PROMPTS.md: the checklist now has a checker

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

CHANGELOG: record the checklist work

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Every project still prints Byte-identical ROM verified.

CHANGELOG: record the zero-page residue work

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

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

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

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

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

Every project still prints Byte-identical ROM verified.

The promoted tier now passes every item of the promotion checklist

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

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

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

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

Every project still prints Byte-identical ROM verified.

CHANGELOG: record the tier passing the checklist

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

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

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

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

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

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

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

Every project still prints Byte-identical ROM verified.

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

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

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

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

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

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

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

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

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

Remaining entry-point naming

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

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

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

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

CHANGELOG: record the entry-point naming

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

Re-align the audit comments to the canonical column

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

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

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

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

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

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

CHANGELOG: record the audit-comment re-alignment

Remaining entry-point naming

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

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

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

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

CHANGELOG: record the tier reaching completion

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

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

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

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

Every project still prints Byte-identical ROM verified.

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

1411 lines
23 KiB
Plaintext
Raw Blame History

BC33 Reset
BC38 Sub_OnNonnegative
BC44 SubCBC44
BC52 Sub_Loop
BC5C Sub_OnNonzero
BC66 Sub_Loop2
BC6E Sub_OnNonnegative2
BC79 Sub_OnNonnegative3
BC91 SubCBC91
BC95 Sub_OnNonzero2
BCC1 Sub_BCC1
BCC4 Sub_BCC4
BCC6 Sub_OnNonzero3
BCDA Sub_BCDA
BCDC Sub_OnNonzero4
BCF0 Sub_BCF0
BCF2 Sub_OnNonzero5
BD01 Sub_BD01
BD03 Sub_OnNonzero6
BD17 Sub_BD17
BD19 Sub_OnNonzero7
BD2D Sub_BD2D
BD2F Sub_OnNonzero8
BD33 NmiHandler
BD4D Sub_Loop3
BD58 Sub_Loop4
BD7A Sub_Loop5
BD84 Sub_Loop6
BD99 Sub_Loop7
BD9C Sub_BD9C
BDB5 Sub_BDB5
BDD8 SubCBDD8
BDF7 SubCBDF7
BE05 SubCBE05
BE20 SubCBE20
BE32 SubCBE32
BE4D SubCBE4D
BE62 SubCBE62
BE77 SubCBE77
BE8C SubCBE8C
BEAF Sub_BEAF
BEB1 Sub_OnNonzero9
BEBF Sub_Loop8
BEC0 Sub_OnZero
BEC1 Sub_BEC1
BEDC Sub_BEDC
BEEA Sub_Loop9
BEFB Sub_Loop10
BF0D Sub_BF0D
BF1B Sub_Loop11
BF29 Sub_BF29
BF2D Sub_OnNonzero10
BF64 Sub_Loop12
BF65 Sub_BF65
BFA1 Sub_Loop13
BFA7 Sub_Loop14
BFBD Sub_OnNonzero11
BFDE Sub_Loop15
BFE6 Sub_BFE6
BFE7 Sub_OnCarryClear
BFEF Sub_Loop16
C00B Sub_Loop17
C017 Sub_Loop18
C01A Sub_C01A
C028 Sub_Loop19
C029 Sub_C029
C039 Sub_Loop20
C03A Sub_C03A
C04A Sub_OnNonzero12
C077 Sub_Loop21
C081 Sub_Loop22
C08A Sub_Loop23
C08B Sub_C08B
C0A7 Sub_Loop24
C0AF Sub_C0AF
C0D1 Sub_Loop25
C0DB Sub_Loop26
C0DC Sub_C0DC
C0F8 Sub_Loop27
C102 Sub_C102
C124 Sub_Loop28
C12E Sub_Loop29
C12F Sub_C12F
C14D Sub_Loop30
C16A Sub_Loop31
C16D Sub_Loop32
C18B Sub_Loop33
C18E Sub_C18E
C190 Sub_OnNonzero13
C1A6 Sub_Loop34
C1B0 Sub_C1B0
C1D5 Sub_Loop35
C1E0 Sub_C1E0
C1E8 Sub_Loop36
C200 Sub_Loop37
C20A Sub_C20A
C23C Sub_Loop38
C241 Sub_Loop39
C25D Sub_Loop40
C26C Sub_Loop41
C278 Sub_Loop42
C27A Sub_OnNonzero14
C297 Sub_Loop43
C2A1 Sub_C2A1
C2C7 Sub_Loop44
C2D6 Sub_OnNonzero15
C2DE Sub_Loop45
C2E8 Sub_Loop46
C2EA Sub_OnNonzero16
C2F2 Sub_Loop47
C2FC Sub_C2FC
C31C Sub_Loop48
C323 Sub_Loop49
C336 Sub_Loop50
C34B Sub_Loop51
C35D Sub_C35D
C366 Sub_Loop52
C370 Sub_Loop53
C385 Sub_Loop54
C398 Sub_Loop55
C39E Sub_Loop56
C3A7 Sub_Loop57
C3E8 Sub_OnNonzero17
C423 Sub_Loop58
C438 Sub_Loop59
C451 Sub_Loop60
C465 Sub_C465
C46E Sub_Loop61
C486 Sub_C486
C48F Sub_Loop62
C496 Sub_Loop63
C49A Sub_C49A
C4C0 Sub_Loop64
C4C5 Sub_C4C5
C4CF Sub_C4CF
C50F Sub_Loop65
C51B Sub_Loop66
C521 Sub_C521
C525 Sub_OnNonzero18
C583 Sub_Loop67
C58C Sub_Loop68
C592 Sub_C592
C5B7 Sub_Loop69
C5C7 Sub_Loop70
C5D8 Sub_C5D8
C5F2 Sub_Loop71
C5F8 Sub_Loop72
C614 Sub_Loop73
C62B Sub_Loop74
C634 Sub_Loop75
C64E Sub_Loop76
C655 Sub_Loop77
C65C Sub_Loop78
C66C Sub_Loop79
C686 Sub_Loop80
C6A8 Sub_Loop81
C6AE Sub_Loop82
C6DC Sub_C6DC
C6E3 Sub_Loop83
C6E5 Sub_OnNonzero19
C6FE Sub_Loop84
C704 Sub_Loop85
C723 Sub_Loop86
C728 Sub_Loop87
C74E Sub_Loop88
C762 Sub_C762
C76A Sub_Loop89
C76B Sub_C76B
C76D Sub_OnNonzero20
C786 Sub_Loop90
C789 Sub_Loop91
C792 Sub_Loop92
C793 Sub_C793
C79B Sub_OnNonzero21
C861 Sub_C861
C863 Sub_OnNonzero22
C86F Sub_C86F
C873 Sub_OnNonzero23
C87F Sub_C87F
C899 Sub_OnNonzero24
C9BF Sub_C9BF
C9C7 Sub_C9C7
C9E5 Sub_Loop93
CA02 Sub_CA02
CA0B Sub_Loop94
CA20 Sub_CA20
CA34 Sub_Loop95
CA36 Sub_OnNonzero25
CA4B Sub_OnNonzero26
CA6F Sub_CA6F
CA7F Sub_Loop96
CA86 Sub_Loop97
CAE0 Sub_CAE0
CAF8 Sub_Loop98
CB06 Sub_Loop99
CB0D Sub_Loop100
CB28 Sub_Loop101
CB2B Sub_OnNonzero27
CB46 Sub_Loop102
CB4D Sub_Loop103
CB67 Sub_Loop104
CB7C Sub_Loop105
CB81 Sub_Loop106
CB85 Sub_CB85
CB97 Sub_Loop107
CBA2 Sub_Loop108
CBDB Sub_OnNonnegative4
CBE1 Sub_CBE1
CBEC Sub_CBEC
CBF6 Sub_CBF6
CC01 Sub_Loop109
CD78 Sub_CD78
CDB0 Sub_CDB0
CDB2 Sub_OnNonzero28
CDC0 Sub_OnNonzero29
CDCD Sub_Loop110
CDD1 Sub_Loop111
CDDC Sub_Loop112
CDDE Sub_OnCarryClear2
CDF0 Sub_OnNonzero30
CE0A Sub_OnNonzero31
CE1F Sub_OnNonzero32
CE24 Sub_OnNonzero33
CE48 Sub_OnNonzero34
CE5E Sub_CE5E
CE68 Sub_OnNonzero35
CE7C Sub_OnNonzero36
CE87 Sub_CE87
CE89 Sub_OnNonzero37
CEAB Sub_CEAB
CEBE Sub_Loop113
CEC3 Sub_Loop114
CECC Sub_Loop115
CED3 Sub_Loop116
CED7 Sub_Loop117
CEE3 Sub_Loop118
CEF3 Sub_Loop119
CEF4 Sub_CEF4
CF04 Sub_OnNonzero38
CF18 Sub_OnNonzero39
CF26 Sub_Loop120
CF27 Sub_CF27
CF38 Sub_OnNonzero40
CF48 Sub_CF48
CF4A Sub_CF4A
CF86 Sub_Loop121
CF87 Sub_CF87
CF93 Sub_OnNonzero41
CF9A Sub_Loop122
CFA3 Sub_Loop123
CFC1 Sub_CFC1
CFE3 Sub_Loop124
CFF9 Sub_Loop125
D00A Sub_Loop126
D028 Sub_Loop127
D042 Sub_Loop128
D05B Sub_Loop129
D064 Sub_Loop130
D078 Sub_Loop131
D07A Sub_D07A
D08D Sub_D08D
D0C6 Sub_D0C6
D0CA Sub_D0CA
D0ED Sub_Loop132
D0F3 Sub_Loop133
D0FD Sub_D0FD
D138 Sub_OnNonzero42
D15F Sub_OnNonzero43
D17F Sub_Loop134
D189 Sub_OnNonzero44
D1B0 Sub_OnNonzero45
D1CD Sub_D1CD
D1E0 Sub_Loop135
D203 Sub_OnNonzero46
D220 Sub_Loop136
D22A Sub_Loop137
D258 Sub_D258
D26B Sub_Loop138
D270 Sub_D270
D279 Sub_Loop139
D29B Sub_Loop140
D29E Sub_Loop141
D2D8 Sub_OnNonzero47
D32B Sub_OnNonzero48
D349 Sub_OnNonzero49
D367 Sub_OnNonzero50
D383 Sub_D383
D388 Sub_D388
D38E Sub_Loop142
D38F Sub_D38F
D395 Sub_Loop143
D396 Sub_D396
D3A2 Sub_OnNonzero51
D3BE Sub_Loop144
D3BF Sub_D3BF
D3C8 Sub_Loop145
D3F1 Sub_Loop146
D40B Sub_OnNonzero52
D419 Sub_Loop147
D427 Sub_Loop148
D439 Sub_Loop149
D478 Sub_D478
D483 Sub_Loop150
D4C2 Sub_Loop151
D4C9 Sub_D4C9
D4CE Sub_Loop152
D4DA Sub_D4DA
D502 Sub_Loop153
D505 Sub_Loop154
D507 Sub_D507
D50E Sub_Loop155
D528 Sub_Loop156
D536 Sub_Loop157
D546 Sub_Loop158
D585 Sub_D585
D59F Sub_Loop159
D5AA Sub_Loop160
D5DA Sub_Loop161
D5F6 Sub_Loop162
D61B Sub_Loop163
D634 Sub_Loop164
D656 Sub_Loop165
D662 Sub_Loop166
D665 Sub_D665
D668 Sub_D668
D66A Sub_D66A
D672 Sub_Loop167
D67A Sub_Loop168
D683 Sub_Loop169
D68B Sub_Loop170
D6A7 Sub_Loop171
D6BC Sub_Loop172
D6D3 Sub_Loop173
D6E8 Sub_Loop174
D708 Sub_D708
D71C Sub_Loop175
D729 Sub_Loop176
D746 Sub_Loop177
D74E Sub_Loop178
D756 Sub_Loop179
D776 Sub_Loop180
D7C3 Sub_Loop181
D7CF Sub_Loop182
D7D1 Sub_D7D1
D7E2 Sub_Loop183
D7EB Sub_Loop184
D806 Sub_Loop185
D821 Sub_Loop186
D83E Sub_Loop187
D846 Sub_Loop188
D84E Sub_Loop189
D851 Sub_Loop190
D85D Sub_Loop191
D85E Sub_D85E
D865 Sub_Loop192
D87D Sub_Loop193
D891 Sub_Loop194
D8DB Sub_Loop195
D8F0 Sub_Loop196
D8F7 Sub_Loop197
D919 Sub_D919
D920 Sub_Loop198
D92A Sub_Loop199
D989 Sub_D989
D99D Sub_OnNonzero53
D9C0 Sub_D9C0
D9F5 Sub_D9F5
DA1C Sub_OnCarryClear3
DA1F Sub_Loop200
DA2A Sub_Loop201
DA2D Sub_DA2D
DA36 Sub_Loop202
DA38 Sub_DA38
DA3E Sub_DA3E
DA52 Sub_Loop203
DA5B Sub_OnNonzero54
DA6D Sub_Loop204
DA7C Sub_OnNonzero55
DA8B Sub_Loop205
DA94 Sub_Loop206
DA95 Sub_Loop207
DABB Sub_DABB
DABD Sub_OnNonzero56
DACC Sub_Loop208
DAD9 Sub_Loop209
DB0C Sub_Loop210
DB11 Sub_Loop211
DB12 Sub_DB12
DB32 Sub_OnZero2
DB61 Sub_Loop212
DBB5 Sub_Loop213
DBC0 Sub_Loop214
DBDA Sub_Loop215
DBFA Sub_Loop216
DC08 Sub_OnNonzero57
DC54 Sub_Loop217
DC5B Sub_Loop218
DC68 Sub_DC68
DC81 Sub_OnZero3
DCA1 Sub_Loop219
DCCD Sub_Loop220
DCE2 Sub_Loop221
DCE4 Sub_OnNonzero58
DCF2 Sub_Loop222
DD25 Sub_Loop223
DD2C Sub_OnNonzero59
DD2D Sub_DD2D
DD3A Sub_Loop224
DD3F Sub_Loop225
DDBB Sub_DDBB
DDC3 Sub_Loop226
DDC5 Sub_OnNonzero60
DDD0 Sub_OnNonzero61
DDF7 Sub_Loop227
DDFA Sub_Loop228
DE03 Sub_Loop229
DE14 Sub_Loop230
DE16 Sub_OnNonzero62
DE23 Sub_OnNonzero63
DE4F Sub_DE4F
DE5C Sub_Loop231
DE65 Sub_Loop232
DE6E Sub_Loop233
DE77 Sub_Loop234
DE7E Sub_Loop235
DE80 Sub_DE80
DE8B Sub_Loop236
DE8E Sub_Loop237
DEBB Sub_Loop238
DEBE Sub_Loop239
DECB Sub_Loop240
DEDF Sub_Loop241
DF07 Sub_OnCarryClear4
DF0A Sub_Loop242
DF15 Sub_Loop243
DF21 Sub_Loop244
DF2D Sub_Loop245
DF2E Sub_DF2E
DF30 Sub_DF30
DF37 Sub_OnCarrySet
DF3A Sub_Loop246
DF5B Sub_Loop247
DF5E Sub_Loop248
DF72 Sub_Loop249
DF9A Sub_OnCarryClear5
DFA5 Sub_Loop250
DFB0 Sub_Loop251
DFBC Sub_Loop252
DFC8 Sub_Loop253
DFC9 Sub_DFC9
DFD1 Sub_Loop254
DFD8 Sub_DFD8
E003 Sub_Loop255
E016 Sub_E016
E02E Sub_Loop256
E042 Sub_E042
E048 Sub_Loop257
E050 Sub_Loop258
E05C Sub_Loop259
E061 Sub_E061
E07C Sub_Loop260
E08F Sub_E08F
E0A7 Sub_Loop261
E0BB Sub_E0BB
E0C1 Sub_Loop262
E0C9 Sub_Loop263
E0D5 Sub_Loop264
E0DC Sub_Loop265
E0DE Sub_E0DE
E0EF Sub_Loop266
E0F6 Sub_Loop267
E0F9 Sub_Loop268
E108 Sub_Loop269
E120 Sub_Loop270
E13A Sub_Loop271
E13D Sub_Loop272
E14A Sub_Loop273
E174 Sub_OnZero4
E177 Sub_Loop274
E1C7 Sub_Loop275
E1C8 Sub_Loop276
E1D9 Sub_Loop277
E1DC Sub_E1DC
E205 Sub_Loop278
E20C Sub_Loop279
E20F Sub_E20F
E21B Sub_E21B
E228 Sub_Loop280
E22D Sub_Loop281
E22F Sub_E22F
E23B Sub_Loop282
E248 Sub_Loop283
E25F Sub_Loop284
E262 Sub_Loop285
E27C Sub_E27C
E29B Sub_Loop286
E2A6 Sub_E2A6
E2B7 Sub_Loop287
E2ED Sub_Loop288
E2F9 Sub_Loop289
E305 Sub_Loop290
E306 Sub_E306
E30B Sub_E30B
E317 Sub_Loop291
E31A Sub_Loop292
E329 Sub_Loop293
E341 Sub_Loop294
E35C Sub_Loop295
E362 Sub_E362
E369 Sub_Loop296
E36C Sub_Loop297
E380 Sub_Loop298
E398 Sub_Loop299
E399 Sub_Loop300
E3B0 Sub_Loop301
E3B2 Sub_E3B2
E3C9 Sub_Loop302
E40D Sub_Loop303
E40E Sub_Loop304
E41F Sub_Loop305
E422 Sub_E422
E44B Sub_Loop306
E456 Sub_Loop307
E462 Sub_Loop308
E463 Sub_E463
E46C Sub_Loop309
E46D Sub_E46D
E47D Sub_Loop310
E495 Sub_E495
E4B2 Sub_Loop311
E4CF Sub_Loop312
E4D4 SubCE4D4
E532 Sub_E532
E535 Sub_Loop313
E542 Sub_Loop314
E545 Sub_Loop315
E557 Sub_Loop316
E563 Sub_Loop317
E567 Sub_OnNonzero64
E574 Sub_Loop318
E5A2 Sub_Loop319
E5B0 Sub_Loop320
E5B1 Sub_E5B1
E5C1 Sub_Loop321
E5C8 Sub_Loop322
E5C9 Sub_E5C9
E60A Sub_Loop323
E60B Sub_E60B
E617 Sub_Loop324
E622 Sub_Loop325
E639 Sub_Loop326
E63A Sub_Loop327
E64A Sub_Loop328
E64B Sub_E64B
E654 Sub_OnCarryClear6
E657 Sub_Loop329
E66F Sub_Loop330
E67B Sub_OnNonzero65
E684 Sub_Loop331
E685 Sub_Loop332
E6A1 Sub_Loop333
E6B8 Sub_OnNonzero66
E6C3 Sub_Loop334
E6C4 Sub_Loop335
E6CA Sub_Loop336
E6CF Sub_E6CF
E6DB Sub_Loop337
E6E6 Sub_OnNonzero67
E6F6 Sub_Loop338
E6F8 Sub_OnNonzero68
E701 Sub_E701
E703 Sub_OnNonzero69
E70D Sub_Loop339
E713 Sub_OnNonzero70
E723 Sub_Loop340
E725 Sub_OnNonzero71
E72E Sub_E72E
E730 Sub_OnNonzero72
E73B SubCE73B
E74D Sub_Loop341
E76A Sub_Loop342
E776 Sub_Loop343
E781 Sub_Loop344
E78A Sub_Loop345
E79A Sub_E79A
E7DC Sub_Loop346
E7DD Sub_Loop347
E81B Sub_Loop348
E81C Sub_E81C
E82D Sub_Loop349
E837 Sub_Loop350
E847 Sub_Loop351
E856 Sub_Loop352
E857 Sub_Loop353
E85C Sub_E85C
E869 Sub_Loop354
E86A Sub_E86A
E8A3 Sub_Loop355
E8B4 Sub_Loop356
E8B5 Sub_Loop357
E8C5 Sub_Loop358
E8D5 Sub_Loop359
E8DE Sub_Loop360
E8EE Sub_Loop361
E903 Sub_Loop362
E912 Sub_Loop363
E91B Sub_Loop364
E965 Sub_E965
E978 Sub_Loop365
E97C Sub_Loop366
E991 Sub_Loop367
E9AA Sub_Loop368
E9AB Sub_Loop369
E9BC Sub_Loop370
E9BD Sub_Loop371
E9D4 Sub_Loop372
E9E2 Sub_Loop373
E9F2 Sub_Loop374
EA06 Sub_Loop375
EA28 Sub_EA28
EA3F Sub_Loop376
EA50 Sub_Loop377
EA55 Sub_Loop378
EA5C Sub_Loop379
EA67 Sub_Loop380
EA82 Sub_Loop381
EA84 Sub_OnNonzero73
EA85 Sub_Loop382
EA98 Sub_Loop383
EAA6 Sub_Loop384
EAAD SubCEAAD
EB95 Sub_EB95
EB9E Sub_OnNonzero74
EBAE Sub_Loop385
EBAF SubCEBAF
EBCC Sub_Loop386
EC17 Sub_Loop387
EC18 SubCEC18
EC6B Sub_Loop388
EC9A Sub_EC9A
EC9C Sub_OnNonzero75
ECB6 Sub_Loop389
ECCF Sub_Loop390
ECDC SubCECDC
ECDF SubCECDF
ECE9 Sub_Loop391
ECF2 Sub_Loop392
F7E6 Sub_F7E6
F7E8 Sub_OnNonzero76
F7FF Sub_Loop393
F837 SubCF837
F864 SubCF864
F879 Sub_Loop394
F88D Sub_Loop395
F89E Sub_Loop396
F8A4 Sub_F8A4
F8BB Sub_F8BB
F8CD Sub_F8CD
F8D8 SubCF8D8
F8E7 Sub_F8E7
F901 Sub_Loop397
F922 Sub_F922
F92A Sub_Loop398
F93C Sub_Loop399
F953 Sub_Loop400
F967 Sub_Loop401
F96D Sub_Loop402
F974 Sub_Loop403
F9F3 Sub_F9F3
F9FD Sub_OnNonzero77
FA09 Sub_Loop404
FA51 Sub_FA51
FA57 Sub_FA57
FA63 Sub_Loop405
FA89 Sub_FA89
FA8D Sub_OnNonnegative5
FAA8 Sub_FAA8
FAAE Sub_Loop406
FAAF Sub_FAAF
FAC7 Sub_FAC7
FAD2 Sub_Loop407
FAE6 Sub_FAE6
FB1A Sub_FB1A
FB2A Sub_Loop408
FB33 Sub_Loop409
FB34 Sub_Loop410
FB3D Sub_Loop411
FB49 Sub_Loop412
FB81 Sub_Loop413
FB9E Sub_Loop414
FBAF Sub_Loop415
FBB7 Sub_Loop416
FBC0 Sub_FBC0
FBDA Sub_Loop417
FBF6 Sub_Loop418
FBF7 Sub_Loop419
FBF9 Sub_FBF9
FC08 Sub_Loop420
FC09 Sub_Loop421
FC16 Sub_Loop422
FC19 Sub_Loop423
FC28 Sub_Loop424
FC37 Sub_Loop425
FC46 Sub_Loop426
# ---- derived internal branch-target names ----
BC33 Reset
BC38 Sub_OnNonnegative
BC44 SubCBC44
BC52 Sub_Loop
BC5C Sub_OnNonzero
BC66 Sub_Loop2
BC6E Sub_OnNonnegative2
BC79 Sub_OnNonnegative3
BC91 SubCBC91
BC95 Sub_OnNonzero2
BCC1 Sub_BCC1
BCC4 Sub_BCC4
BCC6 Sub_OnNonzero3
BCDA Sub_BCDA
BCDC Sub_OnNonzero4
BCF0 Sub_BCF0
BCF2 Sub_OnNonzero5
BD01 Sub_BD01
BD03 Sub_OnNonzero6
BD17 Sub_BD17
BD19 Sub_OnNonzero7
BD2D Sub_BD2D
BD2F Sub_OnNonzero8
BD33 NmiHandler
BD4D Sub_Loop3
BD58 Sub_Loop4
BD7A Sub_Loop5
BD84 Sub_Loop6
BD99 Sub_Loop7
BD9C Sub_BD9C
BDB5 Sub_BDB5
BDD8 SubCBDD8
BDF7 SubCBDF7
BE05 SubCBE05
BE20 SubCBE20
BE32 SubCBE32
BE4D SubCBE4D
BE62 SubCBE62
BE77 SubCBE77
BE8C SubCBE8C
BEAF Sub_BEAF
BEB1 Sub_OnNonzero9
BEBF Sub_Loop8
BEC0 Sub_OnZero
BEC1 Sub_BEC1
BEDC Sub_BEDC
BEEA Sub_Loop9
BEFB Sub_Loop10
BF0D Sub_BF0D
BF1B Sub_Loop11
BF29 Sub_BF29
BF2D Sub_OnNonzero10
BF64 Sub_Loop12
BF65 Sub_BF65
BFA1 Sub_Loop13
BFA7 Sub_Loop14
BFBD Sub_OnNonzero11
BFDE Sub_Loop15
BFE6 Sub_BFE6
BFE7 Sub_OnCarryClear
BFEF Sub_Loop16
C00B Sub_Loop17
C017 Sub_Loop18
C01A Sub_C01A
C028 Sub_Loop19
C029 Sub_C029
C039 Sub_Loop20
C03A Sub_C03A
C04A Sub_OnNonzero12
C077 Sub_Loop21
C081 Sub_Loop22
C08A Sub_Loop23
C08B Sub_C08B
C0A7 Sub_Loop24
C0AF Sub_C0AF
C0D1 Sub_Loop25
C0DB Sub_Loop26
C0DC Sub_C0DC
C0F8 Sub_Loop27
C102 Sub_C102
C124 Sub_Loop28
C12E Sub_Loop29
C12F Sub_C12F
C14D Sub_Loop30
C16A Sub_Loop31
C16D Sub_Loop32
C18B Sub_Loop33
C18E Sub_C18E
C190 Sub_OnNonzero13
C1A6 Sub_Loop34
C1B0 Sub_C1B0
C1D5 Sub_Loop35
C1E0 Sub_C1E0
C1E8 Sub_Loop36
C200 Sub_Loop37
C20A Sub_C20A
C23C Sub_Loop38
C241 Sub_Loop39
C25D Sub_Loop40
C26C Sub_Loop41
C278 Sub_Loop42
C27A Sub_OnNonzero14
C297 Sub_Loop43
C2A1 Sub_C2A1
C2C7 Sub_Loop44
C2D6 Sub_OnNonzero15
C2DE Sub_Loop45
C2E8 Sub_Loop46
C2EA Sub_OnNonzero16
C2F2 Sub_Loop47
C2FC Sub_C2FC
C31C Sub_Loop48
C323 Sub_Loop49
C336 Sub_Loop50
C34B Sub_Loop51
C35D Sub_C35D
C366 Sub_Loop52
C370 Sub_Loop53
C385 Sub_Loop54
C398 Sub_Loop55
C39E Sub_Loop56
C3A7 Sub_Loop57
C3E8 Sub_OnNonzero17
C423 Sub_Loop58
C438 Sub_Loop59
C451 Sub_Loop60
C465 Sub_C465
C46E Sub_Loop61
C486 Sub_C486
C48F Sub_Loop62
C496 Sub_Loop63
C49A Sub_C49A
C4C0 Sub_Loop64
C4C5 Sub_C4C5
C4CF Sub_C4CF
C50F Sub_Loop65
C51B Sub_Loop66
C521 Sub_C521
C525 Sub_OnNonzero18
C583 Sub_Loop67
C58C Sub_Loop68
C592 Sub_C592
C5B7 Sub_Loop69
C5C7 Sub_Loop70
C5D8 Sub_C5D8
C5F2 Sub_Loop71
C5F8 Sub_Loop72
C614 Sub_Loop73
C62B Sub_Loop74
C634 Sub_Loop75
C64E Sub_Loop76
C655 Sub_Loop77
C65C Sub_Loop78
C66C Sub_Loop79
C686 Sub_Loop80
C6A8 Sub_Loop81
C6AE Sub_Loop82
C6DC Sub_C6DC
C6E3 Sub_Loop83
C6E5 Sub_OnNonzero19
C6FE Sub_Loop84
C704 Sub_Loop85
C723 Sub_Loop86
C728 Sub_Loop87
C74E Sub_Loop88
C762 Sub_C762
C76A Sub_Loop89
C76B Sub_C76B
C76D Sub_OnNonzero20
C786 Sub_Loop90
C789 Sub_Loop91
C792 Sub_Loop92
C793 Sub_C793
C79B Sub_OnNonzero21
C861 Sub_C861
C863 Sub_OnNonzero22
C86F Sub_C86F
C873 Sub_OnNonzero23
C87F Sub_C87F
C899 Sub_OnNonzero24
C9BF Sub_C9BF
C9C7 Sub_C9C7
C9E5 Sub_Loop93
CA02 Sub_CA02
CA0B Sub_Loop94
CA20 Sub_CA20
CA34 Sub_Loop95
CA36 Sub_OnNonzero25
CA4B Sub_OnNonzero26
CA6F Sub_CA6F
CA7F Sub_Loop96
CA86 Sub_Loop97
CAE0 Sub_CAE0
CAF8 Sub_Loop98
CB06 Sub_Loop99
CB0D Sub_Loop100
CB28 Sub_Loop101
CB2B Sub_OnNonzero27
CB46 Sub_Loop102
CB4D Sub_Loop103
CB67 Sub_Loop104
CB7C Sub_Loop105
CB81 Sub_Loop106
CB85 Sub_CB85
CB97 Sub_Loop107
CBA2 Sub_Loop108
CBDB Sub_OnNonnegative4
CBE1 Sub_CBE1
CBEC Sub_CBEC
CBF6 Sub_CBF6
CC01 Sub_Loop109
CD78 Sub_CD78
CDB0 Sub_CDB0
CDB2 Sub_OnNonzero28
CDC0 Sub_OnNonzero29
CDCD Sub_Loop110
CDD1 Sub_Loop111
CDDC Sub_Loop112
CDDE Sub_OnCarryClear2
CDF0 Sub_OnNonzero30
CE0A Sub_OnNonzero31
CE1F Sub_OnNonzero32
CE24 Sub_OnNonzero33
CE48 Sub_OnNonzero34
CE5E Sub_CE5E
CE68 Sub_OnNonzero35
CE7C Sub_OnNonzero36
CE87 Sub_CE87
CE89 Sub_OnNonzero37
CEAB Sub_CEAB
CEBE Sub_Loop113
CEC3 Sub_Loop114
CECC Sub_Loop115
CED3 Sub_Loop116
CED7 Sub_Loop117
CEE3 Sub_Loop118
CEF3 Sub_Loop119
CEF4 Sub_CEF4
CF04 Sub_OnNonzero38
CF18 Sub_OnNonzero39
CF26 Sub_Loop120
CF27 Sub_CF27
CF38 Sub_OnNonzero40
CF48 Sub_CF48
CF4A Sub_CF4A
CF86 Sub_Loop121
CF87 Sub_CF87
CF93 Sub_OnNonzero41
CF9A Sub_Loop122
CFA3 Sub_Loop123
CFC1 Sub_CFC1
CFE3 Sub_Loop124
CFF9 Sub_Loop125
D00A Sub_Loop126
D028 Sub_Loop127
D042 Sub_Loop128
D05B Sub_Loop129
D064 Sub_Loop130
D078 Sub_Loop131
D07A Sub_D07A
D08D Sub_D08D
D0C6 Sub_D0C6
D0CA Sub_D0CA
D0ED Sub_Loop132
D0F3 Sub_Loop133
D0FD Sub_D0FD
D138 Sub_OnNonzero42
D15F Sub_OnNonzero43
D17F Sub_Loop134
D189 Sub_OnNonzero44
D1B0 Sub_OnNonzero45
D1CD Sub_D1CD
D1E0 Sub_Loop135
D203 Sub_OnNonzero46
D220 Sub_Loop136
D22A Sub_Loop137
D258 Sub_D258
D26B Sub_Loop138
D270 Sub_D270
D279 Sub_Loop139
D29B Sub_Loop140
D29E Sub_Loop141
D2D8 Sub_OnNonzero47
D32B Sub_OnNonzero48
D349 Sub_OnNonzero49
D367 Sub_OnNonzero50
D383 Sub_D383
D388 Sub_D388
D38E Sub_Loop142
D38F Sub_D38F
D395 Sub_Loop143
D396 Sub_D396
D3A2 Sub_OnNonzero51
D3BE Sub_Loop144
D3BF Sub_D3BF
D3C8 Sub_Loop145
D3F1 Sub_Loop146
D40B Sub_OnNonzero52
D419 Sub_Loop147
D427 Sub_Loop148
D439 Sub_Loop149
D478 Sub_D478
D483 Sub_Loop150
D4C2 Sub_Loop151
D4C9 Sub_D4C9
D4CE Sub_Loop152
D4DA Sub_D4DA
D502 Sub_Loop153
D505 Sub_Loop154
D507 Sub_D507
D50E Sub_Loop155
D528 Sub_Loop156
D536 Sub_Loop157
D546 Sub_Loop158
D585 Sub_D585
D59F Sub_Loop159
D5AA Sub_Loop160
D5DA Sub_Loop161
D5F6 Sub_Loop162
D61B Sub_Loop163
D634 Sub_Loop164
D656 Sub_Loop165
D662 Sub_Loop166
D665 Sub_D665
D668 Sub_D668
D66A Sub_D66A
D672 Sub_Loop167
D67A Sub_Loop168
D683 Sub_Loop169
D68B Sub_Loop170
D6A7 Sub_Loop171
D6BC Sub_Loop172
D6D3 Sub_Loop173
D6E8 Sub_Loop174
D708 Sub_D708
D71C Sub_Loop175
D729 Sub_Loop176
D746 Sub_Loop177
D74E Sub_Loop178
D756 Sub_Loop179
D776 Sub_Loop180
D7C3 Sub_Loop181
D7CF Sub_Loop182
D7D1 Sub_D7D1
D7E2 Sub_Loop183
D7EB Sub_Loop184
D806 Sub_Loop185
D821 Sub_Loop186
D83E Sub_Loop187
D846 Sub_Loop188
D84E Sub_Loop189
D851 Sub_Loop190
D85D Sub_Loop191
D85E Sub_D85E
D865 Sub_Loop192
D87D Sub_Loop193
D891 Sub_Loop194
D8DB Sub_Loop195
D8F0 Sub_Loop196
D8F7 Sub_Loop197
D919 Sub_D919
D920 Sub_Loop198
D92A Sub_Loop199
D989 Sub_D989
D99D Sub_OnNonzero53
D9C0 Sub_D9C0
D9F5 Sub_D9F5
DA1C Sub_OnCarryClear3
DA1F Sub_Loop200
DA2A Sub_Loop201
DA2D Sub_DA2D
DA36 Sub_Loop202
DA38 Sub_DA38
DA3E Sub_DA3E
DA52 Sub_Loop203
DA5B Sub_OnNonzero54
DA6D Sub_Loop204
DA7C Sub_OnNonzero55
DA8B Sub_Loop205
DA94 Sub_Loop206
DA95 Sub_Loop207
DABB Sub_DABB
DABD Sub_OnNonzero56
DACC Sub_Loop208
DAD9 Sub_Loop209
DB0C Sub_Loop210
DB11 Sub_Loop211
DB12 Sub_DB12
DB32 Sub_OnZero2
DB61 Sub_Loop212
DBB5 Sub_Loop213
DBC0 Sub_Loop214
DBDA Sub_Loop215
DBFA Sub_Loop216
DC08 Sub_OnNonzero57
DC54 Sub_Loop217
DC5B Sub_Loop218
DC68 Sub_DC68
DC81 Sub_OnZero3
DCA1 Sub_Loop219
DCCD Sub_Loop220
DCE2 Sub_Loop221
DCE4 Sub_OnNonzero58
DCF2 Sub_Loop222
DD25 Sub_Loop223
DD2C Sub_OnNonzero59
DD2D Sub_DD2D
DD3A Sub_Loop224
DD3F Sub_Loop225
DDBB Sub_DDBB
DDC3 Sub_Loop226
DDC5 Sub_OnNonzero60
DDD0 Sub_OnNonzero61
DDF7 Sub_Loop227
DDFA Sub_Loop228
DE03 Sub_Loop229
DE14 Sub_Loop230
DE16 Sub_OnNonzero62
DE23 Sub_OnNonzero63
DE4F Sub_DE4F
DE5C Sub_Loop231
DE65 Sub_Loop232
DE6E Sub_Loop233
DE77 Sub_Loop234
DE7E Sub_Loop235
DE80 Sub_DE80
DE8B Sub_Loop236
DE8E Sub_Loop237
DEBB Sub_Loop238
DEBE Sub_Loop239
DECB Sub_Loop240
DEDF Sub_Loop241
DF07 Sub_OnCarryClear4
DF0A Sub_Loop242
DF15 Sub_Loop243
DF21 Sub_Loop244
DF2D Sub_Loop245
DF2E Sub_DF2E
DF30 Sub_DF30
DF37 Sub_OnCarrySet
DF3A Sub_Loop246
DF5B Sub_Loop247
DF5E Sub_Loop248
DF72 Sub_Loop249
DF9A Sub_OnCarryClear5
DFA5 Sub_Loop250
DFB0 Sub_Loop251
DFBC Sub_Loop252
DFC8 Sub_Loop253
DFC9 Sub_DFC9
DFD1 Sub_Loop254
DFD8 Sub_DFD8
E003 Sub_Loop255
E016 Sub_E016
E02E Sub_Loop256
E042 Sub_E042
E048 Sub_Loop257
E050 Sub_Loop258
E05C Sub_Loop259
E061 Sub_E061
E07C Sub_Loop260
E08F Sub_E08F
E0A7 Sub_Loop261
E0BB Sub_E0BB
E0C1 Sub_Loop262
E0C9 Sub_Loop263
E0D5 Sub_Loop264
E0DC Sub_Loop265
E0DE Sub_E0DE
E0EF Sub_Loop266
E0F6 Sub_Loop267
E0F9 Sub_Loop268
E108 Sub_Loop269
E120 Sub_Loop270
E13A Sub_Loop271
E13D Sub_Loop272
E14A Sub_Loop273
E174 Sub_OnZero4
E177 Sub_Loop274
E1C7 Sub_Loop275
E1C8 Sub_Loop276
E1D9 Sub_Loop277
E1DC Sub_E1DC
E205 Sub_Loop278
E20C Sub_Loop279
E20F Sub_E20F
E21B Sub_E21B
E228 Sub_Loop280
E22D Sub_Loop281
E22F Sub_E22F
E23B Sub_Loop282
E248 Sub_Loop283
E25F Sub_Loop284
E262 Sub_Loop285
E27C Sub_E27C
E29B Sub_Loop286
E2A6 Sub_E2A6
E2B7 Sub_Loop287
E2ED Sub_Loop288
E2F9 Sub_Loop289
E305 Sub_Loop290
E306 Sub_E306
E30B Sub_E30B
E317 Sub_Loop291
E31A Sub_Loop292
E329 Sub_Loop293
E341 Sub_Loop294
E35C Sub_Loop295
E362 Sub_E362
E369 Sub_Loop296
E36C Sub_Loop297
E380 Sub_Loop298
E398 Sub_Loop299
E399 Sub_Loop300
E3B0 Sub_Loop301
E3B2 Sub_E3B2
E3C9 Sub_Loop302
E40D Sub_Loop303
E40E Sub_Loop304
E41F Sub_Loop305
E422 Sub_E422
E44B Sub_Loop306
E456 Sub_Loop307
E462 Sub_Loop308
E463 Sub_E463
E46C Sub_Loop309
E46D Sub_E46D
E47D Sub_Loop310
E495 Sub_E495
E4B2 Sub_Loop311
E4CF Sub_Loop312
E4D4 SubCE4D4
E532 Sub_E532
E535 Sub_Loop313
E542 Sub_Loop314
E545 Sub_Loop315
E557 Sub_Loop316
E563 Sub_Loop317
E567 Sub_OnNonzero64
E574 Sub_Loop318
E5A2 Sub_Loop319
E5B0 Sub_Loop320
E5B1 Sub_E5B1
E5C1 Sub_Loop321
E5C8 Sub_Loop322
E5C9 Sub_E5C9
E60A Sub_Loop323
E60B Sub_E60B
E617 Sub_Loop324
E622 Sub_Loop325
E639 Sub_Loop326
E63A Sub_Loop327
E64A Sub_Loop328
E64B Sub_E64B
E654 Sub_OnCarryClear6
E657 Sub_Loop329
E66F Sub_Loop330
E67B Sub_OnNonzero65
E684 Sub_Loop331
E685 Sub_Loop332
E6A1 Sub_Loop333
E6B8 Sub_OnNonzero66
E6C3 Sub_Loop334
E6C4 Sub_Loop335
E6CA Sub_Loop336
E6CF Sub_E6CF
E6DB Sub_Loop337
E6E6 Sub_OnNonzero67
E6F6 Sub_Loop338
E6F8 Sub_OnNonzero68
E701 Sub_E701
E703 Sub_OnNonzero69
E70D Sub_Loop339
E713 Sub_OnNonzero70
E723 Sub_Loop340
E725 Sub_OnNonzero71
E72E Sub_E72E
E730 Sub_OnNonzero72
E73B SubCE73B
E74D Sub_Loop341
E76A Sub_Loop342
E776 Sub_Loop343
E781 Sub_Loop344
E78A Sub_Loop345
E79A Sub_E79A
E7DC Sub_Loop346
E7DD Sub_Loop347
E81B Sub_Loop348
E81C Sub_E81C
E82D Sub_Loop349
E837 Sub_Loop350
E847 Sub_Loop351
E856 Sub_Loop352
E857 Sub_Loop353
E85C Sub_E85C
E869 Sub_Loop354
E86A Sub_E86A
E8A3 Sub_Loop355
E8B4 Sub_Loop356
E8B5 Sub_Loop357
E8C5 Sub_Loop358
E8D5 Sub_Loop359
E8DE Sub_Loop360
E8EE Sub_Loop361
E903 Sub_Loop362
E912 Sub_Loop363
E91B Sub_Loop364
E965 Sub_E965
E978 Sub_Loop365
E97C Sub_Loop366
E991 Sub_Loop367
E9AA Sub_Loop368
E9AB Sub_Loop369
E9BC Sub_Loop370
E9BD Sub_Loop371
E9D4 Sub_Loop372
E9E2 Sub_Loop373
E9F2 Sub_Loop374
EA06 Sub_Loop375
EA28 Sub_EA28
EA3F Sub_Loop376
EA50 Sub_Loop377
EA55 Sub_Loop378
EA5C Sub_Loop379
EA67 Sub_Loop380
EA82 Sub_Loop381
EA84 Sub_OnNonzero73
EA85 Sub_Loop382
EA98 Sub_Loop383
EAA6 Sub_Loop384
EAAD SubCEAAD
EB95 Sub_EB95
EB9E Sub_OnNonzero74
EBAE Sub_Loop385
EBAF SubCEBAF
EBCC Sub_Loop386
EC17 Sub_Loop387
EC18 SubCEC18
EC6B Sub_Loop388
EC9A Sub_EC9A
EC9C Sub_OnNonzero75
ECB6 Sub_Loop389
ECCF Sub_Loop390
ECDC SubCECDC
ECDF SubCECDF
ECE9 Sub_Loop391
ECF2 Sub_Loop392
F7E6 Sub_F7E6
F7E8 Sub_OnNonzero76
F7FF Sub_Loop393
F837 SubCF837
F864 SubCF864
F879 Sub_Loop394
F88D Sub_Loop395
F89E Sub_Loop396
F8A4 Sub_F8A4
F8BB Sub_F8BB
F8CD Sub_F8CD
F8D8 SubCF8D8
F8E7 Sub_F8E7
F901 Sub_Loop397
F922 Sub_F922
F92A Sub_Loop398
F93C Sub_Loop399
F953 Sub_Loop400
F967 Sub_Loop401
F96D Sub_Loop402
F974 Sub_Loop403
F9F3 Sub_F9F3
F9FD Sub_OnNonzero77
FA09 Sub_Loop404
FA51 Sub_FA51
FA57 Sub_FA57
FA63 Sub_Loop405
FA89 Sub_FA89
FA8D Sub_OnNonnegative5
FAA8 Sub_FAA8
FAAE Sub_Loop406
FAAF Sub_FAAF
FAC7 Sub_FAC7
FAD2 Sub_Loop407
FAE6 Sub_FAE6
FB1A Sub_FB1A
FB2A Sub_Loop408
FB33 Sub_Loop409
FB34 Sub_Loop410
FB3D Sub_Loop411
FB49 Sub_Loop412
FB81 Sub_Loop413
FB9E Sub_Loop414
FBAF Sub_Loop415
FBB7 Sub_Loop416
FBC0 Sub_FBC0
FBDA Sub_Loop417
FBF6 Sub_Loop418
FBF7 Sub_Loop419
FBF9 Sub_FBF9
FC08 Sub_Loop420
FC09 Sub_Loop421
FC16 Sub_Loop422
FC19 Sub_Loop423
FC28 Sub_Loop424
FC37 Sub_Loop425
FC46 Sub_Loop426
Reference in new issue View Git Blame Copy Permalink