# Baseball (UE) — Game Flow from Power-On

This document describes the execution flow of the disassembled Baseball (UE) PRG bank (16 KB, mapped at CPU **$C000–$FFFF**), starting from power-on. It is based entirely on `prg.s` in this project folder. The rebuild is verified **byte-identical** to the original `rom.nes`.

## Status

**Pass 3 data-table work complete.** `prg.s` is a hand-annotated,
byte-identical disassembly of the whole 16 KB PRG: every routine, every
inline data block and every data table carries a symbolic name, and no
`Label_Cxxxx` placeholder remains. The Pass 3 data-table inventory is the
section *"Pass 3 data-table inventory"* below — it lists all 120 named tables
and all 93 inline data blocks, with the structure of each and the instruction
that reads it.

Two categories of block are still **uninterpreted**, and the inventory says so
rather than guessing:

* The rendering / animation array at `$ED00-$F94C` is read as a whole by the
  renderer; the individual 256-byte pages are named but the record format
  inside a page is not yet established.
* The music / audio data at `$FE40-$FFE1` and the audio lookup data at
  `$FA00-$FA5F` are named by region; the exact record boundaries inside them
  are not yet established.

---

## 1. ROM and Memory Layout

| Property | Value |
|----------|-------|
| Format | iNES / NES 2.0 |
| PRG | 1 × 16 KB (mapped at CPU $C000–$FFFF) |
| CHR | 1 × 8 KB |
| Mirroring | Horizontal |
| PRG bank start | CPU $C000 (`.org $C000`) |
| Linker output | `reconstructed.nes`, byte-identical to `rom.nes` |

### Interrupt vectors (CPU $FFFA–$FFFF)

| Vector | Address | Handler | Notes |
|--------|---------|---------|-------|
| NMI | $C046 | `NMI` | Runs once per frame; the primary frame driver |
| RESET | $C40B | `Reset` | Cold-start initialization |
| IRQ / BRK | $C43E | `IRQ` | Just `rti` (unused) |

---

## 2. Reset — CPU $FFFC → $C40B

**`Reset`** ($C40B)

On power-on or reset:

1. `sei` / `cld` — disable maskable interrupts, clear decimal mode.
2. **Clear CPU RAM** $0000–$07FF — one 256-byte page at a time using the indirect pointer at $00/$01, repeatedly writing $2000 to PPUCTRL during the clear.
3. `jsr InitializeSpriteSortTables` ($C7B1) — set up the sprite sort/index tables at $0377, $038C, $0399.
4. `jsr DisablePpuRendering` ($E96C) — turn off PPU output.
5. **Disable APU** — write $00 to APUSTATUS ($4015) to silence all channels, then select the five-step frame-counter mode and inhibit frame-counter IRQ via JOY2 ($4017).
6. `jsr ExpandRecordPointerList` ($C8BB) with inline data — builds record pointer structures.
7. `lda #$1A / sta PpuMaskShadow` — initial PPU mask shadow value.
8. `jmp InitializeTitleScreen` ($C74A) — RESET does not return; it transfers directly to the title screen.

---

## 3. NMI / Frame Heartbeat — `NMI` ($C046)

The NMI fires once per frame and is the central frame driver. It does **not** simply return; it performs substantial per-frame work:

1. **Save X and Y** into `NmiSavedX` ($0D) / `NmiSavedY` ($0E).
2. **Read PPUSTATUS** ($2002) to reset the PPU address latch.
3. **OAM DMA** — write $02 to OAMDMA ($4014) to copy $0200–$02FF to sprite memory.
4. **Process the PPU command queue** at $0300 — walk variable-length packets (write packets to $2007, read packets discarded), terminating on a zero-length entry, then reset the queue head (`stx $0300`).
5. **Apply scroll** — write `ScrollX` ($DF) and `ScrollY` ($E0) to $2005.
6. **Apply PPU registers** — write `PpuMaskShadow` ($DE) to $2001 and `PpuCtrlShadow` ($DD) to $2000.
7. `jsr InitializeAudioEngine` ($F9D0) — initialize/advance the audio engine.
8. **Latch controllers** — strobe JOY1 ($4016) with $01 then $00.
9. **Read both controllers** — sample JOY1/JOY2 eight times each, shifting button states into `ControllerPressed1` ($15) / `ControllerPressed2` ($16).
10. **Update controller state** — compute newly-pressed edges (`Pressed = (Pressed & ~Held) | raw`) and update `ControllerHeld1/2` ($11/$12).
11. **START-button branch**:
    - If START pressed and `SessionActive` ($1E) is set → `jsr ProcessQueuedObjectEvent` with command $0B.
    - If START pressed and session is **not** active → set `TransitionActive` ($1D) and `GameplaySuspended` ($EF), then `jmp InitializeNewSession` ($C49C).
12. `NMI_CheckState` — if `NmiStateFlag` ($1F) is nonzero, skip ahead and restore registers.
13. Otherwise `jsr QueueInlineObjectEvent` ($EB55) with inline command bytes `$05,$21,$C1`, then `jsr ProcessQueuedObjectEvent` ($EB2A) with command $0B.
14. `inc FrameCounter` ($E3).
15. `jsr CalculateControllerAssignments` ($C87E) — derive per-player control state.
16. Store derived input into `InputState1/2` ($13/$14) and `InputAux1/2` ($17/$18).
17. **Restore X, Y, A**, `rti`.

Because the NMI does controller reading and event dispatch, the main loop largely waits on the NMI-driven queued-event system rather than polling hardware directly.

---

## 4. Title Screen — InitializeTitleScreen ($C74A)

Shared entry point used by RESET and by post-match/transition paths:

1. `jsr InitializeQueuedEventSystem` ($EB9D) — clear the $0600–$06FF event page, the queue count ($E2), active-event slots, and set `CurrentObjectIndex` ($E1) = 1.
2. `GameplaySuspended` ($EF) = 0; `TransitionActive` ($1D) = 1.
3. `PpuCtrlShadow` = $80; disable PPU rendering; fill PPU memory (`FillPpuMemoryAfterValueSaved` at $E985 with value $25).
4. `jsr ProcessInlinePpuStream` ($EA63) twice — streams title PPU data (inline records `$8D,$F8` and `$00,$C0`).
5. `jsr EnableNmiAndWaitForFrame` ($E978) — enable NMI and synchronize to a frame.
6. Enable APU channels ($4015 = $0F), set timing byte $FD = $08.
7. `RefreshTitleScreen` ($C77A) loop:
   - Update `ModeFlags` ($40).
   - `jsr QueueModeIndicatorTiles` ($E5CF).
   - Wait for controller input release (SELECT/$20) and for the frame counter / delay byte $1B to elapse.
8. On exit: `TransitionActive` = 0, `GameplaySuspended` = 1, clear audio ($4015), re-init the event system, queue an inline command `$03,$88,$C4`, then `jmp InitializeSessionDisplay` ($C4AA).

### Attract mode — RunAttractMessageLoop ($C43F)

Before reaching the title input loop, `Reset` can flow into `RunAttractMessageLoop`, which:
- Clears `NmiStateFlag`, selects object event bank 1.
- Draws encoded six-character messages via `CopyInlineDisplayRecord` ($EA17) with inline text bytes.
- Exchanges the object event bank ($EB4E), increments `NmiStateFlag`, and loops back to itself — this is the idle attract display until the player presses START.

---

## 5. Session and Match Initialization

### InitializeSessionDisplay ($C4AA)
PPU shadow setup, disable rendering, fill PPU memory with $26, then process an inline PPU stream (`$F2,$F4`).

### InitializeMatchState ($C4B9)
- Clears base position and acceleration fields ($C94F/$C943).
- Sets `$053B` and `PositionSignState` ($B7) to $80.
- `jsr EnableNmiAndWaitForFrame`.
- **Player/team selection**:
  - `Random0To5` ($C850) → `PlayerOneSelection` ($34).
  - Repeatedly `Random0To5` until a value different from player one → `PlayerTwoSelection` ($35).
