tmerritt/disasm
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
691b2bc23ca267436de0dcc424e42f65d4b2f5d8
disasm/NROM/Mario Bros (JU)/routinemap.tsv
T
tmerrittandClaude Opus 4.8 49e117bfcc Fix Pass 3 symbol application and add promotion criteria to PROMPTS.md 
- Apply symbols.inc hardware register names to Defender 2 (U) (51 operands)
- Apply symbols.inc hardware register names to Donkey Kong 3 (JUE) (36 operands)
- Add APU register symbols (-) to Defender 2 (U) and Donkey Kong 3 (JUE) symbols.inc
- Apply symbols to Donkey Kong Jr. Math (U) (80 operands: 11 single + 69 hardware)
- Apply symbols to Excitebike (JU) (786 operands: 785 single + 1 hardware)
- Add promotion criteria to PROMPTS.md: symbol/local substitution,
  ROM-specific semantic naming, and verification checklist

Add branch/jump target naming requirement to PROMPTS.md

All branches and jumps must target symbolic labels with descriptive names
derived from program flow role (e.g., _Loop, _Next, _Done, _Store, _Return),
never raw address literals. Adds criterion 8 to verification checklist.

Rename all OVERVIEW.md to README.md; add root README content to top-level

- Rename all OVERVIEW.md files to README.md throughout the repo (47 files)
- Prepend README.md content to top-level OVERVIEW.md before rename
- Fix apply_symbols.py NAME_RE regex to handle spaced assignments
- Apply symbols.inc to Defender 2 (U) (51 hardware operands)
- Apply symbols.inc to Donkey Kong 3 (JUE) (36 hardware operands)
- Apply symbols.inc to Donkey Kong Jr. Math (U) (80 operands: 11 single + 69 hardware)
- Apply symbols.inc to Excitebike (JU) (786 operands: 785 single + 1 hardware)
- Add missing Zp18/FrameCounter aliases to Excitebike prg.s
- Build all 27 top-level projects: byte-identical

Promote Donkey Kong Jr. Math back to _wip tier

Moves code from `copilot` folder and verifies each builds after

Add pre-commit hook for byte-identical verification

Add .git/hooks/pre-commit that runs 'make' then 'make clean' in each
project directory before committing. This ensures every project builds
byte-identical before any commit is accepted.

Also includes all file moves from the Donkey Kong Jr. Math (U) demotion
and other file restructuring from the session.

moves code out of copilot folder, its all AI generated.
Moves NROM games into NROM folder

removes copilot folder from Lunar Pool
Adds makefile to build all projects recursively

Updates docs to reflect changes in layout

Repromotes Donkey Kong Jr Math
Repromotes Excitebike
Promotes Popeye (JU) (PRG 1)
Updates Makefile to provide summary of build failure/success

Promote Raid on Bungeling Bay (U): Pass 2/3 partial, whole-ROM byte-identical

Move _wip/NROM/Raid on Bungeling Bay (U) to NROM/ and switch the build
from a PRG-only compare to a whole-ROM one:

  - header.s/chr.s added (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000, $0010) and CHR ($0000, $2000)
    areas ahead of PRG ($C000, $4000)
  - rom.nes symlink to the space-containing original ROM name
  - Makefile builds header.o/prg.o/chr.o into reconstructed.nes and
    compares it against rom.nes ('Byte-identical ROM verified.')
  - one leftover neutral indirect operand jmp (Zp01) at $E2EC becomes
    jmp (IndDispatch01); apply_symbols.py reports 0 substitutions pending

README.md / TODO.md / AGENTS.md updated: 29 promoted, 7 in _wip/.

Pac-Man (U): Pass 2 complete (label renaming) + Pass 3 partial (ZP aliases, table names)

Pass 2 — fresh map derived from the committed split, not from any drafted
map (the drafted maps in other projects were audited and found not
applicable):

  - all 194 address-derived Label_XXXX definitions renamed to semantic
    routine-entry names plus <Routine>_<Role>_<addr> internal branch
    targets; zero Label_ remains
  - all 49 jsr/jmp call sites resolved from raw $XXXX to labels; zero
    raw $XXXX call operands remain
  - routinemap.tsv / derived_names.tsv record the derivation

Pass 3 (partial):

  - 15 proven semantic zero-page aliases added to locals.inc
    (GameState, NmiFlag, ScrollX/Y, PpuCtrlShadow, OamDmaPage,
    CocktailModeFlag, ActivePlayerFlag, GameplaySuspended, FrameCounter,
    StateTimer, Player1/2Input, ActiveInput, CopyrightVerified)
  - 112 operands substituted into prg.s (11 single + 101 hardware)
  - key data tables named: ProgrammerSig ($C0EB), GameStateDispatchTable
    ($C253), TitleScreenData ($C2FD), EntityPtrTable ($D912),
    AudioCommandTable ($EFDD)

Also corrects the README's claim that the RESET vector points at padding:
$FF00 holds real boot code (sei/cld, PPU off, double vblank wait, then
jmp ColdStart at $C042).

.gitignore: ignore reconstructed_prg.bin (build artifact of the _wip
Makefiles; '**/reconstructed.*' does not match the underscore form).

Promote Pac-Man (U): Pass 2/3 complete, whole-ROM byte-identical

Move _wip/NROM/Pac-Man (U) to NROM/ and switch the build from a PRG-only
compare to a whole-ROM one:

  - header.s/chr.s added (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000, $0010) and CHR ($0000, $2000)
    areas ahead of PRG ($C000, $4000)
  - rom.nes symlink to 'Pac-Man (U) [!].nes' (the original ROM name
    contains a space and brackets)
  - Makefile builds header.o/prg.o/chr.o into reconstructed.nes and
    compares it against rom.nes
  - reconstructed.nes is 24,592 bytes, MD5 a69d310f8cae9397fbd39f204672b5c7
    - equal to the original ROM; the header/prg/chr splits were checked
    against the original before promotion and are byte-exact

Pass 3 residue closed.  The last 7 multi-alias zero-page operands are
resolved per site through a new sites.tsv, each proven from context
rather than guessed:

  - jmp ($0010) at $C250/$D3CA/$D90F/$D9B6 -> (DispatchPtrLo); each
    is immediately preceded by sta DispatchPtrLo/sta DispatchPtrHi
  - jmp ($00FE) at $EFDA -> (AudioHandlerPtrLo); preceded by
    sta AudioHandlerPtrLo/sta AudioHandlerPtrHi
  - sta a:$0000,y at $C048/$C089 -> a:Zp00,y; the literal zero-page
    base in the two ZP clear loops, so the neutral name is used rather
    than the semantic WorkPtrLo.  The 'a:' prefix survives the
    substitution, so the bytes stay 99 00 00 (sta abs,Y)

apply_symbols.py now reports 119 operands substituted (101 hardware,
11 single-name, 7 site) and 0 residue.

New tool _tools/align_audit_comments.py: re-aligns the audit comment to
column 35 after a substitution lengthens an operand (nesdis.py pads each
instruction to 31 characters).  Whitespace-only, so the byte identity
cannot change.  405 lines re-aligned in this project; all 2,387 audit
comments still match prg.bin at the stated PRG offset, 0 mismatches.

Docs: root README.md / TODO.md / AGENTS.md updated - 30 promoted, 6 in
_wip/; a per-project detail entry for Pac-Man (U) added; the stale
'Donkey Kong 3 (JUE) has no README.md' claim corrected (it has a
318-line one).

Promote Raid on Bungeling Bay (U) [a2]: Pass 3 complete, whole-ROM byte-identical

Move _wip/NROM/Raid on Bungeling Bay (U) [a2] to NROM/ and switch the build
from a PRG-only compare to a whole-ROM one:

  - header.s/chr.s added (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000, $0010) and CHR ($0000, $2000)
    areas ahead of PRG ($C000, $4000)
  - rom.nes symlink to 'Raid on Bungeling Bay (U) [a2].nes' (the original
    ROM name contains spaces and brackets)
  - reconstructed.nes is 24,592 bytes, MD5 659d340a1e9d420eee28df13319b0094
    - equal to the original ROM; the header/prg/chr splits were checked
    against the original before promotion and are byte-exact

Pass 3 - 15 semantic zero-page aliases, each applied only at the sites
where its role is proven:

  - PpuCtrlShadow ($C2), 15 sites: the reset entry primes it right after
    'sta PPUCTRL', and every other use is an ora/and/eor followed by
    'sta PPUCTRL'
  - NmiPathSelector ($C4), 5 sites: written 1 at $C3E9 and 0 at $C962
  - GameState ($D6), 6 sites: 'cmp #$02' and used as an index at $C4C7
  - FrameSubCounter ($55), 6 sites: set to $0A at $C520, decremented per
    NMI at $C07B
  - PrngPeriodCounter ($EA) / PrngSeedB ($EB) / PrngState ($EC), 13 sites:
    the PRNG state
  - PtrLo ($00) / PtrHi ($01), 8 sites: the 16-bit pair $1C13 and $1610
    compared at $E785/$E791
  - IndDispatch01 ($01) / IndDispatch02 ($02), 3 sites: the computed
    dispatch at $E2EC
  - IndDispatch1B ($1B) / IndDispatch1C ($1C), 6 sites: the dispatch at
    $E7A3
  - IndDispatch17 ($17) / IndDispatch19 ($19): the dispatches at $E79D
    and $E7A0