- If `GameplaySuspended` is set, skip side selection; otherwise derive `ActivePlayerSide` ($4B) from mode flags or a random bit.
- Queue inline object events `$03,$19,$C8` and `$02,$19,$C8`, set `PlayerSelectionActive` ($44) = 1.
- `WaitForPlayerSelection` ($C4FF) spins until `$43` (`SelectionState`) becomes negative, then queues `$03,$3E,$C4` and falls into `CompleteMatchSetup` ($C50C).

### CompleteMatchSetup ($C50C)
- `FillSelectionBackgroundBlocks` ($C85A), `QueuePlayerSelectionDisplay` ($C7DD), `InitializeRandomBitfields` ($C8E8), `QueuePlayerValueDisplay` ($CF8B).
- Queue inline command `$09,$37,$CE`, then enter `InitializeRoundState` ($C51E).

---

## 6. Round / Gameplay State Machine

### InitializeRoundState ($C51E)
Round-setup entry point:
- If gameplay is not suspended and `RoundStateIndex` ($33) < $12, select round music cue; otherwise reset round counters.
- `EnableRoundAudio` ($C52A): enable APU channels ($4015 = $0F), set $FD = $08.
- `ResetRoundCounters` ($C536): clear scores ($67/$68) and `RoundStateIndex`.
- `jsr InitializeObjectsFromTable` ($D06B) — initialize objects from the table at $D0A0–$D125.
- Set `$053B` / `PositionSignState` = $80.
- Store a $3C-tick delay, draw an 8-character message, store another $3C delay.
- `SelectRoundMusicCue` ($C566): choose a music delay value ($20 or $40) based on `RoundStateIndex` parity → store in $FD.
- `PrepareRoundObjects` ($C573): queue player-selection display, queue random-state record, clear `MatchCompleteFlag` ($45) and `SecondarySequenceState` ($64).

### ResetGameplayState ($C57F)
- Clear `InningOrSharedScore` ($66), `BaseMotionActive` ($5C).
- Mark four state entries ($0598–$059B) inactive ($FF).
- `jsr QueueRoundNumberDisplay` ($CF67), re-init objects, set sign state to $80.
- Store a $B4-tick delay.

### Round setup continuation points
- `ResumeRoundSetupAtRandomDirection` ($C5A4): queue random-direction record, clear primary/transition sequence state, set `StateSequenceActive` ($46) = 1, clear state field pairs ($03,$23 via $CF51).
- `ResumeRoundSetupAtSelectionDisplay` ($C5BA): clear the 8-character field, clear $0597–$05A6, clear the 38-byte motion field range $056F–$0594.
- Based on `RoundStateIndex` and score comparison ($67 vs $68), either jump to `CompleteMatchState` ($C6F7) or finish the reset.

### FinishGameplayReset ($C5F1)
- `InitializeDefaultObjects` ($D030), clear sign state, select event bank 1 → enter `RunRoundStateLoop` ($C5FE).

### RunRoundStateLoop ($C5FE) — main per-round loop
This is the core gameplay loop:
- If `PendingStateTransition` ($60) is set → `InitializeObjectStateLookup` ($C8A2).
- If either `PendingStateTransition` or `StateSequenceActive` ($46) is nonzero → dispatch state-specific handlers via queued inline commands (`$0D,$77,$D4`, `$0F,$81,$D3`).
- `RunPrimaryRoundHandlers` ($C619):
  - `InitializeSecondaryActors` ($D610), `InitializeConditionalObject` ($D126).
  - Clear working state: `PendingScoreIncrement`, `BaseMotionPhase`, `BaseMotionEventCount`, `TrajectoryResult`, `PendingStateTransition`, `SpecialSequenceState`, `ObjectTransitionState`, `BaseMotionActive`, `ActionSequenceCounter`, `TrajectoryEvaluationEnabled`, and several others.
  - Clear base acceleration and position fields.
  - Queue three inline object events (`$25,$5A,$D8`, `$0E,$66,$D1`, `$1F,$76,$CA`).
  - `jsr UpdateObjectEventBank_Exchange` with command $08.
  - Walk the 22-entry `RoundEventSlotTable` ($C6E1) in reverse, dispatching each via `DispatchNextQueuedEvent` ($EB66).
  - Write one inline character ($3F, value $28) to the PPU.
- `ApplyPendingScoreUpdate` ($C67E): if a score increment is pending and no state transition, `jsr UpdateCountersAndDisplay` ($CFA6), clear the increment.
- `StartPostRoundDelay` ($C68D): wait for `PendingEvent` ($6F) to clear, then count down delay counter $48.
- If match is not complete and no sequence is active → `jmp ResumeRoundSetupAtSelectionDisplay` ($C5BA) to start the next round.
- `ProcessPostRoundEvents` ($C6A5): dispatch event slots $0D and $0F, store a $0A-tick delay, decrement a counter based on `RoundStateIndex` parity.
- `CheckPostRoundContinuation` ($C6C5): if match complete → `AdvanceRoundNumber` ($C6CC); otherwise `jmp ResumeRoundSetupAtRandomDirection` ($C5A4).
- `AdvanceRoundNumber` ($C6CC): update counters/display, increment `RoundStateIndex`; if index reaches $12 → `InitializeResultsPosition` ($C708); otherwise `SelectRoundMusicCue` ($C566) to begin the next round.

---

## 7. Per-Frame Object and Motion Updates

### UpdateFrameObjectsAndTimers ($C122)
Called each frame to drive object motion:
- Reset PPU queue offset, OAM write offset, and `FrameState20` ($20).
- Queue/process inline object events ($07,$64,$C2 via bank, then command $01).
- Decrement per-object timers at $063F,X (30 slots); when a timer reaches zero, queue a decoded object event.
- Decrement four short countdowns at $05AD,X.
- If a transition is active, jump to `CommonEngineExit` ($EB6A); otherwise `IntegrateAllObjectPositions` ($C15B).

### IntegrateAllObjectPositions ($C15B)
- For 36 object slots (X stepping by 2, each logical object uses two indices):
  - Sign-extend and add horizontal delta ($050B/$050C,X from $056F/$0570,X).
  - Sign-extend and add vertical delta ($053C/$053D,X from $0570/$0571,X).

### UpdateBaseMotionSequence ($C18D)
- Integrate velocity/position for three base object indices ($00, $31, $62).
- Reflect base motion values when $056C is negative (negate $056B/$056C and halve $0569/$056A).
- Apply doubled horizontal/vertical velocity adjustments to $0507/$0508 and $0538/$0539.
- `jsr EvaluateTrajectoryResult` ($CAD2).
- Advance `BaseMotionPhase` ($5D); when motion settles, clear base acceleration/position fields.
- `UpdatePositionSignState` ($C228): compute a signed position delta relative to a $0A threshold, track sign changes in `PositionSignState` ($B7), and update rendering flags.

### IntegrateObjectVelocityAndPosition ($C3CA)
Signed fixed-point position integration used by the three base motion call sites: shifts the signed 16-bit velocity right twice (sign-preserving), adds to position ($0507/$0508), then adds the result to the secondary position ($0509/$050A).

---

## 8. Rendering and OAM

### BuildFrameOam ($C2DE)
- If `TransitionActive` is set: copy an 88-byte sprite/OAM template from $F94D into shadow OAM at $0200, set `OamWriteOffset` ($3F), and jump to `TerminatePpuUpdateQueue`.
- Otherwise, if `PlayerSelectionActive` ($44) is set: copy an 8-byte OAM template from $C331, position two sprites from player selection coordinates (scaled ×16 + $50), choose tiles based on `ModeFlags`.
- Otherwise: `SortObjectsByY` ($C339) — sort object indices by signed 16-bit Y coordinates ($0538/$0539) using the index table at $0377/$0378, then render each sorted object via `RenderSpriteRecordList` ($E77B).

### FinalizeOamAndPpuQueue ($C386)
- If `ObjectListFlag` ($C7) is set, skip status OAM; otherwise copy 20 bytes from $EBC2 into shadow OAM and select two extra bytes from $EBBC based on player selections.
- `TerminatePpuUpdateQueue` ($C3AA): write $00 to terminate the PPU command queue at $0300,Y.
- Hide unused sprites by writing $F0 to each remaining OAM Y coordinate (stepping by 4).
- `jsr AdvanceRandomState` ($E5F4), then `jmp CommonEngineExit` ($EB6A).