Addresses that carry two names keep the neutral ZpXX name where the other
role applies - $01 is PtrHi at the 16-bit compare and IndDispatch01 at the
dispatch; $17 is IndDispatch17 at the dispatch and Zp17 for the absolute
RAM $0017 store in the copy loop at $E895/$E8D0.

New tool _tools/apply_zp_aliases.py does the per-site substitution:
apply_symbols.py only rewrites *numeric* operands, so it cannot rename an
operand that is already written as a neutral ZpXX name.  The tool keeps the
ca65 'a:' prefix (dropping it would turn 'sta a:Zp17,y' into a zero-page
store and change the bytes) and rewrites only the operand token, so the
audit comment survives byte for byte.

Naming correction in the promoted sibling.  Finishing this dump showed that
$EA was misnamed 'VBlankWaitCounter': the routine at $C412 is the game's
pseudo-random generator (the classic eor/asl/php/lsr/plp/rol scrambler,
called from thirteen gameplay sites, twice in a row at $CDF4/$CDF9 with the
second result masked #$07), so $EA is the scrambler's phase counter.
Renamed PrngPeriodCounter in both dumps and named $EB/$EC PrngSeedB /
PrngState.  The sibling's two 'sta a:IndDispatch17,y' operands were also
wrong - they are absolute stores to RAM $0017, not the dispatch pointer -
and are now 'a:Zp17,y', matching the file's 'a:' = absolute convention.

Audit-comment alignment re-done with _tools/align_audit_comments.py (1,040
lines here, 1,080 in the sibling).  Both files still match prg.bin at every
stated PRG offset: 5,467 and 5,483 audit comments, 0 mismatches.

Docs: root README.md / TODO.md / AGENTS.md updated - 31 promoted, 5 in
_wip/; per-project detail entries added for both Raid dumps.

Promote Pac-Man (Tengen) (U): Pass 2/3 from scratch, whole-ROM byte-identical

Move _wip/NROM/Pac-Man (Tengen) (U) to NROM/ and switch the build from a
PRG-only compare to a whole-ROM one:

  - header.s/chr.s added (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000, $0010) and CHR ($0000, $2000)
    areas ahead of PRG ($C000, $4000)
  - rom.nes symlink to 'Pac-Man (Tengen) (U) [!].nes'
  - reconstructed.nes is 24,592 bytes, MD5 d34e7a74d8d2c231b6cc601210e28ad0
    - equal to the original ROM; the header/prg/chr splits were checked
    against the original before promotion and are byte-exact

Disassembled from scratch.  No name, map or file was carried over from the
sibling 'Pac-Man (U)' dump; the map was derived from this dump's own
committed split and the two were only compared afterwards.

Pass 2 (new tool _tools/apply_pass2_map.py):
  - all 194 Label_XXXX definitions renamed to semantic routine entries plus
    <Routine>_<Role> branch targets; zero Label_ remains
  - all 48 raw $XXXX jsr/jmp operands resolved to labels; zero raw $XXXX
    call or branch operands remain
  - the map is in routinemap.tsv

Pass 3:
  - 30 semantic zero-page aliases, each applied only at the sites where its
    role is proven (per-site choice in sites.tsv; the addresses that carry
    two roles keep the neutral ZpXX name elsewhere).  _tools/
    derive_zp_aliases.py records how the set was derived, and locals.inc
    records the reason for every remaining neutral slot
  - 28 data tables named (new tool _tools/name_data_region.py), including
    CharacterDataTable ($C66A) and CharacterNameStrings ($C67E), where the
    ROM itself names Blinky, Pinky, Inky and Clyde - which is why the four
    indexed entities are called ghosts and not 'actors'
  - apply_symbols.py reports 0 substitutions pending and 0 residue
  - audit-comment alignment re-done with _tools/align_audit_comments.py;
    all 2,479 audit comments still match prg.bin at the stated PRG offset

Pass 1 correction - six command handlers recovered (new tool
_tools/recode_region.py).  ScriptCommandTable ($EFDD) is read by the traced
instruction at $EFCC, and six of its entries point at $F00A, $F022, $F03A,
$F052, $F062 and $F072 - all of which the tracer had left as data, and two
of which it had mis-split across the 'jmp $EF61' at $F01F and $F04F.
Those 120 bytes are code here, decoded straight from the ROM; the six
handlers tile $F00A-$F081 exactly.  The same gap exists in the promoted
'Pac-Man (U)' dump, which has not been corrected - recorded in both READMEs.

Residue (documented, not guessed): the unreached main game logic at
$C45A-$C55F is still .byte data.  It is code - the tracer's own decoder
walks it cleanly and the dispatch table at $C511 points into it - but
nothing reaches it, so it cannot be entered without a guess.  The same gap
exists in the promoted 'Pac-Man (U)' dump.  Re-deriving it is a Pass 1 job;
a Mesen Code Data Logger capture is the tool the repo uses for it.

Docs: root README.md / TODO.md / AGENTS.md updated - 32 promoted, 4 in
_wip/; a per-project detail entry added for the Tengen dump.

Promote Pyramid (U): Pass 1 corrected, Pass 2/3 complete, whole-ROM byte-identical

Move _wip/NROM/Pyramid (U) to NROM/ and switch the build from a PRG-only
compare to a whole-ROM one:

  - header.s/chr.s added (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000, $0010) and CHR ($0000, $2000)
    areas ahead of PRG ($C000, $4000)
  - rom.nes symlink to 'Pyramid (U) (Sachen).nes'
  - reconstructed.nes is 24,592 bytes, MD5 aa285ff17f25dd05da5996b7466c59e2
    - equal to the original ROM; the header/prg/chr splits were checked
    against the original before promotion and are byte-exact

Pass 1 correction - the committed split was a strict subset of the correct
one.  This game dispatches through 'jmp' trampoline tables that live
*inside* the data regions, and the tracer cannot follow a jmp there, so
828 bytes of code were still marked as data.  Four such tables were found
($C01E 3 entries, $C02A 6, $C042 2, $C054 5) plus ten more entries at
$C000-$C01B; all sixteen targets decode as valid instructions.  Seeding
them, the $C800 boot mainline and six further code starts recovers the
whole lot, plus a five-byte stub at $DF89 (lda $33 / jmp $DECB) that sat
in a hole between two routines.  The re-trace loses NO committed code byte
and takes the split from 34.5% to 39.6% (3,130 instructions / 6,493 code
bytes).  'make regen' reproduces it, so the split stays verifiable.

Pass 2 - a fresh map derived from this dump's own committed split:
  - 428 Label_XXXX definitions renamed; zero Label_ residue
  - 320 raw $XXXX jsr/jmp operands resolved; zero raw $XXXX branch
    operands remain
  - 431 routine entries and the 32 data blocks named from the code
  - the internal branch-target names are derived mechanically from the
    branch that reaches them by the new _tools/derive_branch_names.py
    (beq -> OnZero, bne -> OnNonzero, bcc/bcs -> the carry cases, a
    backwards branch -> Loop)
  - recorded in routinemap.tsv

Pass 3:
  - 24 semantic zero-page aliases, each applied only where its role is
    proven; the 57 slots that stay neutral are each listed with the reason
    in locals.inc (the neutral set lives in zp_aliases.inc so that
    'make regen' can rebuild locals.inc from prg.bin)
  - 32 data tables named - TaskVectorTable1/2, LevelScriptData,
    MusicPeriodTable, SoundEnvelopeTable, the actor tables - recorded in
    data_region_names.tsv
  - apply_symbols.py reports 0 substitutions pending and 0 residue; no
    hardware register is left as a raw literal
  - the audit comments are now canonical on every line, data included
    (the old file carried only 'PRG:$xxxx' on its 1,358 data lines);
    all 3,762 audit comments match prg.bin at their stated PRG offset

Kept as-is, not 'cleaned up':
  - sta $4100 stays a raw operand.  The iNES header claims mapper 0 but
    the boot code writes past the NES register space; the ROM does not
    explain it, so it is recorded rather than guessed
  - the 'A'/'V' check on RAM $0120/$0121 and its seed/clear routines
    are named for what they do, not for what they are for
  - the ninth entry of the $C3A6 task vector table ($D820) is a junk
    slot and stays data

Docs: root README.md / TODO.md / AGENTS.md updated - 33 promoted, 3 in
_wip/; a per-project detail entry added.

Hogan's Alley (JU): Pass 1 correction, Pass 2, Pass 3, promoted to NROM/

The light-gun game whose engine dispatches through *inline* tables:
`IndirectCall` at $C34D pops the return address of the `jsr` that called
it and reads a 16-bit handler pointer from the word that follows, so all
six handler tables ($C124 19 entries, $C219 4, $C89C 14, $CDD1 1, $D234 2,
$D3D6 14) live inside the code stream and the static tracer cannot follow
them.

Pass 1 correction.  The committed split was a strict subset of the correct
one -- 41.8% of the PRG was classified as code.  A fresh Mesen Code Data
Logger capture was merged with the four captures already in the folder
(hogans_merged.cdl, the OR of five per-byte flag arrays, 6,544 code bytes)
and _tools/cdl_reclass.py rewrote the split to match what the CPU actually
fetched: 1,216 bytes moved from data to code, five the other way, 59 labels
emitted.  The split is now 49.1% code (3,950 instructions, 8,041 bytes).
The four branch targets the reclassifier could not prove were turned into
labels by the new _tools/resolve_raw_branches.py.

Pass 2.  206 routine entries hand-named from this dump's own code and 413
internal branch targets derived mechanically by _tools/derive_branch_names.py:
630 Label_XXXX definitions gone, 484 raw $XXXX call operands resolved, 15
call targets the tracer had never labelled given a label.  Recorded in
routinemap.tsv.  No SubC<addr> residue was needed -- every entry the engine
reaches is named after what it does.

Pass 3.  60 semantic zero-page aliases, each applied only where its role is
proven (zp_aliases.inc, zp_alias_sites.tsv); the slots that stay neutral are
each listed with the reason.  All 34 data blocks named
(data_region_names.tsv).  apply_symbols.py reports 1 residue: `sta a:$00B4,y`
at $C203, the same address as Zp40/ActorPalette but forced to absolute
addressing, so it must stay numeric.

Promotion.  header.s, chr.s and a HEADER/PRG/CHR linker.cfg added, rom.nes
symlinked to the original ROM; the whole-ROM cmp passes on the first
promoted build.  There is deliberately no `make regen` target: the Pass 1
split here is the static trace corrected by a CDL capture, and the base the
correction was applied to is not what the current _tools/nesdis.py
produces, so prg.s is the maintained source of truth.

Tools changed:
  nesdis.py             --split/--note/--provenance options, so a data
                          region can carry its own name and explanation;
                          a forced-data address is no longer reported as a
                          recovered routine entry
  apply_pass2_map.py    can create the label for a call target the tracer
                          left unlabelled; no longer double-labels it
  apply_zp_aliases.py   --at-file, an address-based per-site list
  derive_branch_names.py keeps the map's own header instead of writing a
                          fixed one
  resolve_raw_branches.py  new: turns `bXX *+$NN` operands into labels
  build_hogans_map.py   new: the hand-written Pass 2 map builder

The existing regen pipelines (MUSCLE (U), Urban Champion (JU)) still
reproduce prg.s byte for byte.

Apply the symbols.inc register names at Pass 1; fix a dropped byte in cdl_reclass

nesdis.py now names the hardware registers as it renders the operands, so a
project's Pass 1 output already reads `lda PPUSTATUS` instead of `lda $2002`
and the Pass 3 apply_symbols.py step has nothing left to do for them.

  * nesdis.py --symbols FILE reads a symbols.inc-style file and substitutes
    the register names.  Only unambiguous entries in the $2000-$4017 window
    are used: $4017 is both JOY2 and APUFRAMECOUNTER, so it stays numeric
    and apply_symbols.py reports it as multi-alias residue, exactly as
    before.  The default is the symbols.inc next to --out, so a new project
    gets the names without asking; --no-symbols opts out.
  * The renderer records the operand's numeric value on the Insn, because
    operand_value() used to re-parse the operand text and could no longer
    read a name.
  * The controller bit masks in symbols.inc (PAD_A and friends) are
    constants, not addresses, and are still never substituted.

MUSCLE (U) and Urban Champion (JU) keep --no-symbols: their committed
prg.s was produced with the registers named by the Pass 3 apply_symbols.py
step, and the columns in those files reflect the in-place substitution.
Adding the missing apply_symbols.py step to both regen pipelines makes
them reproduce their committed prg.s byte for byte again - neither did
before this change (MUSCLE was 440 lines out, Urban Champion 772).

cdl_reclass.py had a bug that cost a byte: a region whose last source row
straddled the region's end was replaced by a regeneration of the region
only, so the tail of that row was dropped.  Mario Bros (JU) hit it at
$C595, where the rebuild came out one byte short and every label after it
shifted.  A region now covers the whole rows it replaces.

pass2.py reflow takes an optional column argument; the default is
unchanged (the ';' lands on the same column as before).

Mario Bros (JU): Pass 1 correction, Pass 2, Pass 3, promoted to NROM/

A two-player platformer whose handler tables are *inline*: the pointers sit
in the middle of the code stream, right after the `jsr` that reads them, so
the static tracer could never follow them.

Pass 1 correction.  The committed split was a strict subset of the correct
one -- only 72.0% of the PRG was classified as code.  A Mesen Code Data
Logger capture of this ROM (mario_mesen.cdl, 10,915 code bytes) showed
1,010 bytes the tracer had left as data were code; two branch targets the
capture never reached ($E4CB and $E639) were forced with --override for 57
more, so 1,067 bytes moved from data to code and 22 moved the other way.
The split is now 78.4% code (6,210 instructions, 12,847 bytes).  The three
branch targets the reclassifier could not prove were turned into labels by
_resolve_raw_branches.py, which now refuses to put a label on a `.byte` row.

Pass 2.  206 routine entries and 519 internal branch targets: 931
Label_XXXX definitions gone, 51 raw $XXXX call operands resolved and 12 call
targets the tracer had never labelled given a label.  Zero SubC residue --
the 185 entries a previous session had left as address-derived residue were
all named from this dump's own code.  Recorded in routinemap.tsv.

Pass 3.  25 semantic zero-page aliases, each applied only where its role is
proven (zp_aliases.inc); the slots that stay neutral are each listed with the
reason.  35 data tables named -- GameStateHandlerTable, EnemyBehaviourTable,
EnemyScriptTable, EnemyTypePointerTable, SoundRoutineTable,
NoteFrequencyTable and the rest -- and recorded in
data_region_names.tsv.  apply_symbols.py reports 0 residue.

Promotion.  header.s, chr.s and a HEADER/PRG/CHR linker.cfg added, rom.nes
symlinked to the original ROM; the whole-ROM cmp passes on the first
promoted build.  There is deliberately no `make regen` target: the Pass 1
split here is the static trace corrected by a CDL capture, and the base the
correction was applied to is not what the current _tools/nesdis.py
produces, so prg.s is the maintained source of truth.

Tools:
  apply_pass2_map.py     renames a label of any spelling -- SubC<addr> is
                          the honest residue form -- and its references
                          follow it; one combined pattern, so a 16,000-line
                          file does not need a substitution per label
  resolve_raw_branches.py refuses to label a data row
  build_mario_map.py      new: the hand-written Pass 2 map builder

Remove the old _wip/NROM/Mario Bros (JU) folder (promoted to NROM/)

Mario Bros (JU): add the promoted-tier header, CHR, rom.nes symlink and zero-page aliases

Moves _ROMS/<ROM> into _wip/<MAPPER>/<ROM>

Sync the docs and the skeleton tool with the 857-project _wip tier

The _wip/ tier now holds 857 projects across 30 mapper folders, all
building byte-identical for the whole ROM.  README.md, TODO.md and
AGENTS.md still described the old 39-project tier, so bring them in line
with WIP.md, which carries the tier's index.

The tier is no longer 39 projects of NROM-256 with a 16/32 KB PRG:
only two projects have a 16 KB PRG, 151 have 32 KB, 523 have 128 KB and
one has 1.5 MB, so most of it is a banked mapper whose image does not fit
the 6502's address space.  Those projects link their MEMORY areas at .nes
file offsets rather than CPU addresses, which is the only option and the
honest model; the 39 older projects keep the CPU-address layout because
their PRG really is one contiguous window.

make_skeleton.py gains the two layouts (--layout flat|cpu), the board
name for the mapper, and a fix for find_rom() mistaking the build
output reconstructed.nes for the source ROM.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-10-20 16:44:06 -04:00

1016 lines
28 KiB
Plaintext
Raw Blame History

# Mario Bros (JU) - Pass 2 name map
#
# Derived from this dump's own committed split (after the 2026-10-20 Code
# Data Logger re-classification). Every name below was read out of the code;
# nothing was carried over from another dump.
#
# Format: <CPU address><TAB><name>
#
# The map starts from every label the committed split already carried - the
# partial Pass 2 a previous session did - so the internal branch targets
# can be attributed to the routine that owns them.
#
# Where a routine's role could not be established from the code, the honest
# address-derived `SubC<addr>` residue form is kept rather than a guess.
#
# The internal branch targets are derived from the branch that reaches them
# by _tools/derive_branch_names.py:
# beq -> OnZero bne -> OnNonzero
# bcc -> OnCarryClear bcs -> OnCarrySet
# bmi -> OnNegative bpl -> OnNonnegative
# bvc -> OnOverflowClear bvs -> OnOverflowSet
# a backwards branch (the target is below the branch) -> Loop
#
# ---- derived internal branch-target names ----
C000 Reset
C002 WaitVblank1
C01D ClearRamPageLoop
C02B ClearRamPageLoop_Loop
C04F ClearFramePending
C05D ClearFramePending_Loop
C060 ClearFramePending_Loop2
C06A EndFrame
C077 EndFrame_Loop
C07D NmiHandler
C0AC NmiHandler_Loop
C0B6 NmiPhaseDispatch
C0BF NmiPhaseDispatch_Loop
C0C2 NmiPhaseDispatch_Loop2
C0F3 NmiPhaseDispatch_Loop3
C12E NmiPhaseDispatch_Loop4
C130 HandleNmiPhase2
C13E HandleNmiPhase2_Loop
C149 NmiPhaseHandlerA
C14F NmiPhaseHandlerA_Loop
C152 NmiPhaseHandlerA_Loop2
C155 NmiPhaseHandlerA_Loop3
C158 NmiPhaseHandlerA_Loop4
C15B NmiPhaseHandlerA_Loop5
C15E NmiPhaseHandlerA_Loop6
C161 NmiPhaseHandlerA_Loop7
C164 NmiPhaseHandlerA_Loop8
C189 NmiPhaseHandlerA_Loop9
C193 NmiPhaseHandlerA_Loop10
C196 HandleNmiPhase3
C19F HandleNmiPhase3_OnNonzero
C1C3 HandleNmiPhase4
C1CE HandleNmiPhase4_Loop
C1EC SetMarioSpriteAttrs
C1FD AdvanceFrameCounter
C212 AdvanceFrameCounter_Loop
C221 AdvanceFrameCounter_Loop2
C22D HandleNmiPhase5
C236 HandleNmiPhase5_OnCarrySet
C23C HandleNmiPhase5_Loop
C24B HandleNmiPhase5_Loop2
C26E HandleNmiPhase5_Loop3
C27B HandleNmiPhase5_OnNonzero
C282 HandleNmiPhase5_Loop4
C286 HandleNmiPhase5_Loop5
C2A7 HandleNmiPhase5_Loop6
C2AD HandleNmiPhase6
C2B6 HandleNmiPhase6_OnCarryClear
C2BC HandleNmiPhase6_Loop
C2CB HandleNmiPhase6_Loop2
C2F3 HandleNmiPhase6_Loop3
C2FF HandleNmiPhase6_OnNonzero
C304 HandleNmiPhase6_Loop4
C308 HandleNmiPhase6_Loop5
C32E HandleNmiPhase6_Loop6
C334 SetMarioSpriteFlip
C35A SetMarioSpriteFlip_Loop
C35B HandleNmiPhase7
C369 HandleNmiPhase7_OnZero
C376 HandleNmiPhase7_Loop
C37A HandleNmiPhase7_Loop2
C37D HandleNmiPhase8
C38B HandleNmiPhase8_OnZero
C399 HandleNmiPhase8_Loop
C39D HandleNmiPhase8_Loop2
C3A0 CheckFrameStarted
C3A8 InitFrameState
C3B9 InitFrameState_Loop
C3C1 InitFrameState_Loop2
C3C2 CheckState97_02
C3D5 CheckState97_02_Loop
C3DC CheckState97_02_Loop2
C3E3 SwapMarioState
C3F5 HideOamPair
C402 SetMarioDirection
C41F GetScrollPosition
C429 GetScrollDelta
C430 SubScrollDelta
C43C SubScrollDelta_Loop
C440 SubScrollDelta_Loop2
C443 SubScrollDelta_Loop3
C446 SetVramPointer
C44A SetVramPointer2
C456 SetVramPointer2_OnNonzero
C46E SetVramPointer2_Loop
C494 SetVramPointer2_Loop2
C4AE SetVramPointer2_Loop3
C4B8 UpdateGameplay
C4D7 UpdateGameplay_Loop
C4D9 UpdateGameplay_OnNonnegative
C4F9 UpdateGameplay_Loop2
C501 UpdateGameplay_Loop3
C507 UpdateGameplay_Loop4
C50B UpdateGameplay_Loop5
C528 UpdateGameplay_Loop6
C543 UpdateGameplay_Loop7
C55C UpdateGameplay_Loop8
C561 UpdateGameplay_Loop9
C568 UpdateGameplay_Loop10
C570 StartEnemyAction
C574 StartEnemyAction_Loop
C57E StartEnemyAction_Loop2
C58E StartEnemyAction_Loop3
C5A3 JsrThunkTable
C5DB InitEnemyScript
C5F8 InitEnemyScript_OnNonzero
C605 InitEnemyScript_Loop
C629 InitEnemyScript_Loop2
C62C InitEnemyScript_Loop3
C636 InitEnemyScript_Loop4
C63F InitEnemyScript_Loop5
C647 InitEnemyScript_Loop6
C657 RunEnemyScript
C65D RunEnemyScriptEnd
C66A ClearEnemyPosition
C66F ClearEnemyPosition_Loop
C686 MoveEnemyDown
C697 MoveEnemyDown_Loop
C6BC MoveEnemyDown_Loop2
C6BF CheckEnemyCollision
C6C9 CheckEnemyCollision_Loop
C6CD CheckEnemyCollision_Loop2
C6E0 CheckEnemyCollision_Loop3
C6E9 CheckEnemyCollision_Loop4
C6FC CheckEnemyCollision_Loop5
C708 ResolveEnemyCollision
C727 ResolveEnemyCollision_Loop
C73B ResolveEnemyCollision_Loop2
C744 ResolveEnemyCollision_Loop3
C747 UpdateEnemyScript
C758 UpdateEnemyScript_Loop
C75A RunEnemyScriptB
C75D RunEnemyScriptC
C770 RunEnemyScriptC_OnZero
C775 RunEnemyScriptC_Loop
C781 RunEnemyScriptC_Loop2
C782 RunEnemyScriptC_Loop3
C785 CheckEnemyType30
C792 CheckEnemyType30_Loop
C797 CheckEnemyType30_Loop2
C7B3 CheckEnemyType30_Loop3
C7B7 CheckEnemyType30_Loop4
C7C7 CheckEnemyType30_Loop5
C7CA CheckEnemyType30_Loop6
C7CD DispatchEnemyBehaviour
C7DA DispatchEnemyBehaviour_Loop
C7DE DispatchEnemyBehaviour_Loop2
C7EA DispatchEnemyBehaviour_Loop3
C7F3 DispatchEnemyBehaviour_Loop4
C7F9 DispatchEnemyBehaviour_Loop5
C824 DispatchEnemyBehaviour_Loop6
C853 DispatchEnemyBehaviour_Loop7
C86C DispatchEnemyBehaviour_Loop8
C86F DispatchEnemyBehaviour_Loop9
C881 DispatchEnemyBehaviour_Loop10
C883 DispatchEnemyBehaviour_Loop11
C884 ClearEnemyFlag
C891 ClearEnemyFlag_Loop
C895 ClearEnemyFlag_OnZero
C8A4 ClearEnemyFlag_Loop2
C8AD ClearEnemyFlag_Loop3
C8B5 SetEnemyStateFromScroll
C8B7 SetEnemyState
C8C7 SetEnemyState_Loop
C8CF SetEnemyState_Loop2
C8D1 DispatchEnemyBehaviourB
C8D7 HandleEnemyBehaviour
C8DE HandleEnemyBehaviour_Loop
C8E4 HandleEnemyBehaviour_Loop2
C8F1 HandleEnemyBehaviour_Loop3
C8F4 DispatchEnemyBehaviourC
C90A DispatchEnemyBehaviourC_Loop
C916 DispatchEnemyBehaviourC_Loop2
C917 DispatchEnemyBehaviourC_Loop3
C91C DispatchEnemyBehaviourC_Loop4
C91D DispatchEnemyBehaviourC_Loop5
C92C DispatchEnemyBehaviourC_Loop6
C936 DispatchEnemyBehaviourC_Loop7
C939 DispatchEnemyBehaviourC_Loop8
C93A CheckEnemyScriptCommand
C954 CheckEnemyScriptCommand_Loop
C959 CheckEnemyScriptCommand_Loop2
C96F CheckEnemyScriptCommand_Loop3
C973 CheckEnemyScriptCommand_Loop4
C97D HandleEnemyCommand30
C98E HandleEnemyCommand30_Loop
C992 SetEnemyScrollTarget
C99E SetEnemyScrollTarget_Loop
C9A1 ReadEnemyTileIndex
C9BD ReadEnemyTileIndex_Loop
C9CB ClearEnemyTileFlags
C9D1 ClearEnemyTileFlags_OnZero
C9D2 ClearEnemyTileFlags_Loop
C9DB AdvanceEnemyTileIndex
C9DD AddEnemyTileIndex
C9E6 DispatchEnemyBehaviourD
C9F1 DispatchEnemyBehaviourD_Loop
C9F8 DispatchEnemyBehaviourD_Loop2
C9FE DispatchEnemyBehaviourE
CA0C DispatchEnemyBehaviourE_Loop
CA15 DispatchEnemyBehaviourE_Loop2
CA18 DispatchEnemyBehaviourE_Loop3
CA1B InitVramAddress
CA20 SetVramAddress2400
CA22 SetVramAddress2400B
CA2B SetVramAddressF400
CA35 SetVramAddressF400_OnNonzero
CA3B DrawTileRow
CA5E DrawTileRow_Loop
CA65 DrawTileRow_OnZero
CA66 DrawTileRow2
CA73 DrawTileRow2_Loop
CA77 DrawTileRow2_Loop2
CA7D ComputeTileOffset
CAA4 CheckRangeReturn012
CAB3 CheckRangeReturn012_Loop
CAB6 CheckRangeReturn012_Loop2
CAB9 DispatchTableF393
CACC AdvanceScriptCounter
CADE AdvanceScriptCounter_Loop
CAEB CheckZpB3Return
CAF2 CheckZpB3Return_Loop
CAF7 UpdateEnemyScroll
CB08 UpdateEnemyScroll_Loop
CB18 UpdateEnemyScroll_OnNonzero
CB29 UpdateEnemyScroll_Loop2
CB38 UpdateEnemyScroll_OnCarrySet
CB40 UpdateEnemyScroll_Loop3
CB48 CopyOamRow
CB4F CopyOamRow_Loop
CB50 CopyOamBytes
CB58 UpdateOamShadow
CB65 UpdateOamShadow_Loop
CB6A UpdateOamShadow_OnNonzero
CB84 UpdateOamShadow_Loop2
CB85 SetupScriptPointer
CB9B SetupScriptPointerA
CB9E SetupScriptPointerA_OnNonzero
CBAE AdvanceScriptPointer
CBB6 SetupScriptPointerB
CBB9 SetupScriptPointerB_OnNonzero
CBC3 SetupScriptPointerB_OnZero
CBC4 SetScriptTableBase
CBDD SetScriptTableBase_OnNonzero
CBE4 SetScriptTableBase_Loop
CBE9 SetScriptTableBase_Loop2
CC0D SetScriptTableBase_Loop3
CC13 SetScriptTableBase_Loop4
CC1D SetScriptTableBase_Loop5
CC22 ReadScriptRecord
CC29 DispatchScriptCommand
CC3F CheckEnemyTileRange
CC4C CheckEnemyTileRange_Loop
CC54 CheckEnemyTileRange_Loop2
CC5F CheckEnemyTileRange_Loop3
CC73 AddEnemyTileOffset
CC84 AddEnemyTileOffset_Loop
CC8F AddEnemyTileOffset_Loop2
CCA0 PushTablePointerDispatch
CCC2 PushTablePointerDispatch_Loop
CCC5 ReadControllerPort
CCD3 ReadControllerBits
CCD5 ReadControllerBits_OnNonzero
CCFE ReadControllerBits_Loop
CCFF DrawHudRow
CD1B DrawHudRow_OnNonzero
CD2A DrawHudRow_OnNonzero2
CD34 DrawHudRow_Loop
CD42 DrawHudRow_Loop2
CD43 UpdatePpuCtrl
CD52 UpdatePpuCtrl_OnNonzero
CD68 UpdatePpuCtrl_OnNonzero2
CD81 UpdatePpuCtrl_OnNonzero3
CD88 DecFrameCounter
CD94 DecFrameCounter_OnNonnegative
CD9A DecFrameCounter_Loop
CD9E DispatchViaStackPointer
CDB4 AdvanceDispatchPointer
CDC4 AdvanceDispatchPointer_OnNonzero
CDDA AdvanceDispatchPointer_Loop
CDE6 AdvanceDispatchPointer_Loop2
CDE9 AdvanceDispatchPointer_OnNonzero2
CDEC AdvanceDispatchPointer_Loop3
CE00 WriteVramList
CE09 SetScroll
CE16 CopyBlockToVram
CE18 CopyByteBlock
CE23 CopyByteBlock_OnNonzero
CE2C ReturnOne
CE43 ReturnOne_OnNonzero
CE5A ReturnOne_OnNonzero2
CE84 NextIndex
CE86 ClampTileIndex
CE94 ClampTileIndex_Loop
CE95 CheckMarioFacing
CE9C LoadEnemyTileIndex
CEA3 LoadYFromZpB4
CEB1 LoadYFromZpB4_Loop
CEBA ResetActorState
CEC3 InitEnemyScriptBlock
CED9 InitEnemyScriptBlock_OnNonzero
CEEF InitEnemyScriptBlock_Loop
CF04 InitEnemyScriptBlock_Loop2
CF12 InitEnemyScriptBlock_OnNonzero2
CF19 InitEnemyScriptBlock_Loop3
CF25 InitEnemyScriptBlock_OnNonzero3
CF2C InitEnemyScriptBlock_Loop4
CF3B InitEnemyScriptBlock_Loop5
CF48 InitEnemyScriptBlock_Loop6
CF53 InitEnemyScriptBlock_Loop7
CF5B InitEnemyScriptBlock_Loop8
CF67 CheckEnemySpawnFree
CF83 CheckEnemySpawnFree_Loop
CF88 CheckEnemySpawnFree_Loop2
CF89 CheckEnemySpawnFree_Loop3
CF8B CheckEnemySpawnFree_OnCarryClear
CF9E CheckEnemySpawnFree_OnZero
CFA7 CheckEnemySpawnFree_Loop4
CFA8 CheckEnemySpawnFree_Loop5
CFB6 CheckEnemySpawnFree_Loop6
CFC4 CheckEnemySpawnFree_Loop7
CFC6 CheckEnemySpawnFree_Loop8
CFCA ComputeSpriteOffset
D019 CheckEnemyTileRangeB
D02C CheckEnemyTileRangeB_Loop
D02F DrawScoreDigit
D03F NextScoreDigit
D083 NextScoreDigit_OnNonzero
D0A2 NextScoreDigit_Loop
D0B3 NextScoreDigit_Loop2
D0B4 ComputeSpriteOffsetB
D0C1 ComputeSpriteOffsetB_OnZero
D0E4 ComputeSpriteOffsetB_Loop
D0E8 ComputeSpriteOffsetB_Loop2
D116 ComputeSpriteOffsetB_Loop3
D11C ComputeSpriteOffsetB_Loop4
D138 ComputeSpriteOffsetB_Loop5
D139 AddDecimalDigit
D144 AddDecimalDigit_Loop
D151 AddDecimalDigit_OnCarrySet
D155 AddDecimalDigit_Loop2
D15A AdjustDecimalColumns
D16D AdjustDecimalColumns_Loop
D179 AdjustDecimalColumns_Loop2
D17C SplitDecimalByte
D18B SetVramColumn
D1A0 SetVramColumn_OnNonnegative
D1A9 SetVramColumn_OnZero
D1CF SetVramColumn_OnNonzero
D1D4 SetVramColumn_OnCarryClear
D1E9 SetVramColumn_Loop
D1F5 SetVramColumn_Loop2
D1F6 SetVramColumn_Loop3
D1FA SetVramColumn_Loop4
D1FF SetVramColumn_Loop5
D202 SelectEnemyFrame
D20F SelectEnemyFrame_Loop
D217 SelectEnemyFrame_Loop2
D218 SelectEnemyFrame_Loop3
D251 SelectEnemyFrame_Loop4
D257 SelectEnemyFrame_Loop5
D25B SelectEnemyFrame_Loop6
D25F SelectEnemyFrame_Loop7
D26A SelectEnemyFrame_OnNonzero
D277 SelectEnemyFrame_Loop8
D27F ReadActorPointerTable
D297 ReadActorPointerTable_Loop
D2C7 ReadActorPointerTable_Loop2
D2D0 ReadActorPointerTable_Loop3
D2DF CheckEnemyActive
D2E4 CheckEnemyActive_Loop
D2E9 CheckEnemyActive_Loop2
D301 CheckMarioAlive
D306 CheckMarioAlive_Loop
D30B CheckMarioAlive_Loop2
D31F CheckMarioAlive_Loop3
D328 TestRamFlagPair0500
D33A TestRamFlagPair0500_Loop
D34A ResetRoundState
D36D ResetRoundState_Loop
D37D SetEnemySpawnParams
D381 SetEnemySpawnParams_Loop
D38F SetEnemySpawnParams_OnNonnegative
D39F SetEnemySpawnParams_Loop2
D3A7 SetEnemySpawnParams_OnNonzero
D3C6 SetEnemySpawnParams_OnNonnegative2
D3EA SetEnemySpawnParams_OnNonzero2
D3ED SetEnemySpawnParams_Loop3
D3F5 SetEnemySpawnParams_Loop4
D3F9 UpdateOamSprites
D40B SetHudVramAddress
D440 SetHudVramAddress_Loop
D444 SetHudVramAddress_Loop2
D450 SetHudVramAddress_Loop3
D451 DispatchGameState
D459 DispatchGameState_Loop
D46F DispatchGameState_Loop2
D471 DispatchGameState_OnNonnegative
D47A DispatchGameState_Loop3
D47C ReturnWithoutAction
D47D SetActorFlagOn4B
D48D SetActorFlagOn4B_Loop
D48E SetActorFlagOn4B_Loop2
D4FE ClearActorCounters
D502 ClearActorCounters_OnNonnegative
D508 SetHudVramPointer
D518 SetHudVramPointer_OnNonzero
D51C SetHudVramPointer_OnNonzero2
D53A SetHudVramPointer_Loop
D54A SetHudVramPointer_Loop2
D54F SetHudVramPointer_Loop3
D568 SetHudVramPointer_OnNonnegative
D56E CheckScriptCommand
D588 CheckScriptCommand_Loop
D58B CheckScriptCommand_Loop2
D58C WriteVramAtF4F5
D593 ComputeActorTableOffset
D5BE WriteVramAtF660
D5D5 WriteVramAt
D5DC ResetOamShadow
D5E1 ResetOamShadow_OnZero
D5E5 ReturnFromActorUpdate
D5E6 InitEnemySprites
D5EC InitEnemySpritesB
D5F0 InitEnemySpritesB_Loop
D5FB InitEnemySpritesB_OnNonzero
D5FE InitEnemySpritesB_OnNonzero2
D609 InitEnemySpritesB_Loop2
D60A InitEnemySpritesB_Loop3
D60F CopyHudPalette
D611 CopyHudPalette_OnNonzero
D61D DrawHud
D634 DrawHud_Loop
D63C DrawHud_OnNonnegative
D672 AdvanceHudCounter
D67E AdvanceHudCounter_Loop
D67F ClearSpriteBlock
D68F ClearSpriteBlock_Loop
D69A RunScriptBlockF3BA
D6BA CheckEnemyType
D6E6 CheckEnemyType_Loop
D6F1 CheckEnemyType_Loop2
D6FA CheckEnemyType_Loop3
D701 CheckEnemyType_Loop4
D708 CheckEnemyType_Loop5
D70F CheckEnemyType_OnNonzero
D710 CheckEnemyType_Loop6
D73C CheckEnemySubType
D744 CheckEnemySubType_Loop
D753 CheckEnemySubType_Loop2
D767 CheckEnemySubType_Loop3
D77F CheckEnemySubType_Loop4
D785 CheckEnemySubType_Loop5
D789 SpawnEnemySprites
D792 SpawnEnemySprites_Loop
D797 SpawnEnemySprites_Loop2
D79D SetEnemySpriteFlags
D7AA ReadEnemyPointer
D7C1 ReadEnemyPointer_Loop
D7C2 HandleEnemySubType
D7CE HandleEnemySubType_Loop
D7E0 HandleEnemySubType_OnZero
D7E4 HandleEnemySubType_Loop2
D7FE HandleEnemySubType_Loop3
D80E HandleEnemyCommand
D829 HandleEnemyCommand_Loop
D831 HandleEnemyCommand_Loop2
D84F HandleEnemyCommand_Loop3
D851 CheckEnemyCommandA
D855 HandleEnemyCommandB
D861 HandleEnemyCommandB_Loop
D871 HandleEnemyCommandB_Loop2
D877 SpawnEnemy
D885 HandleEnemyCommandC
D89D HandleEnemyCommandC_Loop
D89E HandleEnemyCommandC_Loop2
D8AF HandleEnemyCommandC_Loop3
D8C0 HandleEnemyCommandC_Loop4
D8C1 HandleEnemyCommandC_Loop5
D8E5 HandleEnemyCommandC_Loop6
D8F1 HandleEnemyCommandC_Loop7
D904 ResetEnemyList
D90D CheckBF_LowNibble
D91A CheckBF_LowNibble_Loop
D927 CheckBF_LowNibble_OnZero
D928 CheckBF_LowNibble_Loop2
D932 CheckBF_LowNibble_OnNonzero
D93C SetMarioDirectionB
D949 SetMarioDirectionB_OnNonzero
D95F SetMarioDirectionB_Loop
D961 SetMarioDirectionB_Loop2
D965 SetMarioDirectionB_Loop3
D968 SetMarioDirectionB_Loop4
D979 ReadEnemyScriptValue
D988 ReadEnemyScriptValue_Loop
D990 ComputeScoreOffset
D99D ComputeScoreOffset_OnZero
D99F ComputeScoreOffset_OnNonzero
D9AD ComputeScoreOffset_Loop
D9B6 FindFreeEnemySlot
D9B7 FindFreeActorSlot
D9C5 FindFreeEnemySlotBack
D9C9 FindFreeActorSlotBack
D9D4 FindFreeActorSlotBack_Loop
D9E0 ReadEnemyPointerB
D9EA SelectEnemyDirection
D9F3 SelectEnemyDirection_Loop
D9FE CheckEnemySpawn
DA09 CheckEnemySpawn_Loop
DA1E CheckEnemySpawn_Loop2
DA1F CheckEnemySpawn_Loop3
DA24 CheckEnemySpawn_Loop4
DA32 CheckEnemySpawn_Loop5
DA3B CheckEnemySpawn_OnCarryClear
DA3C CheckEnemySpawn_Loop6
DA40 CheckEnemySpawn_Loop7
DA46 CheckEnemySpawn_Loop8
DA61 CheckEnemySpawn_Loop9
DA6A CheckEnemySpawn_OnCarrySet
DA6D CheckEnemySpawn_Loop10
DA75 CheckEnemySpawn_Loop11
DA7E UpdateEnemySprite
DAA5 UpdateEnemySprite_Loop
DABA UpdateEnemySprite_Loop2
DAC0 UpdateEnemySprite_Loop3
DAC1 UpdateEnemySprite_Loop4
DAE3 UpdateEnemySprite_Loop5
DAFC UpdateEnemySprite_Loop6
DB18 UpdateEnemySprite_Loop7
DB19 UpdateEnemySprite_Loop8
DB1E AdvanceEnemySpeed
DB2B AdvanceEnemySpeed_Loop
DB2D DecEnemyTimer
DB33 DecEnemyTimer_OnZero
DB34 SelectActorSprite
DB4A SelectActorSprite_Loop
DB53 DecEnemyScriptCounter
DB6A DecEnemyScriptCounter_Loop
DB6B DecEnemyScriptCounter_Loop2
DB73 DecEnemyScriptCounter_Loop3
DBAC DecEnemyScriptCounter_Loop4
DBC6 DecEnemyScriptCounter_Loop5
DBE2 DecEnemyScriptCounter_Loop6
DBFE DecEnemyScriptCounter_Loop7
DBFF CheckEnemySpawnBlocked
DC1F CheckEnemySpawnBlocked_Loop
DC38 FlipEnemySprite
DC3B FlipEnemySprite_Loop
DC44 FlipEnemySprite_Loop2
DC4E FlipEnemySprite_Loop3
DC50 FlipEnemySprite_OnZero
DC55 FlipEnemySprite_Loop4
DC6E FlipEnemySprite_Loop5
DC75 SetEnemyVramPointer
DC86 SetEnemyVramPointer_Loop
DC91 SetEnemyVramPointer_OnNonzero
DC92 SetEnemyVramPointer_Loop2
DCB9 SetEnemyVramPointer_Loop3
DCBC SetEnemyVramPointer_Loop4
DCBF SetEnemyVramPointer_Loop5
DCC2 SetEnemyVramPointer_Loop6
DCCE ResetEnemyListB
DCDC ResetEnemyListB_Loop
DCE5 ResetEnemyListB_Loop2
DCEA InitEnemySpawn
DD11 InitEnemySpawn_Loop
DD2C InitEnemySpawn_Loop2
DD3C InitEnemySpawn_Loop3
DD40 InitEnemySpawn_Loop4
DD5E InitEnemySpawn_Loop5
DD65 InitEnemySpawn_Loop6
DD67 InitEnemySpawn_Loop7
DD7F InitEnemySpawn_Loop8
DD89 InitEnemySpawn_Loop9
DD9A InitEnemySpawn_Loop10
DDB6 SetEnemyActiveFlag
DDC7 CheckEnemySlotUsed
DDE0 CheckEnemyState
DDFB CheckEnemyState_Loop
DE02 CheckEnemyState_OnNonzero
DE04 CheckEnemyState_Loop2
DE05 CheckEnemyState_Loop3
DE0E StartActorAction
DE2C StartActorAction_Loop
DE2E StartActorAction_Loop2
DE2F LoadEnemyTileIndexB
DE3B LoadEnemyTileIndexB_Loop
DE4E LoadEnemyTileIndexB_Loop2
DE57 LoadEnemyTileIndexB_Loop3
DE5E LoadEnemyTileIndexB_OnNonzero
DE78 LoadEnemyTileIndexB_Loop4
DE83 InitZerosIfZp30Zero
DE9A InitZerosIfZp30Zero_Loop
DEA3 InitEnemySpriteTable
DEA5 InitEnemySpriteTable_OnNonnegative
DEAE InitEnemySpriteTable_Loop
DEAF CheckEnemyCollisionB
DEBA CheckEnemyCollisionB_Loop
DEC3 CheckEnemyCollisionB_Loop2
DEDA CheckEnemyCollisionB_Loop3
DEDF CheckEnemyCollisionB_Loop4
DEE0 CheckEnemyCollisionB_Loop5
DEEC CheckEnemyScroll
DEFE CheckEnemyScroll_OnNonzero
DF07 CheckEnemyScroll_Loop
DF11 CheckEnemyScroll_OnNonzero2
DF24 CheckEnemyScroll_Loop2
DF37 CheckEnemyScroll_Loop3
DF50 CheckEnemyScroll_Loop4
DF59 CheckEnemyScroll_Loop5
DF5B CheckEnemyScroll_OnNonzero3
DF60 CheckEnemyScroll_Loop6
DF6C CheckEnemyScroll_Loop7
DF72 CheckEnemyScroll_Loop8
DF75 CheckEnemyScroll_OnZero
DF86 CheckEnemyScroll_OnNonzero4
DF87 CheckEnemyScroll_Loop9
DF9D InitEnemyPalette
DF9F InitEnemyPalette_OnNonzero
DFA1 InitEnemyPalette_OnNonnegative
DFAC InitEnemyPaletteB
DFB0 ClearEnemySprites
DFB9 ClearEnemySprites_Loop
DFBA AdvanceEnemyFrameCounter
DFBD AdvanceSpriteCounter
DFC4 InitSpritesOffscreen
DFC8 InitSpritesOffscreen_OnNonzero
DFD3 CheckSpriteFlip
DFEE CheckSpriteFlip_Loop
DFF5 CheckSpriteFlip_Loop2
DFF7 CheckSpriteFlip_OnNonzero
DFF8 CheckEnemyVisible
E00F CheckEnemyVisible_Loop
E023 CheckEnemyVisible_Loop2
E03C CheckEnemyVisible_Loop3
E044 CheckEnemyVisible_OnNonzero
E049 CheckEnemyVisible_Loop4
E051 CheckEnemyVisible_Loop5
E058 CheckEnemyVisible_Loop6
E06D CheckEnemyVisible_Loop7
E077 CheckEnemyVisible_Loop8
E0B8 WriteVramAt0300
E129 SetActorStateReturn
E131 SetActorStateReturn_Loop
E132 DisableBackgroundAndSprites
E13D EnableBackgroundAndSprites
E170 EnableBackgroundAndSprites_Loop
E188 EnableBackgroundAndSprites_Loop2
E190 EnableBackgroundAndSprites_Loop3
E1A7 EnableBackgroundAndSprites_Loop4
E1C4 EnableBackgroundAndSprites_Loop5
E1CE CheckEnemyScriptFlag
E1E4 CheckEnemyScriptFlag_Loop
E1EA CheckEnemyScriptFlag_Loop2
E1EC SetActorState9
E1F4 SetActorStateAndReturn
E1F6 SetActorStateAndReturn_Loop
E1F7 CheckStageComplete
E20A CheckStageComplete_OnNonzero
E20F CheckStageComplete_Loop
E219 CheckStageComplete_Loop2
E21A RunScriptBlock
E239 RunScriptBlock_Loop
E24E AdvanceEnemyTimer
E258 AdvanceEnemyTimer_OnZero
E25E AdvanceEnemyTimer_OnZero2
E25F AdvanceEnemyTimer_Loop
E26D AdvanceEnemyTimerB
E299 AdvanceEnemyTimerB_Loop
E29A SetEnemyScriptFlag
E2AA SetEnemyScriptFlag_Loop
E2AB CheckStageStarted
E2B1 CheckStageStarted_Loop
E2CF CheckStageStarted_OnNonzero
E2D1 CheckStageStarted_OnNonzero2
E2E4 CheckStageStarted_Loop2
E2ED CheckStageStarted_Loop3
E2F6 CheckStageStarted_Loop4
E2FD WriteScriptByte
E329 WriteScriptByte_Loop
E333 InitStage
E34E InitStage_Loop
E358 InitStage_Loop2
E35C InitStage_Loop3
E36C InitStage_Loop4
E374 InitStage_Loop5
E3AE InitStage_Loop6
E3BB InitStage_Loop7
E3C7 InitStage_OnNonzero
E3DD RunStageScript
E3E0 RunStageScript_OnNonzero
E3E3 RunStageScriptB
E3F2 RunStageScriptB_Loop
E3F3 RunStageScriptB_Loop2
E400 RunStageScriptB_Loop3
E403 RunStageScriptB_Loop4
E41E HandleStageCommand
E42F HandleStageCommand_Loop
E440 HandleStageCommand_Loop2
E448 HandleStageCommand_Loop3
E489 HandleStageCommand_OnNonzero
E4CB WriteVramAt22D0
E4CD WriteVramAt22D0_Loop
E4ED WriteVramAt22D0_Loop2
E4FC WriteVramAt22D0_Loop3
E506 WriteVramAt22D0_Loop4
E51E WriteVramAt22D0_OnNonzero
E522 WriteVramAt22D0_Loop5
E53D WriteVramAt22D0_OnNonnegative
E5F3 WriteVramAt22D0_OnCarrySet
E5F6 WriteVramAt22D0_OnCarryClear
E631 WriteVramAt22D0_OnZero
E639 UpdateScoreCounter
E698 UpdateScoreCounter_OnNonzero
E6A0 UpdateScoreCounter_Loop
E709 CountDownStageTimer
E711 CountDownStageTimer_Loop
E719 CountDownStageTimer_Loop2
E72D CountDownStageTimer_Loop3
E735 CountDownStageTimer_Loop4
E73D CountDownStageTimer_Loop5
E73E CheckMarioSprite
E74D CheckMarioSprite_OnNonzero
E75D CheckMarioSprite_Loop
E768 CheckMarioSprite_Loop2
E769 CheckMarioSprite_Loop3
E772 CheckEnemySprite
E783 CopyEnemyTileTable
E787 CopyEnemyTileTable_OnNonnegative
E795 CheckStageReady
E7AC CheckStageReady_Loop
E7AD CheckStageReady_Loop2
E7BD CheckStageReady_Loop3
E7CB CheckStageReady_Loop4
E7D6 CheckStageReady_Loop5
E7E4 WriteEnemyOam
E805 WriteOamSlot
E806 WriteOamSlot_Loop
E824 SetEnemyOamSlot
E830 SetEnemyOamSlot_Loop
E842 SetEnemyOamPointerB
E84A SetEnemyOamPointerB_Loop
E86B CheckEnemyOamOverflow
E877 CheckEnemyOamOverflow_Loop
E883 SetEnemyOamSlotB
E889 SetEnemyOamSlotB_OnNonzero
E890 SetEnemyOamSlotB_Loop
E893 SetEnemyOamSlotB_Loop2
E8AD SetEnemyOamSlotB_Loop3
E8BE SpawnEnemySprite
E8D0 SpawnEnemySprite_OnCarrySet
E8D3 SpawnEnemySprite_Loop
E8F2 SpawnEnemySprite_Loop2
E905 SpawnEnemySprite_Loop3
E907 SpawnEnemySprite_Loop4
E90A SpawnEnemySprite_OnNonzero
E911 ScanEnemyTypeTable
E925 ScanEnemyTypeTable_Loop
E92E ScanEnemyTypeTable_Loop2
E948 ScanEnemyTypeTable_Loop3
E94B ScanEnemyTypeTable_Loop4
E94D ScanEnemyTypeTable_Loop5
E952 SetEnemyOamSlotC
E95E ReadEnemyOamValue
E96D ToggleZpFC_Bit3
E973 ClearStageFlag
E977 ClearStageFlag_Loop
E97A LookupNoteTable2
E984 LookupNoteTable2_Loop
E998 LookupNoteTable2_Loop2
E9A0 InitEnemyPaletteTable
E9A2 InitEnemyPaletteTable_OnNonnegative
E9AC InitMarioPaletteTable
E9AE InitMarioPaletteTable_OnNonnegative
E9B8 CheckEnemyScriptFlagB
E9D2 CheckEnemyScriptFlagB_OnNonzero
E9D3 RunScript
E9E8 RunScript_Loop
E9F2 PrepareOamWrite
E9FA FetchScriptByte
EA1D FetchScriptByte_Loop
EA25 CheckFlagsReturnCarry
EA2F CheckFlagsReturnCarry_Loop
EA31 CheckStageFlag
EA36 CheckStageFlag_OnNonzero
EA37 CheckStageFlag_Loop
EA4C CheckStageFlag_Loop2
EA54 CheckStageFlag_Loop3
EA79 CheckStageFlag_Loop4
EA7C CheckStageFlag_Loop5
EA87 SetEnemyOamPointer
EA90 SetEnemyOamPointer_Loop
EA91 SetEnemyOamPointer_Loop2
EA94 SetEnemyOamPointer_Loop3
EA97 SetEnemyOamPointer_Loop4
EA9F SetEnemyOamPointer_Loop5
EAB5 SetEnemyOamPointer_Loop6
EAB7 SetEnemyOamPointer_OnZero
EABD SetEnemyOamPointer_Loop7
EAC5 SetEnemyOamPointer_Loop8
EAD3 SetEnemyOamPointer_Loop9
EADC SetEnemyOamPointer_Loop10
EADF AdvanceEnemyFrame
EAE2 AdvanceEnemyFrame_Loop
EAED AdvanceEnemyFrame_Loop2
EB1C AdvanceEnemyFrame_Loop3
EB32 AdvanceEnemyFrame_OnNonzero
EB42 AdvanceEnemyFrame_Loop4
EB4A AdvanceEnemyFrame_Loop5
EB53 AdvanceEnemyFrame_OnZero
EB5E AdvanceEnemyFrame_Loop6
EB63 AdvanceEnemyFrame_Loop7
EB6B DecEnemyFrameCounter
EB74 DecEnemyFrameCounter_Loop
EB84 DecEnemyFrameCounter_Loop2
EBB8 DecEnemyFrameCounter_Loop3
EBBC AddEnemyFrameCounter
EBC9 AddEnemyFrameCounter_Loop
EBCC ScanEnemyTypeTableB
EBE0 ScanEnemyTypeTableB_Loop
EBE9 SetEnemyOamSlotD
EBF2 WriteEnemyOamSlot
EC13 WriteEnemyOamSlot_OnZero
EC14 WriteOamRow
EC1B WriteOamRow_OnNonzero
EC25 WriteOamRow_Loop
EC30 HideEnemySprite
EC51 HideEnemySprite_Loop
EC5B HideEnemySprite_Loop2
EC67 ReadActorPointer
EC6F ReadActorPointer_OnNonzero
EC91 ReadActorPointer_Loop
ECA2 CheckStageCompleteB
ECA7 CheckStageCompleteB_OnNonzero
ECAA CheckStageCompleteB_Loop
ECAF StartEnemyStage
ECBD StartEnemyStage_OnNonnegative
ECEC HandleEnemyType80
ECF2 HandleEnemyType80_OnNonzero
ECFB HandleEnemyType80_Loop
ED18 HandleEnemyType80_Loop2
ED20 HandleEnemyType80_Loop3
ED40 HandleEnemyType80_Loop4
ED50 HandleEnemyType80_Loop5
ED6C HandleEnemyType80_Loop6
ED9C HandleEnemyType80_Loop7
EDA9 CheckEnemyFlags
EDAC CheckEnemyFlags_Loop
EDDD CheckEnemyFlags_Loop2
EDE7 CheckEnemyFlags_Loop3
EDEB CheckStageTimer
EDF1 CheckStageTimer_Loop
EE1E CheckStageTimer_Loop2
EE1F CheckStageTimer_Loop3
EE40 CheckStageTimer_Loop4
EE4C CheckStageTimer_OnNonnegative
EE6A DrawStageText
EE81 DrawStageText_Loop
EE82 PushActorState
EEA5 UpdateEnemyTile
EEAD CheckStageScript
EEB9 CheckStageScript_Loop
EEBB CheckStageScript_Loop2
EEBC AddStageCounter
EECC SubStageCounter
EEE3 SetEnemySpeed
EEEE SetEnemySpeed_Loop
EF16 SetEnemySpeed_Loop2
EF29 SetEnemySpeed_Loop3
EF32 DecEnemyCounter
EF36 DecEnemyCounter_OnNonzero
EF48 DecEnemyCounter_Loop
EF50 ComputeActorTableOffsetB
EF5A ComputeActorTableOffsetB_OnNonzero
F8A7 NopPadding
F8C2 AudioPulse1CtrlSetup
F8C6 AudioPulse1SweepSet
F8C8 StorePulse1Sweep
F8CB StorePulse1Ctrl
F8CF SaveXYWritePulse2Freq
F8D5 PlayPulseNote
F8D8 Pulse2FreqXZero
F8DA WritePulse2Freq
F8EB AudioReturn
F8EC WritePulse2Ctrl
F8EF Pulse2FreqXFour
F8F3 ProcessTriangleChannel
F96B WritePulse2PeriodA
F96D WritePulse2Period
F974 DivideYBy8
F978 ComputeNotePeriod
F979 YMinusXDiv8
F981 RotateBitsForTableLookup
F987 LookupNoteTable
F9A2 SetupAudioChannel
F9B5 DecayFrequencyEnvelope
F9BE DecayFrequencyEnvelope_Loop
F9D8 DecayFrequencyEnvelope_Loop2
F9DD DecayFrequencyEnvelope_Loop3
F9E3 DecayFrequencyEnvelope_Loop4
F9ED DecayFrequencyEnvelope_Loop5
F9F2 DecayFrequencyEnvelope_Loop6
FA11 DecayFrequencyEnvelope_Loop7
FA1B DecayFrequencyEnvelope_Loop8
FA1E SetupSoundChannel
FA2D SetupSoundChannel_OnCarrySet
FA38 SetupSoundChannel_Loop
FA3B SetupSoundChannel_OnCarrySet2
FA44 SetupSoundChannel_OnCarrySet3
FA54 SetupSoundChannel_OnCarrySet4
FA5B SetupSoundChannel_Loop2
FA5F SetupSoundChannel_Loop3
FA66 SetupSoundChannel_OnCarrySet5
FA71 SetupSoundChannel_Loop4
FA76 SetupSoundChannel_Loop5
FA7E SetupSoundChannel_Loop6
FA88 SetupSoundChannel_OnCarrySet6
FA8B SetupSoundChannel_OnCarrySet7
FA8E SetupSoundChannel_OnCarrySet8
FA91 CheckSoundEnabled
FAD1 CheckSoundEnabled_OnZero
FAD4 CheckSoundEnabled_Loop
FADB CheckSoundEnabled_Loop2
FAE5 CheckSoundEnabled_OnCarrySet
FAE8 CheckSoundEnabled_OnCarryClear
FAEB DecayCounter
FAEF ResetAudioChannel
FAF8 ResetAudioChannel_Loop
FAFF ResetAudioChannel_Loop2
FB0F ResetAudioChannel_Loop3
FB24 ResetAudioChannel_Loop4
FB3E SetupNoiseChannel
FB48 ProcessNoiseChannel
FB5C ProcessNoiseChannel_Loop
FB6C ProcessNoiseChannel_Loop2
FB7A ProcessNoiseChannel_OnCarrySet
FB87 ProcessNoiseChannel_OnCarrySet2
FB9A ProcessNoiseChannel_Loop3
FBA0 ProcessNoiseChannel_Loop4
FBAE ProcessNoiseChannel_OnCarrySet3
FBBC ProcessNoiseChannel_OnCarrySet4
FBC4 ProcessNoiseChannel_Loop5
FBC7 ProcessNoiseChannel_Loop6
FBD3 ProcessNoiseChannel_Loop7
FBD8 ProcessNoiseChannel_OnCarrySet5
FBE6 ProcessNoiseChannel_OnCarrySet6
FBE9 ProcessNoiseChannel_OnCarrySet7
FBEC ProcessNoiseEnvelope
FC28 ProcessNoiseEnvelope_OnNonzero
FC29 ProcessNoiseEnvelope_Loop
FC35 ProcessNoiseEnvelope_OnNonzero2
FC38 StopPulse2Channel
FC46 StopPulse2Channel_Loop
FC54 StopPulse2Channel_Loop2
FC5C StopPulse2Channel_Loop3
FC60 StopPulse2Channel_Loop4
FC69 StopPulse2Channel_Loop5
FC79 StopPulse2Channel_Loop6
FC88 StopPulse2Channel_Loop7
FC95 StopPulse2Channel_Loop8
FC9D StopPulse2Channel_OnCarryClear
FCA1 StopPulse2Channel_OnCarrySet
FCA7 WritePulse2Sweep
FCB1 WritePulse2Sweep_OnCarrySet
FCC4 WritePulse2Sweep_OnNonzero
FCC9 UpdateSoundState
FCE3 UpdateSoundState_Loop
FCF3 UpdateSoundState_Loop2
FD0B UpdateSoundState_Loop3
FD1A UpdateSoundState_Loop4
FD21 UpdateSoundState_Loop5
FD27 UpdateSoundChannel
FD33 UpdateSoundChannel_Loop
FD35 UpdateSoundChannel_OnNonzero
FD3B UpdateSoundChannel_Loop2
FD78 UpdateSoundChannel_Loop3
FD95 UpdateSoundChannel_Loop4
FD9E UpdateSoundChannel_Loop5
FDA6 UpdateSoundChannel_Loop6
FDAF UpdateSoundChannel_Loop7
FDBE UpdateSoundChannel_Loop8
FDDA UpdateSoundChannel_Loop9
FDFA UpdateSoundChannel_Loop10
FE02 UpdateSoundChannel_Loop11
FE20 UpdateSoundChannel_Loop12
FE27 UpdateSoundChannel_Loop13
FE2D UpdateSoundChannel_Loop14
FE54 UpdateSoundChannel_Loop15
FE5A UpdateSoundChannel_Loop16
FE63 UpdateSoundChannel_Loop17
Reference in new issue View Git Blame Copy Permalink