---

## 9. Batting and Pitching

### Pitching (RunPitcherWindupSequence, $D18B)
- `RunPitcherWindupSequence` animates the pitcher windup (frames selected via `SetWindupFrame`, $D1A2).
- `SelectPitchAction` ($D1D0): reads controller input to choose the pitch action.
- `SelectPitchType` ($D1EA): searches `PitchTypeThresholdTable` / `PitchDirectionThresholdTable` ($D15D/$D14B) to determine pitch type and direction.
- `AnimatePitchStart` ($D212), `UpdatePitchMovement` ($D265): apply pitch trajectory and controller-based horizontal/vertical input.
- Pitch tables: `PitchVelocityBiasTable` ($D2A4), `PitchDelayTable` ($D2A7), `PitchRenderFlagTable` ($D2AA).

### Batting (SelectBatterAction, $D2AD)
- `WaitForBatterAction` ($D2B2): wait for batter input.
- `UseBatterControllerInput` ($D2D4): map controller to batter action slot.
- `SelectActionFromObjectState` ($D32A) with `ObjectActionLookupTable` ($D339).
- `DispatchActionType` ($D33C): route to the appropriate action handler.

### Object motion and collision
- `MoveControlledObject` ($D382): apply controlled horizontal/vertical offsets (`ControlledHorizontalOffsetTable` / `ControlledVerticalOffsetTable` at $D3F0/$D3F3).
- `TestObjectCollision` ($CBEC): object-vs-object collision testing.
- `TestCurrentObjectInput` ($DB18): resolve controller input for the current object.
- Geometry helpers: `CalculateCurrentObjectGeometry` ($DF45), `CalculateGeometryDifference` ($E4DD), `BuildGeometryVector` ($E513), extensive trigonometry/vector math routines ($E4xx–$E8xx).

---

## 10. Audio Engine

### InitializeAudioEngine ($F9D0)
Initialize the APU: write DMC settings, configure pulse/triangle/noise channel presets, write pulse periods from tables ($FA00–), set up audio lookup data.

### UpdateAudioEngine ($FB05)
Per-frame audio update:
- Clear/finalize primary audio effects.
- Update pulse 1 and pulse 2 effects (preset effects, descending effects, state-change effects, phase effects).
- Update triangle pitch sweeps.
- Dispatch music and noise (`DispatchMusicAndNoise` at $FC60): update music sequencer, noise envelope, timed triangle effects, DMC output.

### Music
- `StartMusicSequence` ($FD34): initialize a music sequence by finding its bank and copying the descriptor.
- Channels: pulse 1 ($FD96), pulse 2 ($FDCF), triangle ($FE0B).
- Music sequence data tables at $FE40–$FFE1 (`MusicSequenceData` … `MusicSequenceData_FFD0`).
- Sound effect presets and noise/triangle envelopes throughout the $F9xx–$FE2x region.

Audio is advanced from the NMI via `jsr InitializeAudioEngine` ($F9D0) each frame; the broader `UpdateAudioEngine` ($FB05) is called from the event system.

---

## 11. Object Event System (the main-loop engine)

The game is driven by a **queued event system** rather than a simple polling loop:

- `InitializeQueuedEventSystem` ($EB9D): clear $0600–$06FF, queue count $E2, active slots, set current object index.
- `QueueInlineObjectEvent` ($EB0A) / `QueueDecodedObjectEvent` ($EB2A): push an event onto the queue.
- `ProcessQueuedObjectEvent` ($EB2A): walk the queue and process active events.
- `DispatchNextQueuedEvent` ($EB66): pop the newest event, save its continuation address on the hardware stack (SP = $FF), and `rts` into it — this is how control transfers between event handlers.
- `CommonEngineExit` ($EB6A): mark the current object inactive; if the queue is empty, wait (`beq DispatchNextQueuedEvent_Wait`) polling $E2; otherwise disable NMI bit 7 and dispatch the next entry.

The main gameplay loop (`RunRoundStateLoop`) and most state handlers ultimately pass through `CommonEngineExit`, which blocks until the NMI or another producer queues the next event. This makes the NMI the real-time heartbeat and the main loop an event consumer.

---

## 12. PPU Streaming Helpers ($E9xx–$EBxx)

A family of routines drives PPU updates from inline byte streams embedded in the code:
- `DisablePpuRendering` ($E96C), `EnableNmiAndWaitForFrame` ($E978).
- `FillPpuMemoryWith26` / `FillPpuMemoryAfterValueSaved` ($E983/$E985): fill PPU memory with a byte value.
- `DecodeInlineParameters` ($E99A), `ReadInlineWord` ($E9B4), `CopyInlineBytesToZeroPage` ($E9C2).
- `WritePpuControlFromCarry` ($E9D2), `SetPpuAddressFromInlineRecord` ($E9DB), `WritePendingPpuByte` ($E9FC), `WriteInlinePpuBlock` ($EA02), `PPUWriteString`.
- `CopyInlineDisplayRecord` ($EA17): draw an encoded text record (count byte followed by character data) — used heavily for titles, scores, round numbers, and announcements.
- `ProcessInlinePpuStream` ($EA63): process a stream of PPU commands.

Many routines are followed by `.byte` inline data that must **not** be disassembled as instructions; the disassembly marks these explicitly.

---

## 13. Match Completion and Results

### CompleteMatchState ($C6F7)
- Increment `RoundStateIndex`.
- If `InningOrSharedScore` ($66) is nonzero → `InitializeResultsPosition`; otherwise draw a single encoded character ($32).
- `InitializeResultsPosition` ($C708): set sign state to $80, draw a 10-character message (`$25,$10,$0A,$16,$0E,$25,$1C,$0E,$1D,$25`), set timing $FD = $4, dispatch event slot 2, queue inline `$02,$88,$C4`.
- `ResultsDelayLoop` ($C737): repeat a $3C-tick delay 10 times.
- Disable APU ($4015 = $00), clear `SessionActive` ($1E), then fall into `InitializeTitleScreen` ($C74A) to return to the title.

---

## 14. Summary of Execution Flow

```
Power On / Reset
    │
    ▼
Reset ($C40B) ───► clear RAM $0000-$07FF, init sprite sort, disable PPU/APU
    │
    ▼
jmp InitializeTitleScreen ($C74A)
    │
    ├─ init event system, draw title screen
    ├─ EnableNmiAndWaitForFrame   (NMI now runs each frame)
    ├─ WaitForTitleInputRelease   (wait for START + input release)
    ▼
jmp InitializeSessionDisplay ($C4AA)
    │
    ▼
jmp InitializeMatchState ($C4B9)
    │
    ├─ Random0To5 → PlayerOneSelection ($34)
    ├─ Random0To5 (≠ P1) → PlayerTwoSelection ($35)
    ├─ derive ActivePlayerSide ($4B)
    └─ WaitForPlayerSelection (spin until $43 < 0)
    │
    ▼
CompleteMatchSetup ($C50C)
    │
    ▼
InitializeRoundState ($C51E)
    │
    ├─ enable audio, reset counters, init objects from table ($D06B)
    ├─ draw messages, select music cue
    ▼
ResetGameplayState ($C57F) → FinishGameplayReset ($C5F1)
    │
    ▼
RunRoundStateLoop ($C5FE)  ◄───────────────────┐
    │                                          │
    ├─ InitializeObjectStateLookup             │
    ├─ RunPrimaryRoundHandlers                 │
    │     ├─ InitializeSecondaryActors         │
    │     ├─ InitializeConditionalObject       │
    │     ├─ walk RoundEventSlotTable          │
    │     └─ dispatch queued events            │
    ├─ ApplyPendingScoreUpdate                 │
    ├─ StartPostRoundDelay (wait $48 ticks)    │
    ├─ ProcessPostRoundEvents                  │
    ├─ CheckPostRoundContinuation              │
    │     ├─ match complete → results → title  │
    │     └─ AdvanceRoundNumber → next round   │
    └─ eventually → CommonEngineExit ($EB6A)   │
              wait for queued event ($E2)      │
              dispatch next event (rts into it)│
              └────────────────────────────────┘

NMI ($C046) [every frame]
    ├─ PPU command queue flush ($0300)
    ├─ OAM DMA ($4014)
    ├─ scroll ($2005), PPU mask/ctrl ($2001/$2000)
    ├─ InitializeAudioEngine ($F9D0)
    ├─ controller latch + read (JOY1/JOY2)
    ├─ controller state (pressed/held edges)
    ├─ START branch → new session or command $0B
    ├─ QueueInlineObjectEvent + ProcessQueuedObjectEvent
    ├─ FrameCounter++, CalculateControllerAssignments
    └─ restore registers, rti
```

---

## 15. Key Zero-Page / RAM Symbols

| Address | Symbol | Use |
|---------|--------|-----|
| $00–$01 | IndirectPtrLo/Hi | RAM-clear indirect pointer |
| $0D–$0E | NmiSavedX/Y | NMI register save |
| $0F | DerivedControl0 | Derived control input |
| $11–$12 | ControllerHeld1/2 | Currently held buttons |
| $13–$14 | InputState1/2 | Current input state |
| $15–$16 | ControllerPressed1/2 | Newly pressed buttons |
| $17–$18 | InputAux1/2 | Auxiliary input |
| $19–$1A | RandomStateLo/Hi | PRNG state |
| $1B | TransitionCounter | Transition delay |
| $1D | TransitionActive | Transition in progress |
| $1E | SessionActive | Session/game active flag |
| $1F | NmiStateFlag | NMI state flag |
| $20 | FrameState20 | Frame state |
| $21 | SelectedPitchAction | Current pitch action |
| $33 | RoundStateIndex | Current round/inning index |
| $34–$35 | PlayerOne/TwoSelection | Selected teams |
| $36–$39 | ObjectScreenX/Y (+Hi) | Object screen coordinates |
| $3E–$3F | PpuQueueOffset / OamWriteOffset | PPU/OAM write positions |
| $40 | ModeFlags | Display/mode flags |
| $42 | CurrentObjectArrayOffset | Current object slot |
| $43 | SelectionState | Selection state |
| $44 | PlayerSelectionActive | Player selection active |
| $45 | MatchCompleteFlag | Match finished |
| $46 | StateSequenceActive | State sequence running |
| $48 | DelayCounter | General delay |
| $4B | ActivePlayerSide | Active player (0/1) |
| $4D–$50 | RandomState0/1, RandomBits0/1 | Randomization state |
| $53–$56 | SavedBaseX/Y (Lo/Hi) | Saved base coordinates |
| $5C | BaseMotionActive | Base motion active |
| $5D | BaseMotionPhase | Base motion phase |
| $5E | BaseMotionEventCount | Base motion event count |
| $5F | TrajectoryResult | Trajectory result |
| $60 | PendingStateTransition | Pending state change |
| $66 | InningOrSharedScore | Inning / shared score |
| $67–$68 | PlayerOne/TwoScore | Scores |
| $69–$6A | EventWrite/ReadIndex | Event queue indices |
| $6F | PendingEvent | Pending event |
| $7E | ActionSequenceCounter | Action sequence counter |
| $83 | ObjectApproachCount | Approach counter |
| $86 | TrajectoryEvaluationEnabled | Trajectory eval enabled |
| $8E–$90 | RandomHorizontal/VerticalMotion | Random motion |
| $9D | CurrentActionState | Current action |
| $9F–$A1 | SecondaryActorState0–2 | Secondary actor states |
| $A2 | ObjectSequenceState | Object sequence state |
| $B7 | PositionSignState | Position sign tracking |
| $C7 | ObjectListFlag | Object list flag |
| $C9–$CA | SpriteSortBaseIndex / SpriteArrayEnd | Sort table bounds |
| $DD–$E0 | PpuCtrl/MaskShadow, ScrollX/Y | PPU/shadow/scroll state |
| $E1 | CurrentObjectIndex | Current object being processed |
| $E2 | ScriptDepth / queue count | Queued event count |
| $E3 | FrameCounter | Frame tick counter |
| $EF | GameplaySuspended | Gameplay suspended |
| $F6–$F7 | SoundPtrLo/Hi | Sound pointer |
| $FE | PendingAudioFlags | Pending audio flags |
| $FF | RenderStateFlags | Render state flags |

---

## Pass 3 data-table inventory

Every data block in the PRG, what its bytes are, and the instruction in this
dump that reads it.  The PRG is a single 16 KB bank at `$C000-$FFFF`, so
every address below is both the CPU address and the PRG offset plus `$C000`.

Two kinds of block exist in this project:

* **Named tables** — a labelled run of `.byte` rows in `prg.s`.  All 120 are
  listed below.
* **Inline data blocks** — bytes that sit *inside* a routine and are consumed
  by the `jsr` immediately above them (the queued-event system pulls its
  arguments straight out of the return address).  All 93 are listed in the
  second table.

### Named tables

| Address | Size | Name | Structure | Read by |
|---------|------|------|-----------|---------|
| `$C000-$C007` | 8 | `TitleCopyrightPpuStream` | PPU command stream for the title-screen copyright line: three-byte records of *PPU address high, PPU address low, data* (`$23,$45,$05`, `$AF,$01,$09,$08,$04`, `$23,$65,$18`). Written into the PPU by `ProcessInlinePpuStream` | `ProcessInlinePpuStream` at `$C008` (the stream is handed to the inline-stream walker; no absolute operand names it) |
| `$C024-$C029` | 6 | `TeamInitialTileTable` | One tile index per selectable team initial, in the order A, C, D, P, R, Y: `$0A,$0C,$0D,$19,$1B,$22` | `lda $C024,y` at `$CF97` and `$CF9F`, indexed by the player's team selection |
| `$C02A-$C02F` | 6 | `TeamSelectionSpriteTileTable` | Sprite tile used for the selection marker of each of the six teams | `lda $C02A,y` at `$C7F9` and `$C80D` |
| `$C030-$C035` | 6 | `TeamSelectionSpriteXTable` | Screen X of each team's selection marker sprite: `$30,$21,$10,$30,$21,$10` | `lda $C030,y` at `$C7FF` and `$C813` |
| `$C331-$C338` | 8 | `OAMTemplate_C331` | 8-byte OAM template (two sprites' Y, tile, attribute, X) copied into the shadow OAM when the player-selection screen is drawn | `lda $C331,x` at `$C2FB` |
| `$C6E1-$C6F6` | 22 | `RoundEventSlotTable` | 22 event-slot indices, ascending by two (`$04,$06,$08,$0A,$0C,$0E,$10,$12`, …); the loop at `$C66A` walks it in reverse and dispatches each slot | `ldy RoundEventSlotTable,x` at `$C66A` |
| `$CB35-$CB38` | 4 | `TrajectoryResultTable` | 4 signed result bytes, indexed by the two-bit value computed at `$CAFC-$CAFF` | `lda TrajectoryResultTable,x` at `$CB00` |
| `$CD22-$CD24` | 3 | `StateHorizontalLowTable` | Low byte of the horizontal displacement applied to the animated object, one entry per state (`$00,$80,$00`). The code's base is `$CD21`, one byte below the table, so entry 0 as read is the operand byte `$2F` of the `bne` at `$CD20` | `lda $CD21,x` at `$CD54` (stored to `$050B`) |
| `$CD25-$CD27` | 3 | `StateHorizontalHighTable` | High byte of the same displacement (`$09,$FF,$F7`); code base `$CD24` | `lda $CD24,x` at `$CD5A` (stored to `$050C`) |
| `$CD28-$CD2A` | 3 | `StateVerticalLowTable` | Low byte of the vertical displacement (`$00,$00,$00`); code base `$CD27` | `lda $CD27,x` at `$CD60` (stored to `$053C`) |
| `$CD2B-$CD2D` | 3 | `StateVerticalHighTable` | High byte of the vertical displacement (`$02,$0A,$02`); code base `$CD2A` | `lda $CD2A,x` at `$CD66` (stored to `$053D`) |
| `$CE1A-$CE21` | 8 | `CelebrationPaletteSequence` | 8 palette bytes appended one at a time during the home-run celebration | `lda CelebrationPaletteSequence,y` at `$CE0F` |
| `$CEC9-$CECE` | 6 | `AnnouncementTextBlank` | Entry `$00` of the 12-entry announcement table: six encoded characters, all `$25` (a blank) | `lda AnnouncementTextTable,y` at `$CEBC`, with A = the entry offset chosen by `DisplayAnnouncementPair` at `$CEA5` |
| `$CECF-$CED4` | 6 | `AnnouncementTextFoul` | Entry `$06` of the announcement table (`$25,$0F,$18,$1E,$15,$25`) | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$CED5-$CEDA` | 6 | `AnnouncementTextStrike` | Entry `$0C` (`$1C,$1D,$1B,$12,$14,$0E`) | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$CEDB-$CEE0` | 6 | `AnnouncementTextOut` | Entry `$12` | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$CEE1-$CEE6` | 6 | `AnnouncementTextBall` | Entry `$18` | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$CEE7-$CEEC` | 6 | `AnnouncementTextWalk` | Entry `$1E` | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$CEED-$CEF2` | 6 | `AnnouncementTextSingle` | Entry `$24` | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$CEF3-$CEF8` | 6 | `AnnouncementTextTwoBase` | Entry `$2A` | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$CEF9-$CFE6` | 6 | `AnnouncementTextThreeBase` | Entry `$30` | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$CEFF-$CF04` | 6 | `AnnouncementTextDeadBall` | Entry `$36` | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$CF05-$CF0A` | 6 | `AnnouncementTextChange` | Entry `$3C` | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$CF0B-$CF10` | 6 | `AnnouncementTextSafe` | Entry `$42` | `lda AnnouncementTextTable,y` at `$CEBC` |
| `$D0A0-$D0A6` | 7 | `ObjectInit_D0A0` | Record 0 of the object-initialisation table: object-array offset `$06`, sprite index `$7A` (`$039B`), attribute `$7A` (`$03B0`), X = `$FECD`, Y = `$F84C` | `ldx ObjectInitializationTable,y` at `$D06C`; the fields are read by `lda ObjectInitFrameField,y` at `$D08C`, `lda ObjectInitAttributeField,y` at `$D092`, `lda ObjectInitXLowField,y` at `$D071`, `lda ObjectInitXHighField,y` at `$D077`, `lda ObjectInitYLowField,y` at `$D07D`, `lda ObjectInitYHighField,y` at `$D083` |
| `$D0A7-$D0AD` | 7 | `ObjectInit_D0A7` | Record 1 (object-array offset `$08`) | as above |
| `$D0AE-$D0B4` | 7 | `ObjectInit_D0AE` | Record 2 | as above |
| `$D0B5-$D0BB` | 7 | `ObjectInit_D0B5` | Record 3 | as above |
| `$D0BC-$D0C2` | 7 | `ObjectInit_D0BC` | Record 4 | as above |
| `$D0C3-$D0C9` | 7 | `ObjectInit_D0C3` | Record 5 | as above |
| `$D0CA-$D0D0` | 7 | `ObjectInit_D0CA` | Record 6 | as above |
| `$D0D1-$D0D7` | 7 | `ObjectInit_D0D1` | Record 7 | as above |
| `$D0D8-$D0DE` | 7 | `ObjectInit_D0D8` | Record 8 | as above |
| `$D0DF-$D0E5` | 7 | `ObjectInit_D0DF` | Record 9 | as above |
| `$D0E6-$D0EC` | 7 | `ObjectInit_D0E6` | Record 10 | as above |
| `$D0ED-$D0F3` | 7 | `ObjectInit_D0ED` | Record 11 | as above |
| `$D0F4-$D0FA` | 7 | `ObjectInit_D0F4` | Record 12 | as above |
| `$D0FB-$D101` | 7 | `ObjectInit_D0FB` | Record 13 | as above |
| `$D102-$D108` | 7 | `ObjectInit_D102` | Record 14 | as above |
| `$D109-$D10F` | 7 | `ObjectInit_D109` | Record 15 | as above |
| `$D110-$D116` | 7 | `ObjectInit_D110` | Record 16 | as above |
| `$D117-$D11D` | 7 | `ObjectInit_D117` | Record 17 | as above |
| `$D11E-$D124` | 7 | `ObjectInit_D11E` | Record 18 | as above |
| `$D125` | 1 | `ObjectInitTable_End` | Zero byte that terminates the object-initialisation table | `ldx ObjectInitializationTable,y` at `$D06C` → `beq ObjectInitializationReturn` at `$D06F` |
| `$D14B-$D153` | 9 | `PitchDirectionThresholdTable` | 9 ascending thresholds compared against the player's horizontal input to choose the pitch direction | `cmp PitchDirectionThresholdTable,x` at `$D1FE` |
| `$D154-$D15C` | 9 | `PitchDirectionResultTable` | The 9 direction values returned when a threshold matches | `lda PitchDirectionResultTable,x` at `$D203` |
| `$D15D-$D161` | 5 | `PitchTypeThresholdTable` | 5 thresholds compared against the player's vertical input to choose the pitch type | `cmp PitchTypeThresholdTable,x` at `$D1EE` |
| `$D162-$D166` | 5 | `PitchTypeResultTable` | The 5 pitch types returned when a threshold matches | `lda PitchTypeResultTable,x` at `$D1F3` |
| `$D2A4-$D2A6` | 3 | `PitchVelocityBiasTable` | 3-byte velocity bias, one entry per pitch type | `sbc PitchVelocityBiasTable,x` at `$D245` |
| `$D2A7-$D2A9` | 3 | `PitchDelayTable` | 3-byte delay, one entry per pitch type | `lda PitchDelayTable,x` at `$D249` |
| `$D2AA-$D2AC` | 3 | `PitchRenderFlagTable` | 3-byte render flag, one entry per pitch type | `lda PitchRenderFlagTable,x` at `$D23B` |
| `$D339-$D33B` | 3 | `ObjectActionLookupTable` | Action/control byte for the selected batter action; the code's base is `$D338`, one byte below the label | `lda $D338,x` at `$D334` |
| `$D3F0-$D3F2` | 3 | `ControlledHorizontalOffsetTable` | 3 signed horizontal offsets applied to a controlled object | `lda ControlledHorizontalOffsetTable,y` at `$D393` |
| `$D3F3-$D3F7` | 5 | `ControlledVerticalOffsetTable` | 5 signed vertical offsets applied to a controlled object | `lda ControlledVerticalOffsetTable,y` at `$D3C5` |
| `$D5B9-$D5BD` | 5 | `RandomMotionBaseTable` | 5 randomised base values (`$C0,$E0,$00,$40,$60`); the code's base is `$D5B8`, one byte below the label | `adc $D5B8,x` at `$D517` |
| `$D5BE-$D5C2` | 5 | `RandomMotionThresholdTable` | 5 thresholds (`$00,$4B,$85,$BC,$F0`); the code's base is `$D5BD`, one byte below the label | `cmp $D5BD,x` at `$D504` |
| `$D5C3-$D5CC` | 10 | `RandomMotionAngleTable` | 10 offset/result values added to the randomised motion angle | `adc $D5C3,x` at `$D532` |
| `$D5CD` | 1 | `RandomMotionAnglePadding` | One standalone byte between the angle table and the angle thresholds; its role is not established | **nothing in the dump reads it** |
| `$D5CE-$D5D7` | 10 | `RandomMotionAngleThresholdTable` | 10 thresholds; the search starts at X = `$0A` and decrements before comparing, so the first read is `$D5D7` | `cmp $D5CE,x` at `$D528` |
| `$D837-$D842` | 12 | `AnimationFrameBaseTable` | 12 replacement / lower animation frames, one per animation range | `cmp AnimationFrameBaseTable,y` at `$D826`; `lda AnimationFrameBaseTable,y` at `$D82B` |
| `$D843-$D84E` | 12 | `AnimationFrameLimitTable` | 12 upper animation-frame thresholds, one per range | `cmp AnimationFrameLimitTable,y` at `$D821` |
| `$D84F-$D85A` | 12 | `AnimationFrameDelayTable` | 12 delays, one per range (most are six ticks; range four waits nine) | `lda AnimationFrameDelayTable,y` at `$D831` |
| `$DA9C-$DA9F` | 4 | `ObjectAnimationAttributeTable` | 4 animation attribute bytes; the code's base is `$DA9B`, one byte below the label, so Y = `$01-$04` | `lda $DA9B,y` at `$DA8F` |
| `$DAA0-$DAA3` | 4 | `ObjectAnimationFrameTable` | 4 animation frame bytes; the code's base is `$DA9F`, one byte below the label | `lda $DA9F,y` at `$DA95` |
| `$DBB0-$DBB7` | 8 | `InputMaskTable` | 8 controller-input masks, one per object selector; adjacent entries repeat in pairs because neighbouring selectors accept the same buttons | `and InputMaskTable,y` at `$DB25` |
| `$DBF6-$DBFD` | 8 | `SecondaryAnimationBaseTable` | 8 base / reset animation frames for the secondary (fielding) objects | `cmp SecondaryAnimationBaseTable,y` at `$DBE8`; `lda SecondaryAnimationBaseTable,y` at `$DBED` |
| `$DBFE-$DC05` | 8 | `SecondaryAnimationLimitTable` | 8 upper animation-frame limits for the secondary objects | `cmp SecondaryAnimationLimitTable,y` at `$DBE3` |
| `$DC29` | 1 | `VerticalAdjustmentTable` | Single signed vertical adjustment byte; the tables that follow overlap it | `adc VerticalAdjustmentTable,y` at `$DC20` |
| `$DC2A-$DC30` | 7 | `HorizontalAdjustmentTable` | 7 signed horizontal adjustment bytes, overlapping the vertical table | `adc HorizontalAdjustmentTable,y` at `$DC0F` |
| `$DC88-$DC90` | 9 | `ObjectEventSlotTable` | 9 event-slot indices, each an even object-array offset; halving each gives the compact object-state index | `ldy ObjectEventSlotTable,x` at `$DC62`; `ldx ObjectEventSlotTable,y` at `$DC74` and `$DCA6` |
| `$DF12-$DF14` | 3 | `SetupCurrentObjectGeometry` | Three raw bytes that copy the saved base coordinates into the geometry argument structure; the original ROM uses absolute addressing for zero-page `$53-$56`, and raw bytes keep CA65 from shortening the instruction | read as part of the surrounding routine; **nothing in the dump names it directly** |
| `$DFC4-$DFD3` | 16 | `SignedCoordinateOffsetTable` | 8 little-endian signed 16-bit offsets (`$F800`, `$0800`, `$F800`, `$0000`, `$00F9`, `$0007`, `$00F9`, `$FE00`); later routines index the region through nearby or overlapping bases | read through the overlapping bases in the geometry routines; **no single absolute operand names it** |
| `$DFEB-$DFEE` | 4 | `ObjectDisplayAttributeTable` | 4 display attribute bytes; the load at `$DFDA` intentionally uses base `$DFEA`, so Y = `$01-$04` | `lda $DFEA,y` at `$DFDA` |
| `$E01D-$E020` | 4 | `ObjectStateLookupData` | 4 bytes of lookup data for the object-state routines | `lda $E01D,x` at `$E111` |
| `$E021-$E026` | 6 | `ObjectStateThresholdTable` | 6 thresholds compared against the object's state value | `cmp $E021,y` at `$DB6A` and `$E0E0` |
| `$E027-$E036` | 16 | `ObjectStateResultTable` | 16 result bytes selected by the state lookup | `eor $E027,y` at `$E0D8`; `lda $E027,y` at `$E0ED` |
| `$E295-$E29A` | 6 | `CandidateObjectOffsetTable` | 6 even object-array offsets searched by `FindNearestCandidateObject`; halving each gives the compact index | `ldy CandidateObjectOffsetTable,x` at `$E266` and `$E291` |
| `$E319-$E320` | 8 | `CurrentObjectAnimationBaseTable` | 8 base / reset frames for the current object's animation ranges | `cmp CurrentObjectAnimationBaseTable,y` at `$E301`; `lda CurrentObjectAnimationBaseTable,y` at `$E306` |
| `$E321-$E328` | 8 | `CurrentObjectAnimationLimitTable` | 8 exclusive upper frame limits | `cmp CurrentObjectAnimationLimitTable,y` at `$E2FC` |
| `$E329-$E330` | 8 | `CurrentObjectAnimationDelayTable` | 8 delays, one per range | `lda CurrentObjectAnimationDelayTable,y` at `$E30C` |
| `$E413-$E432` | 32 | `GeometryParameterData` | First 32 bytes of the geometry parameter block; later routines index it with calculated and overlapping offsets | `lda GeometryParameterData,y` at `$E4C2` |
| `$E433-$E452` | 32 | `GeometryParameterData_Block2` | Second 32 bytes of the same structure | `lda $E433,y` at `$E4C7` |
| `$E453-$E46A` | 24 | `GeometryParameterData_Block3` | Third (24-byte) block of the same structure | `lda $E453,y` at `$E4C8` |
| `$E761-$E76D` | 13 | `RenderingStateTable_Default` | First 13-byte rendering state record | `lda $E761,y` at `$E75A`; the code's base is `$E761` |
| `$E76E-$E77A` | 13 | `RenderingStateTable_Alternate` | Second 13-byte rendering state record | `lda $E76E,y` at `$E75A` |
| `$EBBC-$EBDB` | 32 | `RenderingData_EBBC` | Compact rendering / animation records (repeating `$41` fields and control bytes); the block starts with `$D6 $E1`, which is not a plausible entry point | `lda $EBBC,y` at `$C39A` and `$C3A2` |
| `$EBDC-$EBFB` | 32 | `RenderingData_EBDC` | The same record pattern continued; the exact record boundaries are not yet established | `lda $EBDC,y` at `$C3A4` |
| `$EBFC-$EC1B` | 32 | `RenderingData_EBFC` | The same record pattern continued | `lda $EBFC,y` at `$C3A6` |
| `$ED00-$EDFF` | 256 | `RenderingAnimationData_ED00` | One 256-byte page of rendering / animation data. The pages `$ED00`-`$F8FF` are read as a single array by the renderer, so each 256-byte page is one page of sprite/attribute records | the renderer indexes the whole `$ED00`-`$F8FF` array; no single absolute operand names this page |
| `$EE00-$EEFF` | 256 | `RenderingAnimationData_EE00` | Second page of the same array | as above |
| `$EF00-$EFFF` | 256 | `RenderingAnimationData_EF00` | Third page | as above |
| `$F000-$F0FF` | 256 | `RenderingAnimationData_F000` | Fourth page | as above |
| `$F100-$F1FF` | 256 | `RenderingAnimationData_F100` | Fifth page | as above |
| `$F200-$F2FF` | 256 | `RenderingAnimationData_F200` | Sixth page | as above |
| `$F300-$F3FF` | 256 | `RenderingAnimationData_F300` | Seventh page | as above |
| `$F400-$F4FF` | 256 | `RenderingAnimationData_F400` | Eighth page | as above |
| `$F500-$F5FF` | 256 | `RenderingAnimationData_F500` | Ninth page | as above |
| `$F600-$F6FF` | 256 | `RenderingAnimationData_F600` | Tenth page | as above |
| `$F700-$F7FF` | 256 | `RenderingAnimationData_F700` | Eleventh page | as above |
| `$F800-$F8FF` | 256 | `RenderingAnimationData_F800` | Twelfth page | as above |
| `$F900-$F94C` | 77 | `RenderingAnimationData_F900` | Last partial page of the array | as above |
| `$F9A5-$F9CF` | 43 | `RenderingAnimationData_F9A5` | Trailing animation data after the `$FF` padding at `$F94D-$F9F4` | **nothing in the dump names it** |
| `$F9F4-$F9FF` | 12 | `AudioPadding_F9F4` | `$FF` padding between the rendering data and the audio data | **nothing in the dump reads it** |
| `$FA00-$FA5F` | 96 | `AudioLookupData_FA00` | Adjacent audio tables: 20 little-endian APU timer periods (`$F007`, `$6900`, `$0000`, `$D400`, …) up to `$FA41`, then the note-duration table at `$FA4A` (`$00,$20,$05,$0A,$14,$28,$0D,$21`) and a rhythm table at `$FA50` | `lda $FA00,y` at `$FA9A` (timer high bytes); the low-byte base `$FA01` and the duration base `$FA4A` are referenced directly by the audio routines |
| `$FD0C-$FD13` | 8 | `NoiseEnvelopeSequence` | 8 envelope values; the routine at `$FD14` derives a three-bit index from it | `lda NoiseEnvelopeSequence,y` at `$FD1F` |
| `$FE40-$FE5F` | 32 | `MusicSequenceData` | First 32 bytes of the music sequence / note / duration / envelope data consumed by the sequence engine at `$FD14-$FE3F` | `lda $FE40,y` at `$FD49` and `$FD51` |
| `$FE60-$FE7F` | 32 | `MusicSequenceData_FE60` | Continuation of the music data | `lda $FE60,y` at `$FD53` |
| `$FE80-$FE9F` | 32 | `MusicSequenceData_FE80` | Continuation of the music data | `lda $FE80,y` at `$FD55` |
| `$FEA0-$FEBF` | 32 | `MusicSequenceData_FEA0` | Continuation of the music data | `lda $FEA0,y` at `$FD57` |
| `$FEC0-$FEDF` | 32 | `MusicSequenceData_FEC0` | Continuation of the music data | `lda $FEC0,y` at `$FD59` |
| `$FEE0-$FEFF` | 32 | `MusicSequenceData_FEE0` | Continuation of the music data | `lda $FEE0,y` at `$FD5B` |
| `$FF00-$FF1F` | 32 | `MusicSequenceData_FF00` | Continuation of the music data | `lda $FF00,y` at `$FD5D` |
| `$FF20-$FF3F` | 32 | `MusicSequenceData_FF20` | Continuation of the music data | `lda $FF20,y` at `$FD5F` |
| `$FF40-$FF5F` | 32 | `MusicSequenceData_FF40` | Continuation of the music data | `lda $FF40,y` at `$FD61` |
| `$FF60-$FF7F` | 32 | `MusicSequenceData_FF60` | Continuation of the music data | `lda $FF60,y` at `$FD63` |
| `$FF80-$FF9F` | 32 | `MusicSequenceData_FF80` | Continuation of the music data | `lda $FF80,y` at `$FD65` |
| `$FFA0-$FFBF` | 32 | `MusicSequenceData_FFA0` | Continuation of the music data | `lda $FFA0,y` at `$FD67` |
| `$FFC0-$FFCF` | 16 | `MusicSequenceData_FFC0` | Continuation of the music data | `lda $FFC0,y` at `$FD69` |
| `$FFD0-$FFE1` | 18 | `MusicSequenceData_FFD0` | Final music / audio sequence data | `lda $FFD0,y` at `$FD6B` |
| `$FFE2-$FFF9` | 24 | `UnusedRomPadding` | `$52,$00` finish the audio data above; the rest through `$FFF9` is `$FF` padding | **nothing in the dump reads it** |

### Inline data blocks

These are the bytes that sit inside a routine and are pulled out of the
return address by the helper that the `jsr` above them names.  They are
listed here so that the inventory covers every byte of the PRG that is not an
instruction.

| Address | Size | Name | Structure | Read by |
|---------|------|------|-----------|---------|
| `$C01B` | 27 | inline after `TitleCopyrightPpuStream` | 4 `.byte` row(s) of inline data that follow the call | the routine it follows |
| `$C023` | 1 | inline after `TitleCopyrightPpuStream` | 1 `.byte` row(s) of inline data that follow the call | the routine it follows |
| `$C0F3` | 3 | inline after `NMI_CheckState` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C0F0` |
| `$C12D` | 3 | inline after `UpdateFrameObjectsAndTimers` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C12A` |
| `$C246` | 3 | inline after `SaveSignedPositionDelta` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C243` |
| `$C434` | 3 | inline after `Reset_ClearPageLoop` | 1 `.byte` row(s) of inline data that follow the call | `ExpandRecordPointerList` at `$C431` |
| `$C456` | 7 | inline after `RunAttractMessageLoop` | 3 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$C44F` |
| `$C475` | 7 | inline after `RunAttractMessageLoop` | 3 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$C46E` |
| `$C4B7` | 2 | inline after `InitializeSessionDisplay` | 1 `.byte` row(s) of inline data that follow the call | `ProcessInlinePpuStream` at `$C4B4` |
| `$C4F2` | 3 | inline after `DeriveSelectedSideFromMode` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C4EF` |
| `$C4F8` | 3 | inline after `StartPlayerSelection` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C4F5` |
| `$C509` | 3 | inline after `WaitForPlayerSelection` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C506` |
| `$C51B` | 3 | inline after `CompleteMatchSetup` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C518` |
| `$C55D` | 9 | inline after `ResetRoundCounters` | 3 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$C555` |
| `$C610` | 3 | inline after `CheckRoundTransitionState` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C60D` |
| `$C616` | 3 | inline after `CheckRoundTransitionState` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C613` |
| `$C654` | 3 | inline after `RunPrimaryRoundHandlers` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C651` |
| `$C65A` | 3 | inline after `RunPrimaryRoundHandlers` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C657` |
| `$C660` | 3 | inline after `RunPrimaryRoundHandlers` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C65D` |
| `$C67C` | 2 | inline after `ProcessRoundEventSlotTable` | 1 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$C679` |
| `$C706` | 2 | inline after `CompleteMatchState` | 1 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$C703` |
| `$C71F` | 11 | inline after `InitializeResultsPosition` | 3 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$C716` |
| `$C730` | 3 | inline after `InitializeResultsPosition` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C72D` |
| `$C762` | 2 | inline after `InitializeTitleScreen` | 1 `.byte` row(s) of inline data that follow the call | `ProcessInlinePpuStream` at `$C75F` |
| `$C767` | 2 | inline after `InitializeTitleScreen` | 1 `.byte` row(s) of inline data that follow the call | `ProcessInlinePpuStream` at `$C764` |
| `$C7AB` | 3 | inline after `WaitForTitleInputRelease` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$C7A8` |
| `$C7D8` | 9 | inline after `ClearEightCharacterField` | 3 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$C7D0` |
| `$C7EC` | 8 | inline after `QueuePlayerSelectionDisplay` | 3 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$C7E4` |
| `$C910` | 3 | inline after `QueueRandomStateRecord` | 1 `.byte` row(s) of inline data that follow the call | `ExpandRecordPointerList` at `$C90D` |
| `$C917` | 3 | inline after `QueueAlternateRandomStateRecord` | 1 `.byte` row(s) of inline data that follow the call | `ExpandRecordPointerList` at `$C914` |
| `$C936` | 3 | inline after `SaveDirectionSelection` | 1 `.byte` row(s) of inline data that follow the call | `ExpandRecordPointerList` at `$C933` |
| `$C93F` | 3 | inline after `QueueAlternateDirectionRecord` | 1 `.byte` row(s) of inline data that follow the call | `ExpandRecordPointerList` at `$C93C` |
| `$CA9B` | 3 | inline after `UpdateTrajectoryFrame` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CA98` |
| `$CAA4` | 3 | inline after `QueueNegativeTrajectoryCommand` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CAA1` |
| `$CAAD` | 3 | inline after `QueueLaterTrajectoryCommand` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CAAA` |
| `$CB2A` | 3 | inline after `ApplyNegativeTrajectoryResult` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CB27` |
| `$CB31` | 3 | inline after `QueueNegativeResultCommand` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CB2E` |
| `$CC16` | 3 | inline after `AdvancePrimaryStateSequence` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CC13` |
| `$CC38` | 3 | inline after `QueuePrimaryStateEvent` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CC35` |
| `$CCB5` | 3 | inline after `Routine_CCAA_OneTimeCommand` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CCB2` |
| `$CD14` | 3 | inline after `Routine_CD09_OneTimeCommand` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CD11` |
| `$CD3E` | 3 | inline after `QueueSelectedStateMarker` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CD3B` |
| `$CD84` | 5 | inline after `WaitForStateAnimation` | 2 `.byte` row(s) of inline data that follow the call | `LoadObjectPositionInline` at `$CD80` |
| `$CDAF` | 3 | inline after `RunHomeRunCelebration` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$CDAC` |
| `$CDE8` | 9 | inline after `HomeRunAnimationLoop` | 3 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$CDE0` |
| `$CF63` | 4 | inline after `QueueThreeBlanks` | 2 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$CF5F` |
| `$D033` | 6 | inline after `DisplaySharedCounter` | 2 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$D02F` |
| `$D061` | 6 | inline after `ConvertSharedCounterToDigits` | 2 `.byte` row(s) of inline data that follow the call | `CopyInlineDisplayRecord` at `$D05D` |
| `$D138` | 5 | inline after `InitializeConditionalObject` | 2 `.byte` row(s) of inline data that follow the call | `LoadObjectPositionInline` at `$D134` |
| `$D16E` | 3 | inline after `InitializePrimaryGameplayActor` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D16B` |
| `$D184` | 6 | inline after `ClearPrimaryActorState` | 3 `.byte` row(s) of inline data that follow the call | `LoadBasePositionFieldsInline` at `$D17D` |
| `$D1CB` | 3 | inline after `FinishWindupSequence` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D1C8` |
| `$D21D` | 3 | inline after `AnimatePitchStart` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D21A` |
| `$D262` | 3 | inline after `PitchStartAnimationLoop` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D25F` |
| `$D29E` | 3 | inline after `CheckPitchVerticalLimit` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D29B` |
| `$D31A` | 3 | inline after `SaveBatterAction` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D317` |
| `$D35D` | 3 | inline after `Routine_D355_State1` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D35A` |
| `$D36F` | 3 | inline after `Routine_D367_State2` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D36C` |
| `$D37B` | 3 | inline after `Routine_D373_State3` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D378` |
| `$D480` | 5 | inline after `RunFielderAnimationSequence` | 2 `.byte` row(s) of inline data that follow the call | `LoadObjectPositionInline` at `$D47C` |
| `$D572` | 3 | inline after `SelectRandomMotionOffset` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D56F` |
| `$D578` | 3 | inline after `SelectRandomMotionOffset` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D575` |
| `$D5A6` | 3 | inline after `FinishRandomMotionSequence` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D5A3` |
| `$D5AC` | 3 | inline after `FinishRandomMotionSequence` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D5A9` |
| `$D628` | 5 | inline after `InitializeSecondaryActors` | 2 `.byte` row(s) of inline data that follow the call | `LoadObjectPositionInline` at `$D624` |
| `$D630` | 5 | inline after `InitializeSecondaryActors` | 2 `.byte` row(s) of inline data that follow the call | `LoadObjectPositionInline` at `$D62C` |
| `$D638` | 5 | inline after `InitializeSecondaryActors` | 2 `.byte` row(s) of inline data that follow the call | `LoadObjectPositionInline` at `$D634` |
| `$D65A` | 5 | inline after `InitializeState6Actor` | 2 `.byte` row(s) of inline data that follow the call | `LoadObjectPositionInline` at `$D656` |
| `$D68D` | 5 | inline after `InitializeState4Actor` | 2 `.byte` row(s) of inline data that follow the call | `LoadObjectPositionInline` at `$D689` |
| `$D6BB` | 5 | inline after `InitializeState2Actor` | 2 `.byte` row(s) of inline data that follow the call | `LoadObjectPositionInline` at `$D6B7` |
| `$D79F` | 3 | inline after `WaitForVerticalPositionF6` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D79C` |
| `$D7A5` | 3 | inline after `WaitForVerticalPositionF6` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D7A2` |
| `$D804` | 3 | inline after `WaitForVerticalPosition02` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D801` |
| `$D80A` | 3 | inline after `WaitForVerticalPosition02` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D807` |
| `$D863` | 3 | inline after `ProcessSecondaryObjectStates` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D860` |
| `$D871` | 3 | inline after `CheckObjectState059A` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D86E` |
| `$D87F` | 3 | inline after `CheckObjectState059B` | 1 `.byte` row(s) of inline data that follow the call | `QueueInlineObjectEvent` at `$D87C` |
| `$D9F2` | 5 | inline after `SecondaryObject_TransitionHandler` | 2 `.byte` row(s) of inline data that follow the call | `LoadObjectPositionInline` at `$D9EE` |
| `$DC7A` | 3 | inline after `InitializeObjectEventSequence_DispatchLoop` | 1 `.byte` row(s) of inline data that follow the call | `DispatchInlineObjectCommand` at `$DC77` |
| `$DCAC` | 1 | inline after `DispatchSixObjectEvents_Loop` | 1 `.byte` row(s) of inline data that follow the call | the routine it follows |
| `$DF17` | 3 | inline after `SetupCurrentObjectGeometry` | 1 `.byte` row(s) of inline data that follow the call | the routine it follows |
| `$DF1C` | 3 | inline after `SetupCurrentObjectGeometry` | 1 `.byte` row(s) of inline data that follow the call | the routine it follows |
| `$DF21` | 3 | inline after `SetupCurrentObjectGeometry` | 1 `.byte` row(s) of inline data that follow the call | the routine it follows |
| `$E17B` | 3 | inline after `ObjectStateDispatch_DifferentObject` | 1 `.byte` row(s) of inline data that follow the call | `DispatchInlineObjectCommand` at `$E178` |
| `$E989` | 2 | inline after `FillPpuMemoryAfterValueSaved` | 1 `.byte` row(s) of inline data that follow the call | `SetPpuAddressFromInlineRecord` at `$E986` |
| `$EAC0` | 2 | inline after `RunDisplayTransition` | 1 `.byte` row(s) of inline data that follow the call | `SetPpuAddressFromInlineRecord` at `$EABD` |
| `$EACA` | 2 | inline after `RunDisplayTransition` | 1 `.byte` row(s) of inline data that follow the call | `SetPpuAddressFromInlineRecord` at `$EAC7` |
| `$EAD4` | 2 | inline after `RunDisplayTransition` | 1 `.byte` row(s) of inline data that follow the call | `SetPpuAddressFromInlineRecord` at `$EAD1` |
| `$EADC` | 2 | inline after `RunDisplayTransition` | 1 `.byte` row(s) of inline data that follow the call | `SetPpuAddressFromInlineRecord` at `$EAD9` |
| `$EAF8` | 1 | inline after `WriteFixedPpuSequence` | 1 `.byte` row(s) of inline data that follow the call | the routine it follows |
| `$EAFC` | 6 | inline after `WriteFixedPpuSequence` | 2 `.byte` row(s) of inline data that follow the call | the routine it follows |
| `$ECFC` | 228 | inline after `RenderingAndAnimationData_EC1C` | 15 `.byte` row(s) of inline data that follow the call | the routine it follows |
| `$F99D` | 88 | inline after `FrameOamTemplate_F94D` | 6 `.byte` row(s) of inline data that follow the call | the routine it follows |

## 16. Notes on the Disassembly

- The source is **21,626 lines** and thoroughly annotated with symbolic names for nearly every routine, table, and data block — there are no generic `Label_Cxxxx` placeholders.
- Numerous routines are followed by inline `.byte` data blocks consumed by `QueueInlineObjectEvent`, `CopyInlineDisplayRecord`, or `ProcessInlinePpuStream`; these are intentionally left as raw bytes and marked in comments.
- The PRG is a single 16 KB bank at $C000–$FFFF; calls to $Dxxx/$Exxx/$Fxxx targets are all within the same bank (no bank switching).
- Build verification: `make` in this folder produces `reconstructed.nes`, compared whole-ROM against `rom.nes`.

## Power-on flow analysis

Derived from the disassembly by `_tools/derive_poweron.py`; the call graph is walked from the reset entry.


---

## Entry-point naming

Every `jsr`/`jmp` target in this project now carries a semantic name;
**none** is left in the address-derived `Sub_CXXX` form.  The last one,
`Sub_C036`, was a second label at `$C036` sitting on top of the project's
own `CalculateRandomizedPitchMotion` label; the duplicate definition is
gone and the one call site (`jsr` at `$D256`) now names the routine
directly.  The routine computes a randomized signed pitch-motion value
from the random state at `$0539`.