diff --git a/src/filemenu/filemenu_common.c b/src/filemenu/filemenu_common.c index 6e9f89b4ba..5e587c615d 100644 --- a/src/filemenu/filemenu_common.c +++ b/src/filemenu/filemenu_common.c @@ -1013,15 +1013,16 @@ void filemenu_draw_contents_copy_arrow(MenuPanel* menu, s32 baseX, s32 baseY, s3 } } -// TODO bad match, look into void func_PAL_8002B574(void); // TODO identify +// TODO bad match, look into void filemenu_init(s32 arg0) { MenuPanel** panelIt; MenuPanel* menu; s32 i; - DMA_COPY_SEGMENT(ui_images); + DMA_COPY_SEGMENT(ui_images_filemenu_pause); + for (i = 0; i < ARRAY_COUNT(filemenu_cursorHudElemID); i++) { filemenu_cursorHudElemID[i] = hud_element_create(filemenu_cursor_hudElemScripts[i]); hud_element_set_flags(filemenu_cursorHudElemID[i], HUD_ELEMENT_FLAG_DROP_SHADOW | HUD_ELEMENT_FLAG_80); @@ -1075,7 +1076,7 @@ void filemenu_init(s32 arg0) { menu = filemenu_menus[0]; filemenu_currentMenu = 0; - if (!arg0) { + if (arg0 == 0) { menu->page = 0; } else { menu->page = 2; diff --git a/src/pause/pause_main.c b/src/pause/pause_main.c index 054c988672..02b5bcb4b8 100644 --- a/src/pause/pause_main.c +++ b/src/pause/pause_main.c @@ -613,7 +613,7 @@ void pause_init(void) { MenuPanel** menuPanels; s32 i; - DMA_COPY_SEGMENT(ui_images); + DMA_COPY_SEGMENT(ui_images_filemenu_pause); for (i = 0; i < ARRAY_COUNT(gPauseIconScripts); i++) { gPauseCommonIconIDs[i] = hud_element_create(gPauseIconScripts[i]); diff --git a/tools/build/configure.py b/tools/build/configure.py index 20b7fed1c3..0714408951 100755 --- a/tools/build/configure.py +++ b/tools/build/configure.py @@ -385,6 +385,8 @@ class Configure: modes.extend( [ "bin", + "rodatabin", + "textbin", "yay0", "img", "vtx", @@ -501,11 +503,13 @@ class Configure: c_maps: bool = False, ): import segtypes - import segtypes.common.c + import segtypes.common.asm import segtypes.common.bin + import segtypes.common.c import segtypes.common.data import segtypes.common.group - import segtypes.common.asm + import segtypes.common.rodatabin + import segtypes.common.textbin import segtypes.n64.header import segtypes.n64.img import segtypes.n64.palette @@ -801,7 +805,11 @@ class Configure: "pal_inc_c", vars, ) - elif isinstance(seg, segtypes.common.bin.CommonSegBin): + elif ( + isinstance(seg, segtypes.common.bin.CommonSegBin) + or isinstance(seg, segtypes.common.textbin.CommonSegTextbin) + or isinstance(seg, segtypes.common.rodatabin.CommonSegRodatabin) + ): build(entry.object_path, entry.src_paths, "bin") elif isinstance(seg, segtypes.n64.yay0.N64SegYay0): compressed_path = entry.object_path.with_suffix("") # remove .o diff --git a/tools/splat/.github/workflows/black.yml b/tools/splat/.github/workflows/black.yml new file mode 100644 index 0000000000..138bd3ad6f --- /dev/null +++ b/tools/splat/.github/workflows/black.yml @@ -0,0 +1,23 @@ +name: black + +on: + push: + pull_request: + +jobs: + black_checks: + runs-on: ubuntu-latest + name: black + steps: + - uses: actions/checkout@v1 + - name: Set up Python 3.8 + uses: actions/setup-python@v1 + with: + python-version: 3.8 + - name: Install Dependencies + run: | + pip install black + pip install -r requirements.txt + pip install types-PyYAML + - name: black + run: black --check . diff --git a/tools/splat/.github/workflows/mypy.yml b/tools/splat/.github/workflows/mypy.yml index 98c16b84c0..ba18d96f27 100644 --- a/tools/splat/.github/workflows/mypy.yml +++ b/tools/splat/.github/workflows/mypy.yml @@ -5,7 +5,7 @@ on: pull_request: jobs: - checks: + mypy_checks: runs-on: ubuntu-latest name: mypy steps: @@ -17,23 +17,7 @@ jobs: - name: Install Dependencies run: | pip install mypy - pip install black pip install -r requirements.txt pip install types-PyYAML - name: mypy run: mypy --show-column-numbers --hide-error-context . - - name: black - run: black --check . - unit_tests: - runs-on: ubuntu-latest - steps: - - name: Checkout - uses: actions/checkout@v1 - - name: Set up Python 3.8 - uses: actions/setup-python@v1 - with: - python-version: 3.8 - - name: Install Dependencies - run: pip install -r requirements.txt - - name: Run unit tests - run: sh run_tests.sh diff --git a/tools/splat/.github/workflows/publish_docs_to_wiki.yml b/tools/splat/.github/workflows/publish_docs_to_wiki.yml new file mode 100644 index 0000000000..41a15b23a5 --- /dev/null +++ b/tools/splat/.github/workflows/publish_docs_to_wiki.yml @@ -0,0 +1,54 @@ +# Based on script from https://github.com/orgs/community/discussions/25929 + +name: Publish docs to Wiki + +# Trigger this action only if there are changes pushed to the docs/** directory under the main branch +on: + push: + paths: + - docs/** # This includes all sub folders + branches: + - main # This can be changed to any branch of your preference + +jobs: + publish_docs_to_wiki: + name: Publish docs to Wiki + runs-on: ubuntu-latest + steps: + # Clone the wiki repository + - name: Checkout Wiki repository + uses: actions/checkout@v4 + with: + repository: ${{ github.event.repository.owner.name }}/${{ github.event.repository.name }}.wiki + path: wiki_repo + + # Clone the main repository + - name: Checkout main repository + uses: actions/checkout@v4 + with: + repository: ${{ github.event.repository.owner.name }}/${{ github.event.repository.name }} + path: splat_repo + + - name: Get the new Wiki files + run: | + cd wiki_repo + rm *.md + cp ../splat_repo/docs/* . + + # `git log -1 --pretty=%aN` prints the current commit's author name + # `git log -1 --pretty=%aE` prints the current commit's author mail + - name: Stage new files + run: | + cd wiki_repo + git config user.name $(git log -1 --pretty=%aN) + git config user.email $(git log -1 --pretty=%aE) + git add . + + # `git diff-index --quiet HEAD` returns non-zero if there are any changes. + # This allows to avoid making a commit/push if there are no changes to the Wiki files + + # `git log -1 --pretty=%B` prints the current commit's message + - name: Push new files to the Wiki + run: | + cd wiki_repo + git diff-index --quiet HEAD || (git commit -m "$(git log -1 --pretty=%B)" && git push) diff --git a/tools/splat/.github/workflows/unit_tests.yml b/tools/splat/.github/workflows/unit_tests.yml new file mode 100644 index 0000000000..9cdb1f5da7 --- /dev/null +++ b/tools/splat/.github/workflows/unit_tests.yml @@ -0,0 +1,20 @@ +name: unit_tests + +on: + push: + pull_request: + +jobs: + unit_tests: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v1 + - name: Set up Python 3.8 + uses: actions/setup-python@v1 + with: + python-version: 3.8 + - name: Install Dependencies + run: pip install -r requirements.txt + - name: Run unit tests + run: sh run_tests.sh diff --git a/tools/splat/.gitrepo b/tools/splat/.gitrepo index 7a5d8a880b..22f18caca7 100644 --- a/tools/splat/.gitrepo +++ b/tools/splat/.gitrepo @@ -5,8 +5,8 @@ ; [subrepo] remote = https://github.com/ethteck/splat.git - branch = master - commit = aab26aab63c40fe0bffeb21bf27677881bdb6910 - parent = 943a5d67594b76f0d7f030ae9fc613e7c5fe046c + branch = main + commit = d6490bb877f692f5e20a7846cabd5f793b314054 + parent = c829fde77b3ccc15761582437966317d3d5b13d6 method = merge cmdver = 0.4.5 diff --git a/tools/splat/CHANGELOG.md b/tools/splat/CHANGELOG.md index 9389540fee..422a8dbe88 100644 --- a/tools/splat/CHANGELOG.md +++ b/tools/splat/CHANGELOG.md @@ -1,6 +1,132 @@ # splat Release Notes +### 0.19.0: vram_classes + +* New top-level yaml feature: `vram_classes`. This allows you to make common definitions for vram locations that can be applied to multiple segments. Please see the [documentation](docs/VramClasses.md) for more details! + * Renamed `ld_use_follows` to `ld_use_symbolic_vram_addresses` to more accurately describe what it's doing + * Renamed `vram_of_symbol` segment option to `vram_symbol` to provide consistency between the segment-level option and the vram class field. + * Removed `appears_after_overlays_addr` symbol_addrs option in favor of specifying this behavior with `vram_classes` +* Removed `dead` symbol_addrs option +* A warning is now emitted when the `sha1` top-level yaml option is not provided. Adding this is highly recommended, as it prevents errors using splat in which the wrong binary is provided. + +### 0.18.3 + +* splat now will emit a `FILL(0)` statement on each segment of a linker script by default, to customize this behavior use the `ld_fill_value` yaml option or the per-segment `ld_fill_value` option. +* New yaml option: `ld_fill_value` + * Allows to specify the value of the `FILL` statement generated on every segment of the linker script. + * It must be either an integer, which will be used as the parameter for the `FILL` statement, or `null`, which tells splat to not emit `FILL` statements. + * This behavior can be customized per segment too. +* New per segment option: `ld_fill_value` + * Allows to specify the value of the `FILL` statement generated for this specific top-level segment of the linker script, ignoring the global configuration. + * If not set, then the global configuration is used. + +### 0.18.2 + +* Fix rodata migration for `.rdata` sections (and other rodata sections that don't use the name `.rodata`) +* `spimdisasm` 1.18.0 or above is now required. + +### 0.18.1 + +* New yaml options: `check_consecutive_segment_types` + * Allows to turn off checking for segment types not being in a consecutive order +* New option for segments: `linker_section_order` and `linker_section` + * `linker_section_order`: Allows overriding the section order used for linker script generation. Useful when a section of a file is not between the other sections of the same type in the ROM, for example a file having its data section between other files's rodata. + * `linker_section`: Allows to override the `.section` directive that will be used when generating the disassembly of the corresponding section, without needing to write an extension segment. This also affects the section name that will be used during link time. Useful for sections with special names, like an executable section named `.start` + +### 0.18.0 + +* `symbol_addrs` parsing checks: + * Enforce lines contain a single `;` + * Enforce no duplicates (same vram, same rom) + +### 0.17.3 + +* Move wiki to the `docs` folder +* Added the ability to specify `find_file_boundaries` on a per segment basis +* Fix `cpp` segment not symbolizing rodata symbols properly + +### 0.17.2 + +* Added more support for PS2 elf files + +### 0.17.1 + +* New yaml options: `ld_sections_allowlist` and `ld_sections_denylist` + * `ld_sections_allowlist`: A list of sections to preserve during link time. It can be useful to preserve debugging sections. + * `ld_sections_denylist`: A list of sections to discard during link time. It can be useful to avoid using the wildcard discard. Note that this option does not turn off `ld_discard_section`. + +### 0.17.0 + +* BREAKING: Linker script generation now imposes the specified `section_order`, which may not completely reflect the yaml order. + * In case this new linker script generation can't be properly adapted to a repo, the old generation can be reenabled by using the `ld_legacy_generation` flag as a temporary solution. Keep in mind this option may be removed in the future. +* New yaml options related to linker script generation: `ld_partial_linking`, `ld_partial_scripts_path`, `ld_partial_build_segments_path`, `elf_path`, `ld_dependencies` + * `ld_partial_linking`: Changes how the linker script is generated, allowing partially linking each segment. This allows for faster linking times when making changes to files at the cost of a slower build time from a clean build and loosing filepaths in the mapfile. This is also known as "incremental linking". This option requires both `ld_partial_scripts_path` and `ld_partial_build_segments_path`. + * `ld_partial_scripts_path`: Folder were each intermediary linker script will be written to. + * `ld_partial_build_segments_path`: Folder where the built partially linked segments will be placed by the build system. + * `elf_path`: Path to the final elf target. + * `ld_dependencies`: Generate a dependency file for every linker script generated, including the main linker script and the ones for partial linking. Dependency files will have the same path and name as the corresponding linker script, but changing the extension to `.d`. Requires `elf_path` to be set. +* New misc yaml options: `asm_function_alt_macro` and `ique_symbols` + * `asm_function_alt_macro`: Allows to use a different label on symbols that are in the middle of functions (that are not branch targets of any kind) than the one used for the label for functions, allowing for alternative function entrypoints. + * `ique_symbols` Automatically fills libultra symbols that are exclusive for iQue. This option is ignored if platform is not N64. +* New "incbin" segments: `textbin`, `databin` and `rodatabin` + * Allows to specify binary blobs to be linked in a specific section instead of the data default. + * If a `textbin` section has a corresponding `databin` and/or `rodatabin` section with the same name then those will be included in the same generated assembly file. + * If a known symbol matches the vram of a incbin section then it will be emitted properly, allowing for better integration with the rest of splat's symbol system. +* `spimdisasm` 1.17.0 or above is now required. + +### 0.16.10 + +* Produce an error if subsegments do not have an ascending vram order. + * This can happen because bss subsegments need their vram to be specified explicitly. + +### 0.16.9 + +* Add command line argument `--disassemble-all`, which has the same effect as the `disassemble_all` yaml option so will disamble already matched functions as well as migrated data. + * Note: the command line argument takes precedence over the yaml, so will take effect even if the yaml option is set to false. + +### 0.16.8 + +* Avoid ignoring the `align` defined in a segment for `code` segments + +### 0.16.7 + +* Use `pylibyaml` to speed-up yaml parsing + +### 0.16.6 + +* Add option `ld_rom_start`. + * Allows offsetting rom address linker symbols by some arbitrary value. + * Useful for SN64 games which often have rom addresses offset by 0xB0000000. + * Defaults to 0. + +### 0.16.5 + +* Add option `segment_symbols_style`. + * Allows changing the style of the generated segment symbols in the linker script. + * Possible values: + * `splat`: The current style for segment symbols. + * `makerom`: Style that aims to be compatible with makerom generated symbols. + * Defaults to `splat`. + +### 0.16.4 + +* Add `get_section_flags` method to the `Segment` class. + * Useful for providing linker section flags when creating a custom section when making splat extensions. + * This may be necessary for some custom section types, because sections unrecognized by the linker will not link its data properly. + * More info about section flags: + +### 0.16.3 + +* Add `--stdout-only` flag. Redirects the progress bar output to `stdout` instead of `stderr`. +* Add a check to prevent relocs with duplicated rom addresses. +* Check empty functions only have 2 instructions before autodecompiling them. + +### 0.16.2 + +* Add option `disassemble_all`. If enabled then already matched functions and migrated data will be disassembled to files anyways. + ### 0.16.1 + * Various changes so that series of image and palette subsegments can have `auto` rom addresses (as long as the first can find its rom address from the parent segment or its own definition) ### 0.16.0 @@ -429,10 +555,10 @@ Internally, there's a new Symbol class which stores information about a symbol a ## 0.5 The Rename Update * n64splat name changed to splat - * Some refactoring was done to support other platforms besides n64 in the future + * Some refactoring was done to support other platforms besides n64 in the future * New `platform` option, which defaults to `n64` * This will cause breaking changes in custom segments, so please refer to one of the changes in one of the n64 base segments for details -* Support for custom artifact paths +* Support for custom artifact paths * New `undefined_syms_auto_path` option * New `undefined_funcs_auto_path` option * New `cache_path` option diff --git a/tools/splat/README.md b/tools/splat/README.md index de7abc7c8c..219be683b3 100644 --- a/tools/splat/README.md +++ b/tools/splat/README.md @@ -1,7 +1,7 @@ # splat A binary splitting tool to assist with decompilation and modding projects -Currently, only N64 and PSX binaries are supported. +Currently, only N64, PSX, and PS2 binaries are supported. Please check out the [wiki](https://github.com/ethteck/splat/wiki) for more information including [examples](https://github.com/ethteck/splat/wiki/Examples) of projects that use splat. diff --git a/tools/splat/create_config.py b/tools/splat/create_config.py index cf34481362..92898589cf 100755 --- a/tools/splat/create_config.py +++ b/tools/splat/create_config.py @@ -4,15 +4,16 @@ import argparse import sys from pathlib import Path -from segtypes.gc.rarc import GcSegRarc from util.gc import gcinfo - from util.n64 import find_code_length, rominfo +from util.psx import psxexeinfo parser = argparse.ArgumentParser( - description="Create a splat config from an N64 ROM or a GameCube disc image." + description="Create a splat config from an N64 ROM, PSX executable, or a GameCube disc image." +) +parser.add_argument( + "file", help="Path to a .z64/.n64 ROM, PSX executable, or .iso/.gcm GameCube image" ) -parser.add_argument("file", help="Path to a .z64/.n64 ROM or .iso/.gcm GameCube image") def main(file_path: Path): @@ -31,6 +32,12 @@ def main(file_path: Path): # Check for GC disc image if int.from_bytes(file_bytes[0x1C:0x20], byteorder="big") == 0xC2339F3D: create_gc_config(file_path, file_bytes) + return + + # Check for PSX executable + if file_bytes[0:8] == b"PS-X EXE": + create_psx_config(file_path, file_bytes) + return def create_n64_config(rom_path: Path): @@ -45,25 +52,50 @@ sha1: {rom.sha1} options: basename: {basename} target_path: {rom_path.with_suffix(".z64")} + elf_path: build/{basename}.elf base_path: . - compiler: {rom.compiler} - find_file_boundaries: True - header_encoding: {rom.header_encoding} platform: n64 - # undefined_funcs_auto: True - # undefined_funcs_auto_path: undefined_funcs_auto.txt - # undefined_syms_auto: True - # undefined_syms_auto_path: undefined_syms_auto.txt - # symbol_addrs_path: symbol_addrs.txt + compiler: {rom.compiler} + # asm_path: asm # src_path: src # build_path: build - # extensions_path: tools/splat_ext - # mips_abi_float_regs: o32 + # create_asm_dependencies: True + + ld_script_path: {basename}.ld + ld_dependencies: True + + find_file_boundaries: True + header_encoding: {rom.header_encoding} + + o_as_suffix: True + use_legacy_include_asm: False + mips_abi_float_regs: o32 + + asm_function_macro: glabel + asm_jtbl_label_macro: jlabel + asm_data_macro: dlabel + # section_order: [".text", ".data", ".rodata", ".bss"] # auto_all_sections: [".data", ".rodata", ".bss"] + + symbol_addrs_path: + - symbol_addrs.txt + reloc_addrs_path: + - reloc_addrs.txt + + # undefined_funcs_auto_path: undefined_funcs_auto.txt + # undefined_syms_auto_path: undefined_syms_auto.txt + + extensions_path: tools/splat_ext + + # string_encoding: ASCII + # data_string_encoding: ASCII + rodata_string_guesser_level: 2 + data_string_guesser_level: 2 # libultra_symbols: True # hardware_regs: True + # gfx_ucode: # one of [f3d, f3db, f3dex, f3dexb, f3dex2] """ first_section_end = find_code_length.run(rom_bytes, 0x1000, rom.entry_point) @@ -187,6 +219,102 @@ segments: f.write(segments) +def create_psx_config(exe_path: Path, exe_bytes: bytes): + exe = psxexeinfo.PsxExe.get_info(exe_path, exe_bytes) + basename = exe_path.name.replace(" ", "").lower() + + header = f"""\ +name: {exe_path.name} +sha1: {exe.sha1} +options: + basename: {basename} + target_path: {exe_path} + base_path: . + platform: psx + compiler: GCC + + # asm_path: asm + # src_path: src + # build_path: build + # create_asm_dependencies: True + + ld_script_path: {basename}.ld + + find_file_boundaries: False + gp_value: 0x{exe.initial_gp:08X} + + o_as_suffix: True + use_legacy_include_asm: False + + asm_function_macro: glabel + asm_jtbl_label_macro: jlabel + asm_data_macro: dlabel + + section_order: [".rodata", ".text", ".data", ".bss"] + # auto_all_sections: [".data", ".rodata", ".bss"] + + symbol_addrs_path: + - symbol_addrs.txt + reloc_addrs_path: + - reloc_addrs.txt + + # undefined_funcs_auto_path: undefined_funcs_auto.txt + # undefined_syms_auto_path: undefined_syms_auto.txt + + extensions_path: tools/splat_ext + + subalign: 2 + + string_encoding: ASCII + data_string_encoding: ASCII + rodata_string_guesser_level: 2 + data_string_guesser_level: 2 +""" + + segments = f"""\ +segments: + - name: header + type: header + start: 0x0 + + - name: main + type: code + start: 0x800 + vram: 0x{exe.destination_vram:X} + bss_size: 0x{exe.bss_size:X} + subsegments: +""" + text_offset = exe.text_offset + if text_offset != 0x800: + segments += f"""\ + - [0x800, rodata, 800] +""" + segments += f"""\ + - [0x{text_offset:X}, asm, {text_offset:X}] +""" + + if exe.data_vram != 0 and exe.data_size != 0: + data_offset = exe.data_offset + segments += f"""\ + - [0x{data_offset:X}, data, {data_offset:X}] +""" + + if exe.bss_size != 0: + segments += f"""\ + - {{ start: 0x{exe.size:X}, type: bss, name: {exe.bss_vram:X}, vram: 0x{exe.bss_vram:X} }} +""" + + segments += f"""\ + - [0x{exe.size:X}] +""" + + out_file = f"{basename}.yaml" + with open(out_file, "w", newline="\n") as f: + print(f"Writing config to {out_file}") + f.write(header) + f.write(segments) + + if __name__ == "__main__": args = parser.parse_args() main(Path(args.file)) diff --git a/tools/splat/disassembler/spimdisasm_disassembler.py b/tools/splat/disassembler/spimdisasm_disassembler.py index c3e49a7fde..335c9d2c87 100644 --- a/tools/splat/disassembler/spimdisasm_disassembler.py +++ b/tools/splat/disassembler/spimdisasm_disassembler.py @@ -8,7 +8,7 @@ from typing import Set class SpimdisasmDisassembler(disassembler.Disassembler): # This value should be kept in sync with the version listed on requirements.txt - SPIMDISASM_MIN = (1, 16, 0) + SPIMDISASM_MIN = (1, 18, 0) def configure(self, opts: SplatOpts): # Configure spimdisasm @@ -80,6 +80,7 @@ class SpimdisasmDisassembler(disassembler.Disassembler): spimdisasm.common.GlobalConfig.GP_VALUE = opts.gp spimdisasm.common.GlobalConfig.ASM_TEXT_LABEL = opts.asm_function_macro + spimdisasm.common.GlobalConfig.ASM_TEXT_ALT_LABEL = opts.asm_function_alt_macro spimdisasm.common.GlobalConfig.ASM_JTBL_LABEL = opts.asm_jtbl_label_macro spimdisasm.common.GlobalConfig.ASM_DATA_LABEL = opts.asm_data_macro spimdisasm.common.GlobalConfig.ASM_TEXT_END_LABEL = opts.asm_end_label @@ -102,12 +103,13 @@ class SpimdisasmDisassembler(disassembler.Disassembler): opts.allow_data_addends ) - spimdisasm.common.GlobalConfig.ASM_GENERATED_BY = opts.asm_generated_by - spimdisasm.common.GlobalConfig.DISASSEMBLE_UNKNOWN_INSTRUCTIONS = ( opts.disasm_unknown ) + if opts.compiler == compiler.GCC and opts.platform == "ps2": + rabbitizer.config.toolchainTweaks_treatJAsUnconditionalBranch = False + def check_version(self, skip_version_check: bool, splat_version: str): if not skip_version_check and spimdisasm.__version_info__ < self.SPIMDISASM_MIN: log.error( diff --git a/tools/splat/disassembler_section.py b/tools/splat/disassembler_section.py index 2eb745a32a..b9e1cada0d 100644 --- a/tools/splat/disassembler_section.py +++ b/tools/splat/disassembler_section.py @@ -1,12 +1,9 @@ -import spimdisasm -from util import symbols -from typing import Optional, Set, Tuple -from segtypes.segment import Segment -from util import log, options, symbols - - from abc import ABC, abstractmethod -from typing import Callable +from typing import Optional + +import spimdisasm + +from util import options, symbols class DisassemblerSection(ABC): diff --git a/tools/splat/docs/Adding-Symbols.md b/tools/splat/docs/Adding-Symbols.md new file mode 100644 index 0000000000..8bb0debe1d --- /dev/null +++ b/tools/splat/docs/Adding-Symbols.md @@ -0,0 +1,136 @@ +Symbols (i.e. labelling a function or variable) are controlled by the `symbols_addrs.txt` file. + +The format for defining symbols is: + +```ini +symbol = address; // option1:value1 option2:value2 +``` +e.g. +```ini +osInitialize = 0x801378C0; // type:func +``` + +:information_source: The file used can be overridden via the `symbol_addrs_path` setting in the global `options` section of the splat yaml. This option can also accept a list of paths, allowing for symbols to be organized in multiple files. + +## symbol + +This is the name of the symbol and can be any valid C variable name, e.g. `myCoolFunction` or `gReticulatedSplineCounter` + +## address + +This is the VRAM address expressed in hexadecimal, e.g. `0x80001050` + +## options + +An optional `key:pair` list of settings, note that each option should be separated by whitespace, but there should be no whitespace between the key:value pairs themselves. + +### `type` + +Override splat's automatic type detection, possible values are: +- `func`: Functions +- `jtbl`: Jumptables +- `jtbl_label`: Jumptables labels (inside functions) +- `label`: Branch labels (inside functions) +- `s8`, `u8`: To specify data/rodata to be disassembled as `.byte`s +- `s16`, `u16`: To specify data/rodata to be disassembled as `.short`s +- `s32`, `u32`: To specify data/rodata to be disassembled as `.word`s (the default) +- `s64`, `u64`: :man_shrugging: +- `f32`, `Vec3f`: To specify data/rodata to be disassembled as `.float`s +- `f64`: To specify data/rodata to be disassembled as `.double`s +- `asciz`, `char*`, `char`: C strings (disassembled as `.asciz`) +- Any custom type starting with a capital letter (will default to `.word`s) + +Any other type will produce an error. + +**Example:** +```ini +minFrameSize = 0x80241D08; // type:s32 +``` + +### `size` + +The size of the function or the size of the data depending on the type of the symbol. It specifies a size in bytes. e.g. `size:0x10`. + +**Example:** +```ini +RawHuffmanTable = 0x8022E0E0; // type:symbol size:0x100 +``` + +### `rom` + +The ROM offset for the symbol, useful (potentially mandatory) for symbols in overlays where multiple symbols could share the same VRAM address. + +**Example:** +```ini +create_particle_effect = 0x802D5F4C; // type:func rom:0x6E75FC +``` + +### `segment` + +Allows specifying to which specific segment this symbol belongs to, useful to disambiguate symbols from segments that share the same VRAM address. This name must be the same as the name of a segment listed in the yaml. + +**Example:** +```ini +sMenuTexture = 0x06004040; // segment:menu_assets +``` + +### `name_end` + +Emits a symbol after the end of the data of the current symbol. Useful to reference the end of an assembly symbol, like RSP data. + +**Example:** +```ini +rspbootTextStart = 0x80084690; // name_end:rspbootTextEnd +``` + +### `defined` + +Forces the symbol to be defined - i.e. prevent it from appearing in `undefined_syms_auto.txt` should splat not encounter the symbol during the symbol detection phase. + +**Example:** +```ini +__osDpDeviceBusy = 0x8014B3D0; // defined:true +``` + +### `extract` + +TBD + +### `ignore` + +Prevents an address from being symbolized and referenced. Useful to get a finer control over the disassembled output. + +**Example:** +```ini +D_A0000000 = 0xA0000000; // ignore:true +``` + +It can also be combined with the `size` attribute to avoid a range of addresses of being symbolized. + +**Example:** +```ini +D_80000000 = 0x80000000; // ignore:true size:0x10 +``` + +### `force_migration` and `force_not_migration` + +Grants a finer control over the automatic rodata migration to functions. This may be required because of the migration heuristic failing to migrate (or to not migrate) a symbol, producing a disordered rodata section. Forcing the migration of a rodata symbol to a function will only work if that function references said rodata symbol. Forcing the not-migration of a rodata symbol always works. + +This attribute is ignored if the `migrate_rodata_to_functions` option is disabled. + +**Example:** +```ini +jtbl_800B13D0 = 0x800B13D0; // type:jtbl force_migration:True +STR_800B32A8 = 0x800C9520; // type:asciz force_not_migration:True +``` + +### `allow_addend` and `dont_allow_addend` + +Allows this symbol to reference (or not reference) other symbols with an addend. + +This attribute overrides the global `allow_data_addends` option. + +**Example:** +```ini +aspMainTextStart = 0x80084760; // dont_allow_addend:True +``` diff --git a/tools/splat/docs/Advanced.md b/tools/splat/docs/Advanced.md new file mode 100644 index 0000000000..fe9b4974fb --- /dev/null +++ b/tools/splat/docs/Advanced.md @@ -0,0 +1,7 @@ +## Writing custom segment handler + +The following list contains examples of custom segments: + +- [RNC](https://github.com/mkst/sssv/blob/master/tools/splat_ext/rnc.py) +- [Vtx](https://github.com/mkst/sssv/blob/master/tools/splat_ext/sssv_vtx.py) +- [Multiple](https://github.com/pmret/papermario/tree/main/tools/splat_ext) diff --git a/tools/splat/docs/Configuration.md b/tools/splat/docs/Configuration.md new file mode 100644 index 0000000000..6ee550062d --- /dev/null +++ b/tools/splat/docs/Configuration.md @@ -0,0 +1,612 @@ +Splat has various options for configuration, all of which are listed under the `options` section of the yaml file. + +## Project configuration + +### base_path + +Path that all other configured paths are relative to. + +#### Usage + +```yaml +base_path: path/to/base/folder +``` + +#### Default + +`.` *(Current directory)* + + +### target_path + +Path to target binary. + +#### Usage + +```yaml +target_path: path/to/target/binary +``` + +### elf_path + +Path to the final elf target + +#### Default +Path to the binary that was used as the input to `create_config.py` + + +### platform + +The target platform for the binary. Options are +- `n64` (Nintendo 64) +- `psx` (PlayStation 1) +- `ps2` (PlayStation 2) +- `gc` (GameCube) + +#### Usage +```yaml +platform: psx +``` + + +### compiler + +Compiler used to build the binary. + +splat recognizes the following compilers, and it will adapt it behavior accordingly for them, but unknown compilers can be passed as well: +- GCC +- SN64 +- IDO + +#### Usage +```yaml +compiler: IDO +``` + +#### Default +`ido` + + +### endianness + +Determines the endianness of the target binary. If not set, the endiannesss will be guessed from the selected platform. + +Valid values: +- big +- little + + +### section_order + +Determines the default section order of the target binary. This can be overridden per-segment. + +Expects a list of strings. + + +### generated_c_preamble + +String that is placed before the contents of newly-generated `.c` files. + +#### Usage + +```yaml +generated_c_preamble: #include "header.h" +``` + +#### Default + +`#include "common.h"` + + +### generated_s_preamble + +String that is placed before the contents of newly-generated assembly (`.s`) files. + +#### Usage + +```yaml +generated_s_preamble: .set fp=64 +``` + + +### o_as_suffix + +Determines whether to replace the suffix of the file to `.o` or to append `.o` to the suffix of the file. + + +### gp_value + +The value of the `$gp` register to correctly calculate offset to `%gp_rel` relocs. + + +### check_consecutive_segment_types + +By default splat will check and error if there are any non consecutive segment types. +This option disables said feature. + +#### Usage + +```yaml +# Disable checking for non-consecutive segments +check_consecutive_segment_types: False +``` + + +## Paths + + +### asset_path + +Path to output split asset files. + +#### Usage + +```yaml +asset_path: path/to/assets/folder +``` + +#### Default + +`assets` + + +### symbol_addrs_path + +Determines the path to the symbol addresses file(s). A `symbol_addrs` file is to be updated/curated manually and contains addresses of symbols as well as optional metadata such as rom address, type, and more + +It's possible to use more than one file by supplying a list instead of a string + +#### Usage +```yaml +symbol_addrs_path: path/to/symbol_addrs +``` + +#### Default +`symbol_addrs.txt` + + + +### reloc_addrs_paths + + + +### build_path +Path that built files will be found. Used for generation of the linker script. + +#### Usage +```yaml +build_path: path/to/build/folder +``` + +#### Default +`build` + + +### src_path +Path to split `.c` files. + +#### Usage +```yaml +src_path: path/to/src/folder +``` + +#### Default +`src` + + +### asm_path +Path to output split assembly files. + +#### Usage +```yaml +asm_path: path/to/asm/folder +``` + +#### Default +`asm` + + +### data_path + +Determines the path to the asm data directory + + +### nonmatchings_path + +Determines the path to the asm nonmatchings directory + + +### cache_path +Path to splat cache + +#### Usage +```yaml +cache_path: path/to/splat/cache +``` + +#### Default +`.splat_cache` + + +### create_undefined_funcs_auto +If `True`, splat will generate an `undefined_funcs_auto.txt` file. + +#### Usage +```yaml +create_undefined_funcs_auto: False +``` + +#### Default +`True` + + +### undefined_funcs_auto_path +Path to file containing automatically defined functions. + +#### Usage +```yaml +undefined_funcs_auto_path: path/to/undefined_funcs_auto.txt +``` + +#### Default +`undefined_funcs_auto.txt` + + + +### create_undefined_syms_auto +If `True`, splat will generate an `undefined_syms_auto.txt` file. + +#### Usage +```yaml +create_undefined_syms_auto: False +``` + +#### Default +`True` + + +### undefined_syms_auto_path +Path to file containing automatically defined symbols. + +#### Usage +```yaml +undefined_syms_auto_path: path/to/undefined_syms_auto.txt +``` + +#### Default +`undefined_syms_auto.txt` + + +### extensions_path +If you are using splat extension(s), this is the path they will be loaded from. + +#### Usage +```yaml +extensions_path: path/to/extensions/folder +``` + +#### Default +`tools/splat_ext` + + +### lib_path + +Determines the path to library files that are to be linked into the target binary + + +### elf_section_list_path +Path to file containing elf section list. + +#### Usage +```yaml +elf_section_list_path: path/to/elf_sections +``` + +#### Default +`elf_sections.txt` + + +## Linker script + + +### subalign + +Sub-alignment (in bytes) of sections. + +#### Usage +```yaml +subalign: 4 +``` + +#### Default +`16` + + +### auto_all_sections + +TODO + +### ld_script_path + +Path to output ld script. + +#### Usage + +```yaml +ld_script_path: path/to/ld/script.ld +``` + +#### Default + +`{basename}.ld` + + +### ld_symbol_header_path + +Path to output a header containing linker symbols. + +#### Usage +```yaml +ld_symbol_header_path: path/to/linker_symbol_header +``` + +### ld_discard_section + +Determines whether to add a discard section to the linker script + +### ld_section_labels + +Determines the list of section labels that are to be added to the linker script + +### ld_wildcard_sections + +Determines whether to add wildcards for section linking in the linker script (.rodata* for example) + +### ld_use_symbolic_vram_addreses + +Determines whether to use `follows_vram` (segment option) and `vram_symbol` / `follows_classes` (vram_class options) to calculate vram addresses in the linker script. +Enabled by default. If disabled, this uses the plain integer values for vram addresses defined in the yaml. + +### ld_partial_linking + +Change linker script generation to allow partially linking segments. Requires both `ld_partial_scripts_path` and `ld_partial_build_segments_path` to be set. + +### ld_partial_scripts_path + +Folder were each intermediary linker script will be written to. + +### ld_partial_build_segments_path + +Folder where the built partially linked segments will be placed by the build system. + +### ld_dependencies + +Generate a dependency file for every linker script generated. Dependency files will have the same path and name as the corresponding linker script, but changing the extension to `.d`. Requires `elf_path` to be set. + +### ld_legacy_generation + +Legacy linker script generation does not impose the section_order specified in the yaml options or per-segment options. + +### segment_end_before_align + +If enabled, the end symbol for each segment will be placed before the alignment directive for the segment + +### segment_symbols_style + +Controls the style of the auto-generated segment symbols in the linker script. + +Possible values: +- splat +- makerom + + +### ld_rom_start + +Specifies the starting offset for rom address symbols in the linker script. + + +### ld_fill_value + +Allows to specify the value of the `FILL` statement generated on every segment of the linker script. + +It must be either an integer, which will be used as the parameter for the `FILL` statement, or `null`, which tells splat to not emit `FILL` statements. + +This behavior can be customized per segment too. See [ld_fill_value](Segments.md#ld_fill_value) on the Segments section. + +Defaults to 0. + + +## C file options + +### create_c_files + +Determines whether to create new c files if they don't exist + +### auto_decompile_empty_functions + +Determines whether to "auto-decompile" empty functions + +### do_c_func_detection + +Determines whether to detect matched/unmatched functions in existing c files so we can avoid creating `.s` files for already-decompiled functions. + +### c_newline + +Determines the newline char(s) to be used in c files + + +## (Dis)assembly-related options + +### symbol_name_format + +Determine the format that symbols should be named by default + +### symbol_name_format_no_rom + +Same as `symbol_name_format` but for symbols with no rom address + +### find_file_boundaries + +Determines whether to detect and hint to the user about likely file splits when disassembling. + +This setting can also be set on a per segment basis, if you'd like to enable or disable detection for specific segments. This could be useful when you are confident you identified all subsegments in a segment, yet `splat` still hints that subsegments could be split. + +### pair_rodata_to_text + +Determines whether to detect and hint to the user about possible rodata sections corresponding to a text section + +### migrate_rodata_to_functions + +Determines whether to attempt to automatically migrate rodata into functions + +### asm_inc_header + +Determines the header to be used in every asm file that's included from c files + +### asm_function_macro + +Determines the macro used to declare functions in asm files + +### asm_function_alt_macro + +Determines the macro used to declare symbols in the middle of functions in asm files (which may be alternative entries) + +### asm_jtbl_label_macro + +Determines the macro used to declare jumptable labels in asm files + +### asm_data_macro + +Determines the macro used to declare data symbols in asm files + +### asm_end_label + +Determines the macro used at the end of a function, such as endlabel or .end + +### asm_emit_size_directive + +Toggles the .size directive emitted by the disassembler + +### include_macro_inc + +Determines including the macro.inc file on non-migrated rodata variables + +### mnemonic_ljust + +Determines the number of characters to left align before the instruction + +### rom_address_padding + +Determines whether to pad the rom address + +### mips_abi_gpr + +Determines which ABI names to use for general purpose registers + +### mips_abi_float_regs + +Determines which ABI names to use for floating point registers. + +Valid values: +- numeric +- o32 +- n32 +- n64 + +`o32`` is highly recommended, as it provides logically named registers for floating point instructions. +For more info, see https://gist.github.com/EllipticEllipsis/27eef11205c7a59d8ea85632bc49224d + +### add_set_gp_64 + +Determines whether to add ".set gp=64" to asm/hasm files + +### create_asm_dependencies + +Generate `.asmproc.d` dependency files for each C file which still reference functions in assembly files + +### string_encoding + +Global option for rodata string encoding. This can be overriden per segment + +### data_string_encoding + +Global option for data string encoding. This can be overriden per segment + +### rodata_string_guesser_level + +Global option for the rodata string guesser. 0 disables the guesser completely. + +### data_string_guesser_level + +Global option for the data string guesser. 0 disables the guesser completely. + +### allow_data_addends + +Global option for allowing data symbols using addends on symbol references. It can be overriden per symbol + +### disasm_unknown + +Tells the disassembler to try disassembling functions with unknown instructions instead of falling back to disassembling as raw data + +### detect_redundant_function_end + +Tries to detect redundant and unreferenced functions ends and merge them together. This option is ignored if the compiler is not set to IDO. + +### disassemble_all + +Don't skip disassembling already matched functions and migrated sections + + +## N64-specific options + +### header_encoding + +Used to specify what encoding should be used used when parsing the N64 ROM header. + +#### Default + +`ASCII` + + +### gfx_ucode + +Determines the type gfx ucode (used by gfx segments) + +Valid options are: +- f3d +- f3db +- f3dex +- f3dexb +- f3dex2 + +### libultra_symbols + +Use named libultra symbols by default. Those will need to be added to a linker script manually by the user + +### ique_symbols + +Use named libultra symbols by default. Those will need to be added to a linker script manually by the user + +### hardware_regs + +Use named hardware register symbols by default. Those will need to be added to a linker script manually by the user + + +## Gamecube-specific options + +### filesystem_path + +Path where the iso's filesystem will be extracted to + +## Compiler-specific options + +### use_legacy_include_asm +If `True`, generate c files using the longer `INCLUDE_ASM` macro. This is defaulted to `True` to by-default support projects using the longer macro. + +#### Usage +```yaml +use_legacy_include_asm: False +``` + +#### Default +`True` diff --git a/tools/splat/docs/Examples.md b/tools/splat/docs/Examples.md new file mode 100644 index 0000000000..82bf8cb47c --- /dev/null +++ b/tools/splat/docs/Examples.md @@ -0,0 +1,32 @@ +The following is a list of projects known to be using **splat** along with the compilers used: + +## N64 Projects + +- [Aidyn Chronicles](https://github.com/blackgamma7/Aidyn) `unknown` (does not build source) +- [Animal Forest](https://github.com/zeldaret/af) `ido7.1` +- [Banjo Kazooie](https://gitlab.com/banjo.decomp/banjo-kazooie) `ido5.3` +- [Conker's Bad Fur Day](https://github.com/mkst/conker) `ido5.3` +- [Dinosaur Planet](https://github.com/zestydevy/dinosaur-planet) `ido5.3` +- [Dr. Mario 64](https://github.com/AngheloAlf/drmario64) `kmc gcc2.7.2` & `egcs gcc2.91.66` +- [Gauntlet Legends](https://github.com/Drahsid/gauntlet-legends) `kmc gcc2.7.2` (uses old KMC GCC wrapper - do not use for reference) +- [Mario Party 3](https://github.com/PartyPlanner64/mp3) `gcc2.7.2 TBD` +- [Mischief Makers](https://github.com/Drahsid/mischief-makers) `ido5.3` +- [Neon Genesis Evangelion 64](https://github.com/farisawan-2000/evangelion) `kmc gcc2.7.2` +- [Paper Mario](https://github.com/pmret/papermario) `gcc2.8.1` +- [Pokemon Snap](https://github.com/ethteck/pokemonsnap) `ido7.1` +- [Pokemon Stadium](https://github.com/ethteck/pokemonstadium) `ido7.1` +- [Pokémon Puzzle League](https://github.com/AngheloAlf/puzzleleague64) `kmc gcc2.7.2` +- [Rocket Robot on Wheels](https://github.com/RocketRet/Rocket-Robot-On-Wheels) `SN64 (build 970404)` +- [Space Station Silicon Valley](https://github.com/mkst/sssv) `ido5.3` +- [Turok 3](https://github.com/drahsid/turok3) `psyq gcc2.8.0` +- [Yoshi's Story](https://github.com/decompals/yoshis-story) `ido7.1` + +## PS1 Projects + +- [Evo's Space Adventures](https://github.com/mkst/esa) `psyq 4.6 (gcc2.95)` +- [Final Fantasy 7](https://github.com/Drahsid/ffvii) `psyq <= 4.1 (gcc2.7.2)` +- [Silent Hill](https://github.com/Vatuu/silent-hill-decomp) `psyq <= 4.1 (gcc2.7.2) TBD` + +## PS2 Projects + +- [Kingdom Hearts](https://github.com/ethteck/kh1) TBD diff --git a/tools/splat/docs/General-Workflow.md b/tools/splat/docs/General-Workflow.md new file mode 100644 index 0000000000..947f2b305a --- /dev/null +++ b/tools/splat/docs/General-Workflow.md @@ -0,0 +1,179 @@ +This describes an example of how to iteratively edit the splat segments config in order to maximise code and data migration from the binary. + +# 1 Initial configuration + +After successfully following the [Quickstart](https://github.com/ethteck/splat/wiki/Quickstart), you should have an initial configuration like the one below: + +```yaml +- name: main + type: code + start: 0x1060 + vram: 0x80070C60 + follows_vram: entry + bss_size: 0x3AE70 + subsegments: + - [0x1060, asm] + # ... a lot of additional `asm` sections + # This section is found out to contain __osViSwapContext + - [0x25C20, asm, energy_orb_wave] + # ... a lot of additional `asm` sections + - [0x2E450, data] + + - [0x3E330, rodata] + # ... a lot of additional `rodata` sections + - { start: 0x3F1B0, type: bss, vram: 0x800E9C20 } + +- [0x3F1B0, bin] +``` + +## 1.1 Match `rodata` to `asm` sections + +It's good practice to start pairing `rodata` sections with `asm` sections _before_ changing the `asm` sections into `c` files. This is because rodata may need to be explicitly included within the `c` file (via `INCLUDE_RODATA` or `GLOBAL_ASM` macros). + +`splat` provides hints about which `rodata` segments are referenced by which `asm` segments based on references to these symbols within the disassembled functions. + +These messages are output when splitting and look like: + +``` +Rodata segment '3EE10' may belong to the text segment 'energy_orb_wave' + Based on the usage from the function func_0xXXXXXXXX to the symbol D_800AEA10 +``` + +To pair these two sections, simply add the _name_ of the suggested text (i.e. `asm`) segment to the `rodata` segment: + +```yaml +- [0x3EE10, rodata, energy_orb_wave] # segment will be paired with a text (i.e. asm or c) segment named "energy_orb_wave" +``` + +**NOTE:** + +By default `migrate_rodata_to_functions` functionality is enabled. This causes splat to include paired rodata along with the disassembled assembly code, allowing it to be linked via `.rodata` segments from the get-go. This guide assumes that you will disable this functionality until you have successfully paired up the segments. + +### Troubleshooting + +#### Multiple `rodata` segments for a single text segment + +Using the following configuration: +```yaml +# ... +- [0x3E900, rodata] +- [0x3E930, rodata] +# ... +``` + +`splat` outputs a hint that doesn't immediately seem to make sense: + +``` +Rodata segment '3E900' may belong to the text segment '16100' + Based on the usage from the function func_80085DA0 to the symbol jtbl_800AE500 + +Rodata segment '3E930' may belong to the text segment '16100' + Based on the usage from the function func_800862C0 to the symbol jtbl_800AE530 +``` + +This hint tells you that `splat` believes one text segment references two `rodata` sections. This usually means that either the `rodata` should not be split at `0x3E930`, or that there is a missing split in the `asm` at `0x16100`, as a text segment can only have one `rodata` segment. + +If we assume that the rodata split is incorrect, we can remove the extraneous split: + +```yaml +# ... +- [0x3E900, rodata, "16100"] +# ... +``` + +**NOTE:** Splat uses heuristics to determine `rodata` and `asm` splits and is not perfect - false positives are possible and, if in doubt, double-check the assembly yourself before changing the splits. + + +### Multiple `asm` segments referring to the same `rodata` segment + +Sometimes the opposite is true, and `splat` believes two `asm` segments belong to a single `rodata` segment. In this case, you can split the `asm` segment to make sure two files are not paired with the same `rodata`. Note that this too can be a false positive. + + +# 2 Disassemble text, data, rodata + +Let's say you want to start decompiling the subsegment at `0x25C20` (`energy_orb_wave`). Start by replacing the `asm` type with `c`, and then re-run splat. + +```yaml +- [0x25C20, c, energy_orb_wave] +# ... +- [0x3EE10, rodata, energy_orb_wave] +``` + +This will disassemble the ROM at `0x25C20` as code, creating individual `.s` files for each function found. The output will be located in `{asm_path}/nonmatchings/energy_orb_wave/.s`. + +Assuming `data` and `rodata` segments have been paired with the `c` segment, splat will generate `{asm_path}/energy_orb_wave.data.s` and `{asm_path}/energy_orb_wave.rodata.s` respectively. + +Finally, splat will generate a C file, at `{src_path}/energy_orb_wave.c` containing macros that will be used to include all disassembled function assembly. + +**NOTE:** +- the path for where assembly is written can be configured via `asm_path`, the default is `{base_dir}/asm` +- the source code path can be configured via `src_path`, the default is `{base_path}/src` + +## Macros + +The macros to include text/rodata assembly are different for GCC vs IDO compiler: + +**GCC**: `INCLUDE_ASM` & `INCLUDE_RODATA` (text/rodata respectively) +**IDO**: `GLOBAL_ASM` + +These macros must be defined in an included header, which splat currently does not produce. + +For a GCC example, see the [include.h](https://github.com/AngheloAlf/drmario64/blob/master/include/include_asm.h) from the Dr. Mario project. + +For IDO, you will need to use [asm-processor](https://github.com/simonlindholm/asm-processor) in order to include assembly code within the c files. + + +# 3 Decompile text + +This involved back and forth between `.c` and `.s` files: + +- editing the `data.s`, `rodata.s` files to add/fixup symbols at the proper locations +- decompiling functions, declaring symbols (`extern`s) in the `.c` + +The linker script links +- `.text` (only) from the `.o` built from `energy_orb_wave.c` +- `.data` (only) from the `.o` built from `energy_orb_wave.data.s` +- `.rodata` (only) from the `.o` built from `energy_orb_wave.rodata.s` + +# 4 Decompile (ro)data + +Migrate data to the .c file, using raw values, lists or structs as appropriate code. + +Once you have paired the rodata and text segments together, you can enabled `migrate_rodata_to_functions`. This will add the paired rodata into each individual function's assembly file, and therefore, the rodata will end up in the compiled .o file. + +To link the .data/.rodata from the .o built from the .c file (instead of from the .s files), the subsegments must be changed from: + +```yaml +- [0x42100, c, energy_orb_wave] +- [0x42200, data, energy_orb_wave] # extract data at this ROM address as energy_orb_wave.data.s +- [0x42300, rodata, energy_orb_wave] # extract rodata at this ROM address as energy_orb_wave.rodata.s +``` + +to: + +```yaml +- [0x42100, c, energy_orb_wave] +- [0x42200, .data, energy_orb_wave] # take the .data section from the compiled c file named energy_orb_wave +- [0x42300, .rodata, energy_orb_wave] # take the .rodata section from the compiled c file named energy_orb_wave +``` + + +**NOTE:** +If using `auto_all_section` and there are no other `data`/`.data`/`rodata`/`.rodata` in the subsegments in the code segment, the subsegments can also be changed to + +```yaml +- [0x42100, c, energy_orb_wave] +- [0x42200] +``` + +# 5 Decompile bss + +`bss` works in a similar way to data/rodata. However, `bss` is usually discarded from the final binary, which makes it somewhat tricker to migrate. + +The `bss` segment will create assembly files that are full of `space`. The `.bss` segment will link the `.bss` section of the referenced `c` file. + +# 6 Done! + +`.text`, `.data`, `.rodata` and `.bss` are linked from the .o built from `energy_orb_wave.c` which now has everything to match when building + +The assembly files (functions .s, data.s and rodata.s files) can be deleted diff --git a/tools/splat/docs/Home.md b/tools/splat/docs/Home.md new file mode 100644 index 0000000000..33307acb3a --- /dev/null +++ b/tools/splat/docs/Home.md @@ -0,0 +1,25 @@ +### What is splat? + +**splat** is a binary splitting tool, written in Python. Its goal is to support the successful disassembly and then rebuilding of binary data. + +It is the spiritual successor to [n64split](https://github.com/queueRAM/sm64tools/blob/master/n64split.c), originally written to handle N64 ROMs, it now has limited support for PSX and PS2 binaries. + +MIPS code disassembly is handled via [spimdisasm](https://github.com/Decompollaborate/spimdisasm/). + +There are a number of asset types built-in (e.g. various image formats, N64 Vtx data, etc), and it is designed to be simple to extend by writing your own custom types that can do anything you want as part of the **splat** pipeline. + + +### How does it work? + +**splat** takes a [yaml](https://en.wikipedia.org/wiki/YAML) configuration file which tells it *where* and *how* to split a given file. Symbols can be mapped to addresses (and their types provided) via an optional "symbol_addrs" file. + +**splat** runs two distinct phases: scan and split. + +The _scan_ phase makes a first pass over the data and performs the initial disassembly of code and data. During the _split_ phase, information gathered during the _scan_ phase is used and files & data are written out to disk. + +After scanning and splitting, **splat** will output a linker script that can be used as part of re-building the input file. + + +### Sounds great, how do I get started? + +Have a look at the [Quickstart](https://github.com/ethteck/splat/wiki/Quickstart), or check out the [Examples](https://github.com/ethteck/splat/wiki/Examples) page to see projects that are using **splat**. diff --git a/tools/splat/docs/Quickstart.md b/tools/splat/docs/Quickstart.md new file mode 100644 index 0000000000..f8711446e1 --- /dev/null +++ b/tools/splat/docs/Quickstart.md @@ -0,0 +1,153 @@ +> **Note**: This quickstart is written with N64 ROMs in mind, and the assumption that you are using Ubuntu 20.04 either natively, via WSL2 or via Docker. + +For the purposes of this quickstart, we will assume that we are going to split a game called `mygame` and we have the ROM in `.z64` format named `baserom.z64`. + +Create a directory for `~/mygame` and `cd` into it: + +```sh +mkdir -p ${HOME}/mygame && cd ${HOME}/mygame +``` + +Copy the `baserom.z64` file into the `mygame` directory inside your home directory. + +### System packages + +#### Python 3.8 + +Ensure you are have **Python 3.8** or higher installed: + +```sh +$ python3 --version +Python 3.8.10 +``` + +If you get `bash: python3: command not found` install it with the following command: + +```sh +sudo apt-get update && sudo apt-get install -y python3 python3-pip +``` + +#### Git + +Ensure you have **git**: + +```sh +$ git --version +``` + +If you get `bash: git: command not found`, install it with the following command: + +```sh +sudo apt-get update && sudo apt-get install -y git +``` + +## Checkout the repository + +We will clone **splat** into a `tools` directory to keep things organised: + +```sh +git clone https://github.com/ethteck/splat.git tools/splat +``` + +## Python packages + +Run the following to install the prerequisite Python packages: + +```sh +python3 -m pip install -r ./tools/splat/requirements.txt +``` + +## Create a config file for your baserom + +**splat** has a script that will generate a `yaml` file for your ROM. + +```sh +python3 tools/splat/create_config.py baserom.z64 +``` + +The `yaml` file generated will be named based upon the name of the ROM (taken from its header). The example below is for Super Mario 64: + +```yaml +$ cat supermario64.yaml +name: Super Mario 64 (North America) +sha1: 9bef1128717f958171a4afac3ed78ee2bb4e86ce +options: + basename: supermario64 + target_path: baserom.z64 + base_path: . + compiler: IDO + find_file_boundaries: True + # platform: n64 + # undefined_funcs_auto_path: undefined_funcs_auto.txt + # undefined_syms_auto_path: undefined_syms_auto.txt + # symbol_addrs_path: symbol_addrs.txt + # undefined_syms_path: undefined_syms.txt + # asm_path: asm + # src_path: src + # build_path: build + # extensions_path: tools/splat_ext + # auto_all_sections: True +segments: + - name: header + type: header + start: 0x0 + - name: boot + type: bin + start: 0x40 + - name: main + type: code + start: 0x1000 + vram: 0x80246000 + subsegments: + - [0x1000, asm] + - type: bin + start: 0xE6430 + - [0x800000] +``` + +This is a bare-bones configuration and there is a lot of work required to map out the different sections of the ROM. + +## Run splat with your configuration + +```sh +python3 tools/splat/split.py supermario64.yaml +``` + +The output will look something like this: +``` +splat 0.7.10.1 +Loading and processing symbols +Starting scan +..Segment 1000, function at vram 80246DF8 ends with extra nops, indicating a likely file split. +File split suggestions for this segment will follow in config yaml format: + - [0x1E70, asm] + - [0x3C40, asm] + - [0x45E0, asm] + - [0x6FF0, asm] +# < -- snip --> + - [0xE6060, asm] + - [0xE61F0, asm] + - [0xE6200, asm] + - [0xE6260, asm] +.. +Starting split +.... +Split 943 KB (11.24%) in defined segments + header: 64 B (0.00%) 1 split, 0 cached + bin: 4 KB (0.05%) 1 split, 0 cached + code: 939 KB (11.19%) 1 split, 0 cached + unknown: 7 MB (88.76%) from unknown bin files +``` + +Notice that **splat** has found some potential file splits (function start/end with 16 byte alignment padded with nops). + +It's up to you to figure out the layout of the ROM. + + +## Next Steps + +The reassembly of the ROM is currently out of scope of this quickstart, as is switching out the `asm` segments for `c`. + +You can find a general workflow for using `splat` at [General Workflow](https://github.com/ethteck/splat/wiki/General-Workflow) + +Please feel free to improve this guide! diff --git a/tools/splat/docs/Segments.md b/tools/splat/docs/Segments.md new file mode 100644 index 0000000000..c5346e3e32 --- /dev/null +++ b/tools/splat/docs/Segments.md @@ -0,0 +1,312 @@ +# Segments + +The configuration file for **splat** consists of a number of well-defined segments. + +Most segments can be defined as a either a dictionary or a list, however the list syntax is only suitable for simple cases as it does not allow for specifying many of the options a segment type has to offer. + +Splat segments' behavior generally falls under two categories: extraction and linking. Some segments will only do extraction, some will only do linking, some both, and some neither. Generally, segments will describe both extraction and linking behavior. Additionally, a segment type whose name starts with a dot (.) will only focus on linking. + +## `asm` + +**Description:** + +Segments designated Assembly, `asm`, will be disassembled via [spimdisasm](https://github.com/Decompollaborate/spimdisasm) and enriched with Symbols based on the contents of the `symbol_addrs` configuration. + +**Example:** + +```yaml +# as list +- [0xABC, asm, filepath1] +- [0xABC, asm, dir1/filepath2] # this will create filepath2.s inside a directory named dir1 + +# as dictionary +- name: filepath + type: asm + start: 0xABC +``` + +### `hasm` + +**Description:** + +Hand-written Assembly, `hasm`, similar to `asm` except it will not overwrite any existing files. Useful when assembly has been manually edited. + +**Example:** + +```yaml +# as list +- [0xABC, hasm, filepath] + +# as dictionary +- name: filepath + type: hasm + start: 0xABC +``` + +## `bin` + +**Description:** + +The `bin`(ary) segment type is for raw data, or data where the type is yet to be determined, data will be written out as raw `.bin` files. + +**Example:** + +```yaml +# as list +- [0xABC, bin, filepath] + +# as dictionary +- name: filepath + type: bin + start: 0xABC +``` + +## `code` + +**Description:** + +The 'code' segment type, `code` is a group that can have many `subsegments`. Useful to group sections of code together (e.g. all files part of the same overlay). + +**Example:** + +```yaml +# must be a dictionary +- name: main + type: code + start: 0x00001000 + vram: 0x80125900 + subsegments: + - [0x1000, asm, entrypoint] + - [0x1050, c, main] +``` + +## `c` + +**Description:** + +The C code segments have two behaviors: + +- If the target `.c` file does not exist, a new file will be generated with macros to include the original assembly (macros differ for IDO vs GCC compiler). +- Otherwise the target `.c` file is scanned to determine what assembly needs to be extracted from the ROM. + +Assembly that is extracted due to a `c` segment will be written to a `nonmatchings` folder, with one function per file. + +**Example:** + +```yaml +# as list +- [0xABC, c, filepath] + +# as dictionary +- name: filepath + type: c + start: 0xABC +``` + +## `header` + +**Description:** + +This is platform specific; parses the data and interprets as a header for e.g. N64 or PS1 elf. + +**Example:** + +```yaml +# as list +- [0xABC, header, filepath] + +# as dictionary +- name: filepath + type: header + start: 0xABC +``` + +## `data` + +**Description:** + +Data located in the ROM. Extracted as assembly; integer, float and string types will be attempted to be inferred by the disassembler. + +**Example:** + +```yaml +# as list +- [0xABC, data, filepath] + +# as dictionary +- name: filepath + type: data + start: 0xABC +``` + +This will created `filepath.data.s` within the `asm` folder. + +## `.data` + +**Description:** + +Data located in the ROM that is linked from a C file. Use the `.data` segment to tell the linker to pull the `.data` section from the compiled object of corresponding `c` segment. + +**Example:** + +```yaml +# as list +- [0xABC, .data, filepath] + +# as dictionary +- name: filepath + type: .data + start: 0xABC +``` + +**NOTE:** `splat` will not generate any `.data.s` files for these `.` (dot) sections. + +## `rodata` + +**Description:** + +Read-only data located in the ROM, e.g. floats, strings and jump tables. Extracted as assembly; integer, float and string types will be attempted to be inferred by the disassembler. + +**Example:** + +```yaml +# as list +- [0xABC, rodata, filepath] + +# as dictionary +- name: filepath + type: rodata + start: 0xABC +``` + +This will created `filepath.rodata.s` within the `asm` folder. + +## `.rodata` + +**Description:** + +Read-only data located in the ROM, linked to a C file. Use the `.rodata` segment to tell the linker to pull the `.rodata` section from the compiled object of corresponding `c` segment. + +**Example:** + +```yaml +# as list +- [0xABC, .rodata, filepath] + +# as dictionary +- name: filepath + type: .rodata + start: 0xABC +``` + +**NOTE:** `splat` will not generate any `.rodata.s` files for these `.` (dot) sections. + +## `bss` + +**Description:** + +`bss` is where variables are placed that have been declared but are not given an initial value. These sections are usually discarded from the final binary (although PSX binaries seem to include them!). + +Note that the `bss_size` option needs to be set at segment level for `bss` segments to work correctly. + +**Example:** + +```yaml +- { start: 0x7D1AD0, type: bss, name: filepath, vram: 0x803C0420 } +``` + +## `.bss` + +**Description:** + +Links the `.bss` section of the associated `c` file. + +**Example:** + +```yaml +- { start: 0x7D1AD0, type: .bss, name: filepath, vram: 0x803C0420 } +``` + +## Images + +**Description:** + +**splat** supports most of the [N64 image formats](https://n64squid.com/homebrew/n64-sdk/textures/image-formats/): + +- `i`, i.e. `i4` and `i8` +- `ia`, i.e. `ia4`, `ia8`, and `ia16` +- `ci`, i.e. `ci4` and `ci8` +- `rgb`, i.e. `rgba32` and `rgba16` + +These segments will parse the image data and dump out a `png` file. + +**Note:** Using the dictionary syntax allows for richer configuration. + +**Example:** + +```yaml +# as list +- [0xABC, i4, filename, width, height] +# as a dictionary +- name: filename + type: i4 + start: 0xABC + width: 64 + height: 64 + flip_x: yes + flip_y: no +``` + +## General segment options + +All splat's segments can be passed extra options for finer configuration. Note that those extra options require to rewrite the entry using the dictionary yaml notation instead of the list one. + +### `linker_section_order` + +**Description:** + +Allows overriding the section order used for linker script generation. + +Useful when a section of a file is not between the other sections of the same type in the ROM, for example a file having its data section between other files's rodata. + +Take in mind this option may need the [`check_consecutive_segment_types`](Configuration.md#check_consecutive_segment_types) yaml option to be turned off. + +**Example:** + +```yaml +- [0x400, data, file1] +# data ends + +# rodata starts +- [0x800, rodata, file2] +- { start: 0xA00, type: data, name: file3, linker_section_order: .rodata } +- [0xC00, rodata, file4] +``` + +This will created `file3.data.s` within the `asm` folder, but won't be reordered in the generated linker script to be placed on the data section. + +### `linker_section` + +**Description:** + +Allows to override the `.section` directive that will be used when generating the disassembly of the corresponding section, without needing to write an extension segment. This also affects the section name that will be used during link time. + +Useful for sections with special names, like an executable section named `.start` + +**Example:** + +```yaml +- { start: 0x1000, type: asm, name: snmain, linker_section: .start } +- [0x1070, rdata, libc] +- [0x10A0, rdata, main_030] +``` + +### `ld_fill_value` + +Allows to specify the value of the `FILL` statement generated for this specific top-level segment of the linker script, ignoring the global configuration. + +It must be either an integer, which will be used as the parameter for the `FILL` statement, or `null`, which tells splat to not emit a `FILL` statement for this segment. + +If not set, then the global configuration is used. See [ld_fill_value](Configuration.md#ld_fill_value) on the Configuration section. + +Defaults to the value of the global option. diff --git a/tools/splat/docs/VramClasses.md b/tools/splat/docs/VramClasses.md new file mode 100644 index 0000000000..c889919c85 --- /dev/null +++ b/tools/splat/docs/VramClasses.md @@ -0,0 +1,59 @@ +# vram classes + +Version 0.19.0 introduced `vram_classes`, a new top-level yaml section that can be used to help reduce duplicated data in your yaml and more clearly organize its memory layout. + +## Introduction +Before vram classes, you might have had something like this in your yaml: + +```yaml +- type: code + start: 0x4269D0 + vram: 0x802A9000 + vram_symbol: battle_move_end + subsegments: ... +- type: code + start: 0x4273B0 + vram: 0x802A9000 # notice same `vram` and `vram_symbol` for both segments + vram_symbol: battle_move_end + subsegments: ... +``` + +Having to duplicate the vram address and vram_symbol properties for potentially dozens of hundreds of overlay segments is tedious and pollutes your yaml with repeated information that can become out of sync. Enter vram_classes! + +```yaml +- type: code + start: 0x4269D0 + vram_class: maps + subsegments: ... +- type: code + start: 0x4273B0 + vram_class: maps + subsegments: ... +``` + +Here, we are telling splat that both of these segments use the `maps` vram class. We are now effectively pointing both segments to the same source of information. Now let's look at how vram classes are defined: + +## Format + +```yaml +options: + ... + ld_use_symbolic_vram_addresses: True + ... +vram_classes: + - { name: maps, vram: 0x802A9000, vram_symbol: battle_move_end } +``` + +`vram_classes` is a top-level yaml section that contains a list of vram classes. You can either define them in dict form (as seen above) or list form. However, for list form, only `name` and `vram` are supported (`[maps, 0x802A9000]`). If you want to specify other options, please use the dict form. The fields supported are as follows: + +- `name` (required): The name of the class + +- `vram` (required): The vram address to be used during disasembly. If `ld_use_symbolic_vram_addresses` is disabled or no `vram_symbol` or `follows_classes` properties are provided, this address will be used in the linker script. + +The following properties are optional and only take effect if `ld_use_symbolic_vram_addresses` is enabled: + +- `vram_symbol`: The name of the symbol to use in the linker script for this class. + +- `follows_classes`: A list of vram class names that this class must come after in memory. If we added `follows_classes: [apples, bananas]` to our above vram_class, this would make all `maps` segments start at the end of all `apples` and `bananas` segments. + +The internal linker script symbol name that is chosen for `follows_classes` is the name of the class followed by `_CLASS_VRAM`. You can override this by also specifying `vram_symbol`. \ No newline at end of file diff --git a/tools/splat/platforms/n64.py b/tools/splat/platforms/n64.py index ed3ee1c31a..5836b66617 100644 --- a/tools/splat/platforms/n64.py +++ b/tools/splat/platforms/n64.py @@ -1,4 +1,4 @@ -from util import compiler, log, options, palettes, symbols +from util import options, symbols def init(target_bytes: bytes): @@ -6,5 +6,7 @@ def init(target_bytes: bytes): if options.opts.libultra_symbols: symbols.spim_context.globalSegment.fillLibultraSymbols() + if options.opts.ique_symbols: + symbols.spim_context.globalSegment.fillIQueSymbols() if options.opts.hardware_regs: symbols.spim_context.globalSegment.fillHardwareRegs(True) diff --git a/tools/splat/platforms/ps2.py b/tools/splat/platforms/ps2.py new file mode 100644 index 0000000000..09da192fac --- /dev/null +++ b/tools/splat/platforms/ps2.py @@ -0,0 +1,2 @@ +def init(target_bytes: bytes): + pass diff --git a/tools/splat/requirements.txt b/tools/splat/requirements.txt index 429fdead57..66374ab243 100644 --- a/tools/splat/requirements.txt +++ b/tools/splat/requirements.txt @@ -4,7 +4,7 @@ tqdm intervaltree colorama # This value should be keep in sync with the version listed on disassembler/spimdisasm_disassembler.py -spimdisasm>=1.16.0 +spimdisasm>=1.18.0 rabbitizer>=1.7.0 pygfxd n64img>=0.1.4 diff --git a/tools/splat/run_tests.sh b/tools/splat/run_tests.sh index ca362d71a9..e57f8b3df9 100644 --- a/tools/splat/run_tests.sh +++ b/tools/splat/run_tests.sh @@ -1,3 +1,5 @@ +#!/bin/bash + # docker build container docker build --tag splat-build:latest . && \ # get compilers and tools diff --git a/tools/splat/segtypes/common/bin.py b/tools/splat/segtypes/common/bin.py index b72a201071..b6b64a575f 100644 --- a/tools/splat/segtypes/common/bin.py +++ b/tools/splat/segtypes/common/bin.py @@ -7,6 +7,10 @@ from segtypes.common.segment import CommonSegment class CommonSegBin(CommonSegment): + @staticmethod + def is_data() -> bool: + return True + def out_path(self) -> Optional[Path]: return options.opts.asset_path / self.dir / f"{self.name}.bin" diff --git a/tools/splat/segtypes/common/c.py b/tools/splat/segtypes/common/c.py index 5990b6c78f..6662fb7cda 100644 --- a/tools/splat/segtypes/common/c.py +++ b/tools/splat/segtypes/common/c.py @@ -1,7 +1,7 @@ import os import re from pathlib import Path -from typing import Optional, Set, List, Tuple +from typing import Optional, Set, List import spimdisasm @@ -10,27 +10,30 @@ from util.compiler import GCC, SN64, IDO from util.symbols import Symbol from segtypes.common.codesubsegment import CommonSegCodeSubsegment -from segtypes.common.group import CommonSegGroup from segtypes.common.rodata import CommonSegRodata +STRIP_C_COMMENTS_RE = re.compile( + r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"', + re.DOTALL | re.MULTILINE, +) + +C_FUNC_RE = re.compile( + r"^(?:static\s+)?[^\s]+\s+([^\s(]+)\(([^;)]*)\)[^;]+?{", re.MULTILINE +) + +C_GLOBAL_ASM_IDO_RE = re.compile(r"GLOBAL_ASM\(\"(\w+\/)*(\w+)\.s\"\)", re.MULTILINE) + + class CommonSegC(CommonSegCodeSubsegment): - defined_funcs: Set[str] = set() - global_asm_funcs: Set[str] = set() - global_asm_rodata_syms: Set[str] = set() + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) - STRIP_C_COMMENTS_RE = re.compile( - r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"', - re.DOTALL | re.MULTILINE, - ) + self.defined_funcs: Set[str] = set() + self.global_asm_funcs: Set[str] = set() + self.global_asm_rodata_syms: Set[str] = set() - C_FUNC_RE = re.compile( - r"^(?:static\s+)?[^\s]+\s+([^\s(]+)\(([^;)]*)\)[^;]+?{", re.MULTILINE - ) - - C_GLOBAL_ASM_IDO_RE = re.compile( - r"GLOBAL_ASM\(\"(\w+\/)*(\w+)\.s\"\)", re.MULTILINE - ) + self.file_extension = "c" @staticmethod def strip_c_comments(text): @@ -41,14 +44,14 @@ class CommonSegC(CommonSegCodeSubsegment): else: return s - return re.sub(CommonSegC.STRIP_C_COMMENTS_RE, replacer, text) + return re.sub(STRIP_C_COMMENTS_RE, replacer, text) @staticmethod def get_funcs_defined_in_c(c_file: Path) -> Set[str]: with open(c_file, "r") as f: text = CommonSegC.strip_c_comments(f.read()) - return set(m.group(1) for m in CommonSegC.C_FUNC_RE.finditer(text)) + return set(m.group(1) for m in C_FUNC_RE.finditer(text)) @staticmethod def find_all_instances(string: str, sub: str): @@ -104,9 +107,7 @@ class CommonSegC(CommonSegCodeSubsegment): if options.opts.compiler in [GCC, SN64]: return set(CommonSegC.find_include_asm(text)) else: - return set( - m.group(2) for m in CommonSegC.C_GLOBAL_ASM_IDO_RE.finditer(text) - ) + return set(m.group(2) for m in C_GLOBAL_ASM_IDO_RE.finditer(text)) @staticmethod def get_global_asm_rodata_syms(c_file: Path) -> Set[str]: @@ -115,16 +116,14 @@ class CommonSegC(CommonSegCodeSubsegment): if options.opts.compiler in [GCC, SN64]: return set(CommonSegC.find_include_rodata(text)) else: - return set( - m.group(2) for m in CommonSegC.C_GLOBAL_ASM_IDO_RE.finditer(text) - ) + return set(m.group(2) for m in C_GLOBAL_ASM_IDO_RE.finditer(text)) @staticmethod def is_text() -> bool: return True def out_path(self) -> Optional[Path]: - return options.opts.src_path / self.dir / f"{self.name}.c" + return options.opts.src_path / self.dir / f"{self.name}.{self.file_extension}" def scan(self, rom_bytes: bytes): if ( @@ -156,6 +155,7 @@ class CommonSegC(CommonSegCodeSubsegment): self.spim_section.get_section(), spimdisasm.mips.sections.SectionText ), f"{self.name}, rom_start:{self.rom_start}, rom_end:{self.rom_end}" + rodata_section_type = "" rodata_spim_segment: Optional[spimdisasm.mips.sections.SectionRodata] = None if ( options.opts.migrate_rodata_to_functions @@ -164,6 +164,9 @@ class CommonSegC(CommonSegCodeSubsegment): assert isinstance( self.rodata_sibling, CommonSegRodata ), self.rodata_sibling.type + rodata_section_type = ( + self.rodata_sibling.get_linker_section_linksection() + ) if self.rodata_sibling.spim_section is not None: assert isinstance( self.rodata_sibling.spim_section.get_section(), @@ -193,10 +196,13 @@ class CommonSegC(CommonSegCodeSubsegment): # Produce the asm files for functions for entry in symbols_entries: + entry.sectionText = self.get_linker_section_linksection() + entry.sectionRodata = rodata_section_type if entry.function is not None: if ( entry.function.getName() in self.global_asm_funcs or is_new_c_file + or options.opts.disassemble_all ): func_sym = self.get_symbol( entry.function.vram, @@ -212,6 +218,7 @@ class CommonSegC(CommonSegCodeSubsegment): if ( spim_rodata_sym.getName() in self.global_asm_rodata_syms or is_new_c_file + or options.opts.disassemble_all ): rodata_sym = self.get_symbol( spim_rodata_sym.vram, in_segment=True, local_only=True @@ -340,6 +347,7 @@ class CommonSegC(CommonSegCodeSubsegment): # Terrible hack to "auto-decompile" empty functions if ( options.opts.auto_decompile_empty_functions + and len(func.instructions) == 2 and func.instructions[0].isReturn() and func.instructions[1].isNop() ): @@ -402,7 +410,10 @@ class CommonSegC(CommonSegCodeSubsegment): dep_path = build_path / c_path.with_suffix(".asmproc.d") dep_path.parent.mkdir(parents=True, exist_ok=True) with dep_path.open("w") as f: - o_path = build_path / c_path.with_suffix(".o") + if options.opts.use_o_as_suffix: + o_path = build_path / c_path.with_suffix(".o") + else: + o_path = build_path / c_path.with_suffix(c_path.suffix + ".o") f.write(f"{o_path}:") depend_list = [] for entry in symbols_entries: diff --git a/tools/splat/segtypes/common/code.py b/tools/splat/segtypes/common/code.py index eda9936faf..3c2cf25641 100644 --- a/tools/splat/segtypes/common/code.py +++ b/tools/splat/segtypes/common/code.py @@ -7,9 +7,7 @@ from util.range import Range from util.symbols import Symbol from segtypes.common.group import CommonSegGroup -from segtypes.segment import Segment - -CODE_TYPES = ["c", "asm", "hasm"] +from segtypes.segment import Segment, parse_segment_align def dotless_type(type: str) -> str: @@ -44,7 +42,10 @@ class CommonSegCode(CommonSegGroup): self.jtbl_glabels_to_add: Set[int] = set() self.jumptables: Dict[int, Tuple[int, int]] = {} self.rodata_syms: Dict[int, List[Symbol]] = {} - self.align = 0x10 + + self.align = parse_segment_align(yaml) + if self.align is None: + self.align = 0x10 @property def needs_symbols(self) -> bool: @@ -160,6 +161,7 @@ class CommonSegCode(CommonSegGroup): base_segments: OrderedDict[str, Segment] = OrderedDict() ret = [] prev_start: Optional[int] = -1 + prev_vram: Optional[int] = -1 inserts: OrderedDict[ str, int ] = ( @@ -197,14 +199,16 @@ class CommonSegCode(CommonSegGroup): else: if cur_section != typ: # We're changing sections - if found_sections[cur_section].has_end(): - log.error( - f"Section {cur_section} end encountered but was already ended earlier!" - ) - if found_sections[typ].has_start(): - log.error( - f"Section {typ} start encounted but has already started earlier!" - ) + + if options.opts.check_consecutive_segment_types: + if found_sections[cur_section].has_end(): + log.error( + f"Section {cur_section} end encountered but was already ended earlier!" + ) + if found_sections[typ].has_start(): + log.error( + f"Section {typ} start encounted but has already started earlier!" + ) # End the current section found_sections[cur_section].end = i @@ -269,7 +273,7 @@ class CommonSegCode(CommonSegGroup): if start is not None and prev_start is not None and start < prev_start: log.error( - f"Error: Group segment {self.name} contains subsegments which are out of ascending rom order (0x{prev_start:X} followed by 0x{start:X})" + f"Error: Group segment '{self.name}' contains subsegments which are out of ascending rom order (0x{prev_start:X} followed by 0x{start:X})" ) vram = None @@ -287,6 +291,16 @@ class CommonSegCode(CommonSegGroup): segment_class, subsegment_yaml, start, end, vram ) + if ( + segment.vram_start is not None + and prev_vram is not None + and segment.vram_start < prev_vram + ): + log.error( + f"Error: Group segment '{self.name}' contains subsegments which are out of ascending vram order (0x{prev_vram:X} followed by 0x{segment.vram_start:X}).\n" + + f"Detected when processing file '{segment.name}' of type '{segment.type}'" + ) + segment.sibling = base_segments.get(segment.name, None) if segment.sibling is not None: @@ -300,6 +314,16 @@ class CommonSegCode(CommonSegGroup): segment.rodata_sibling = segment.sibling segment.sibling.sibling = segment + if self.section_order.index(".text") < self.section_order.index( + ".data" + ): + if segment.is_data(): + segment.sibling.data_sibling = segment + else: + if segment.is_text() and segment.sibling.is_data(): + segment.data_sibling = segment.sibling + segment.sibling.sibling = segment + segment.parent = self if segment.special_vram_segment: self.special_vram_segment = True @@ -324,6 +348,7 @@ class CommonSegCode(CommonSegGroup): base_segments[segment.name] = segment prev_start = start + prev_vram = segment.vram_start if end is not None: last_rom_end = end @@ -385,10 +410,10 @@ class CommonSegCode(CommonSegGroup): def scan(self, rom_bytes): # Always scan code first for sub in self.subsegments: - if sub.type in CODE_TYPES and sub.should_scan(): + if sub.is_text() and sub.should_scan(): sub.scan(rom_bytes) # Scan everyone else for sub in self.subsegments: - if sub.type not in CODE_TYPES and sub.should_scan(): + if not sub.is_text() and sub.should_scan(): sub.scan(rom_bytes) diff --git a/tools/splat/segtypes/common/codesubsegment.py b/tools/splat/segtypes/common/codesubsegment.py index 9731c11794..08f732762f 100644 --- a/tools/splat/segtypes/common/codesubsegment.py +++ b/tools/splat/segtypes/common/codesubsegment.py @@ -148,7 +148,7 @@ class CommonSegCodeSubsegment(Segment): self.parent.check_rodata_sym(func_spim.vram, sym) def print_file_boundaries(self): - if not options.opts.find_file_boundaries or not self.spim_section: + if not self.show_file_boundaries or not self.spim_section: return assert isinstance(self.rom_start, int) diff --git a/tools/splat/segtypes/common/cpp.py b/tools/splat/segtypes/common/cpp.py new file mode 100644 index 0000000000..c163059704 --- /dev/null +++ b/tools/splat/segtypes/common/cpp.py @@ -0,0 +1,8 @@ +from segtypes.common.c import CommonSegC + + +class CommonSegCpp(CommonSegC): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + self.file_extension = "cpp" diff --git a/tools/splat/segtypes/common/data.py b/tools/splat/segtypes/common/data.py index 7a93653169..c96c787b62 100644 --- a/tools/splat/segtypes/common/data.py +++ b/tools/splat/segtypes/common/data.py @@ -10,6 +10,17 @@ from disassembler_section import make_data_section class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup): + @staticmethod + def is_data() -> bool: + return True + + def asm_out_path(self) -> Path: + typ = self.type + if typ.startswith("."): + typ = typ[1:] + + return options.opts.data_path / self.dir / f"{self.name}.{typ}.s" + def out_path(self) -> Optional[Path]: if self.type.startswith("."): if self.sibling: @@ -20,7 +31,7 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup): return options.opts.src_path / self.dir / f"{self.name}.c" else: # ASM - return options.opts.data_path / self.dir / f"{self.name}.{self.type}.s" + return self.asm_out_path() def scan(self, rom_bytes: bytes): CommonSegGroup.scan(self, rom_bytes) @@ -31,26 +42,31 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup): def split(self, rom_bytes: bytes): super().split(rom_bytes) - if ( - not self.type.startswith(".") - and self.spim_section - and self.should_self_split() - ): - path = self.out_path() + if self.type.startswith(".") and not options.opts.disassemble_all: + return - if path: - path.parent.mkdir(parents=True, exist_ok=True) + if self.spim_section is None or not self.should_self_split(): + return - self.print_file_boundaries() + path = self.asm_out_path() - with open(path, "w", newline="\n") as f: - f.write('.include "macro.inc"\n\n') - preamble = options.opts.generated_s_preamble - if preamble: - f.write(preamble + "\n") - f.write(f".section {self.get_linker_section()}\n\n") + path.parent.mkdir(parents=True, exist_ok=True) - f.write(self.spim_section.disassemble()) + self.print_file_boundaries() + + with path.open("w", newline="\n") as f: + f.write('.include "macro.inc"\n\n') + preamble = options.opts.generated_s_preamble + if preamble: + f.write(preamble + "\n") + + f.write(f".section {self.get_linker_section()}") + section_flags = self.get_section_flags() + if section_flags: + f.write(f', "{section_flags}"') + f.write("\n\n") + + f.write(self.spim_section.disassemble()) def should_self_split(self) -> bool: return options.opts.is_mode_active("data") diff --git a/tools/splat/segtypes/common/databin.py b/tools/splat/segtypes/common/databin.py new file mode 100644 index 0000000000..616288652f --- /dev/null +++ b/tools/splat/segtypes/common/databin.py @@ -0,0 +1,45 @@ +from pathlib import Path +from typing import Optional + +from util import log, options + +from segtypes.common.textbin import CommonSegTextbin + + +class CommonSegDatabin(CommonSegTextbin): + @staticmethod + def is_text() -> bool: + return False + + @staticmethod + def is_data() -> bool: + return True + + def get_linker_section(self) -> str: + return ".data" + + def get_section_flags(self) -> Optional[str]: + return "wa" + + def split(self, rom_bytes): + if self.rom_end is None: + log.error( + f"segment {self.name} needs to know where it ends; add a position marker [0xDEADBEEF] after it" + ) + + self.write_bin(rom_bytes) + + if self.sibling is None: + # textbin will write the incbin instead + + s_path = self.out_path() + assert s_path is not None + s_path.parent.mkdir(parents=True, exist_ok=True) + + with s_path.open("w") as f: + f.write('.include "macro.inc"\n\n') + preamble = options.opts.generated_s_preamble + if preamble: + f.write(preamble + "\n") + + self.write_asm_contents(rom_bytes, f) diff --git a/tools/splat/segtypes/common/decompressor.py b/tools/splat/segtypes/common/decompressor.py index 3bdc5ea9ae..152521ef94 100644 --- a/tools/splat/segtypes/common/decompressor.py +++ b/tools/splat/segtypes/common/decompressor.py @@ -43,6 +43,8 @@ class CommonSegDecompressor(N64Segment): options.opts.asset_path / self.dir / f"{self.name}.{self.compression_type}", - self.get_linker_section(), + self.get_linker_section_order(), + self.get_linker_section_linksection(), + self.is_noload(), ) ] diff --git a/tools/splat/segtypes/common/header.py b/tools/splat/segtypes/common/header.py index b03b0ae86c..55bfc25a07 100644 --- a/tools/splat/segtypes/common/header.py +++ b/tools/splat/segtypes/common/header.py @@ -6,6 +6,10 @@ from segtypes.common.segment import CommonSegment class CommonSegHeader(CommonSegment): + @staticmethod + def is_data() -> bool: + return True + def should_split(self): return self.extract and options.opts.is_mode_active("code") diff --git a/tools/splat/segtypes/common/lib.py b/tools/splat/segtypes/common/lib.py index 51371c17f3..17d4c12b4e 100644 --- a/tools/splat/segtypes/common/lib.py +++ b/tools/splat/segtypes/common/lib.py @@ -50,4 +50,13 @@ class CommonSegLib(N64Segment): object_path = Path(f"{path}.a:{self.object}.o") - return [LinkerEntry(self, [path], object_path, self.get_linker_section())] + return [ + LinkerEntry( + self, + [path], + object_path, + self.get_linker_section_order(), + self.get_linker_section_linksection(), + self.is_noload(), + ) + ] diff --git a/tools/splat/segtypes/common/rodata.py b/tools/splat/segtypes/common/rodata.py index bac0826b16..599aacb2fe 100644 --- a/tools/splat/segtypes/common/rodata.py +++ b/tools/splat/segtypes/common/rodata.py @@ -12,6 +12,10 @@ class CommonSegRodata(CommonSegData): def get_linker_section(self) -> str: return ".rodata" + @staticmethod + def is_data() -> bool: + return False + @staticmethod def is_rodata() -> bool: return True diff --git a/tools/splat/segtypes/common/rodatabin.py b/tools/splat/segtypes/common/rodatabin.py new file mode 100644 index 0000000000..7cd5916792 --- /dev/null +++ b/tools/splat/segtypes/common/rodatabin.py @@ -0,0 +1,45 @@ +from pathlib import Path +from typing import Optional + +from util import log, options + +from segtypes.common.textbin import CommonSegTextbin + + +class CommonSegRodatabin(CommonSegTextbin): + @staticmethod + def is_text() -> bool: + return False + + @staticmethod + def is_rodata() -> bool: + return True + + def get_linker_section(self) -> str: + return ".rodata" + + def get_section_flags(self) -> Optional[str]: + return "a" + + def split(self, rom_bytes): + if self.rom_end is None: + log.error( + f"segment {self.name} needs to know where it ends; add a position marker [0xDEADBEEF] after it" + ) + + self.write_bin(rom_bytes) + + if self.sibling is None: + # textbin will write the incbin instead + + s_path = self.out_path() + assert s_path is not None + s_path.parent.mkdir(parents=True, exist_ok=True) + + with s_path.open("w") as f: + f.write('.include "macro.inc"\n\n') + preamble = options.opts.generated_s_preamble + if preamble: + f.write(preamble + "\n") + + self.write_asm_contents(rom_bytes, f) diff --git a/tools/splat/segtypes/common/textbin.py b/tools/splat/segtypes/common/textbin.py new file mode 100644 index 0000000000..5edf7aa380 --- /dev/null +++ b/tools/splat/segtypes/common/textbin.py @@ -0,0 +1,114 @@ +from pathlib import Path +from typing import Optional, TextIO + +from util import log, options + +from segtypes.common.segment import CommonSegment + + +class CommonSegTextbin(CommonSegment): + @staticmethod + def is_text() -> bool: + return True + + def get_linker_section(self) -> str: + return ".text" + + def get_section_flags(self) -> Optional[str]: + return "ax" + + def out_path(self) -> Optional[Path]: + return options.opts.data_path / self.dir / f"{self.name}.s" + + def bin_path(self) -> Path: + typ = self.type + if typ.startswith("."): + typ = typ[1:] + + return options.opts.asset_path / self.dir / f"{self.name}.{typ}.bin" + + def write_bin(self, rom_bytes): + binpath = self.bin_path() + binpath.parent.mkdir(parents=True, exist_ok=True) + + assert isinstance(self.rom_start, int) + assert isinstance(self.rom_end, int) + + binpath.write_bytes(rom_bytes[self.rom_start : self.rom_end]) + + self.log(f"Wrote {self.name} to {binpath}") + + def write_asm_contents(self, rom_bytes, f: TextIO): + binpath = self.bin_path() + asm_label = options.opts.asm_function_macro + if not self.is_text(): + asm_label = options.opts.asm_data_macro + + assert isinstance(self.rom_start, int) + assert isinstance(self.rom_end, int) + + f.write(f".section {self.get_linker_section()}") + section_flags = self.get_section_flags() + if section_flags: + f.write(f', "{section_flags}"') + f.write("\n\n") + + # Check if there's a symbol at this address + sym = None + vram = self.rom_to_ram(self.rom_start) + if vram is not None: + sym = self.get_symbol(vram, in_segment=True) + + if sym is not None: + f.write(f"{asm_label} {sym.name}\n") + sym.defined = True + + f.write(f'.incbin "{binpath}"\n') + + if sym is not None: + if self.is_text() and options.opts.asm_end_label != "": + f.write(f"{options.opts.asm_end_label} {sym.name}\n") + + if sym.given_name_end is not None: + if ( + sym.given_size is None + or sym.given_size == self.rom_end - self.rom_start + ): + f.write(f"{asm_label} {sym.given_name_end}\n") + + def split(self, rom_bytes): + if self.rom_end is None: + log.error( + f"segment {self.name} needs to know where it ends; add a position marker [0xDEADBEEF] after it" + ) + + self.write_bin(rom_bytes) + + s_path = self.out_path() + assert s_path is not None + s_path.parent.mkdir(parents=True, exist_ok=True) + + with s_path.open("w") as f: + f.write('.include "macro.inc"\n\n') + preamble = options.opts.generated_s_preamble + if preamble: + f.write(preamble + "\n") + + self.write_asm_contents(rom_bytes, f) + + # We check against CommonSegTextbin instead of the specific type because the other incbins inherit from this class + if isinstance(self.data_sibling, CommonSegTextbin): + f.write("\n") + self.data_sibling.write_asm_contents(rom_bytes, f) + + if isinstance(self.rodata_sibling, CommonSegTextbin): + f.write("\n") + self.rodata_sibling.write_asm_contents(rom_bytes, f) + + def should_scan(self) -> bool: + return self.rom_start is not None and self.rom_end is not None + + def should_split(self) -> bool: + return ( + self.extract and self.should_scan() + ) # only split if the segment was scanned first diff --git a/tools/splat/segtypes/linker_entry.py b/tools/splat/segtypes/linker_entry.py index 981d3d312e..fc9b873326 100644 --- a/tools/splat/segtypes/linker_entry.py +++ b/tools/splat/segtypes/linker_entry.py @@ -1,10 +1,8 @@ import os import re -from dataclasses import dataclass from functools import lru_cache from pathlib import Path from typing import Dict, List, OrderedDict, Set, Tuple, Union -from segtypes.n64.palette import N64SegPalette from util import options @@ -57,42 +55,82 @@ def write_file_if_different(path: Path, new_content: str): f.write(new_content) -def segment_cname(segment: Segment) -> str: - name = segment.name - if segment.parent: - name = segment.parent.name + "_" + name +def get_segment_rom_start(cname: str) -> str: + if options.opts.segment_symbols_style == "makerom": + return f"_{cname}SegmentRomStart" + return f"{cname}_ROM_START" - if isinstance(segment, N64SegPalette): - name += "_pal" - return to_cname(name) +def get_segment_rom_end(cname: str) -> str: + if options.opts.segment_symbols_style == "makerom": + return f"_{cname}SegmentRomEnd" + return f"{cname}_ROM_END" + + +def get_segment_vram_start(cname: str) -> str: + if options.opts.segment_symbols_style == "makerom": + return f"_{cname}SegmentStart" + return f"{cname}_VRAM" + + +def get_segment_vram_end(cname: str) -> str: + if options.opts.segment_symbols_style == "makerom": + return f"_{cname}SegmentEnd" + return f"{cname}_VRAM_END" + + +def convert_section_name_to_linker_format(section_type: str) -> str: + assert section_type.startswith(".") + if options.opts.segment_symbols_style == "makerom": + if section_type == ".rodata": + return "RoData" + return section_type[1:].capitalize() + + return to_cname(section_type.upper()) + + +def get_segment_section_start(segment_name: str, section_type: str) -> str: + sec = convert_section_name_to_linker_format(section_type) + if options.opts.segment_symbols_style == "makerom": + return f"_{segment_name}Segment{sec}Start" + return f"{segment_name}{sec}_START" + + +def get_segment_section_end(segment_name: str, section_type: str) -> str: + sec = convert_section_name_to_linker_format(section_type) + if options.opts.segment_symbols_style == "makerom": + return f"_{segment_name}Segment{sec}End" + return f"{segment_name}{sec}_END" + + +def get_segment_section_size(segment_name: str, section_type: str) -> str: + sec = convert_section_name_to_linker_format(section_type) + if options.opts.segment_symbols_style == "makerom": + return f"_{segment_name}Segment{sec}Size" + return f"{segment_name}{sec}_SIZE" def get_segment_vram_end_symbol_name(segment: Segment) -> str: - return segment_cname(segment) + "_VRAM_END" - - -@dataclass -class LinkerSection: - name: str - started: bool = False - ended: bool = False - - @property - def section_type(self) -> str: - if self.name == ".rdata": - return ".rodata" - return self.name + return get_segment_vram_end(segment.get_cname()) class LinkerEntry: def __init__( - self, segment: Segment, src_paths: List[Path], object_path: Path, section: str + self, + segment: Segment, + src_paths: List[Path], + object_path: Path, + section_order: str, + section_link: str, + noload: bool = False, ): self.segment = segment self.src_paths = [clean_up_path(p) for p in src_paths] - self.section = section - if self.section == "linker" or self.section == "linker_offset": + self.section_order = section_order + self.section_link = section_link + self.noload = noload + self.bss_contains_common = segment.bss_contains_common + if self.section_link == "linker" or self.section_link == "linker_offset": self.object_path = None elif self.segment.type == "lib": self.object_path = object_path @@ -100,30 +138,44 @@ class LinkerEntry: self.object_path = path_to_object_path(object_path) @property - def section_type(self) -> str: - if self.section == ".rdata": + def section_order_type(self) -> str: + if self.section_order == ".rdata": return ".rodata" else: - return self.section + return self.section_order + + @property + def section_link_type(self) -> str: + if self.section_link == ".rdata": + return ".rodata" + else: + return self.section_link class LinkerWriter: - def __init__(self): + def __init__(self, is_partial: bool = False): self.linker_discard_section: bool = options.opts.ld_discard_section + self.sections_allowlist: List[str] = options.opts.ld_sections_allowlist + self.sections_denylist: List[str] = options.opts.ld_sections_denylist # Used to store all the linker entries - build tools may want this information self.entries: List[LinkerEntry] = [] + self.dependencies_entries: List[LinkerEntry] = [] self.buffer: List[str] = [] self.header_symbols: Set[str] = set() + self.is_partial: bool = is_partial + self._indent_level = 0 self._writeln("SECTIONS") self._begin_block() - self._writeln("__romPos = 0;") - if options.opts.gp is not None: - self._writeln("_gp = " + f"0x{options.opts.gp:X};") + if not self.is_partial: + self._writeln(f"__romPos = {options.opts.ld_rom_start};") + + if options.opts.gp is not None: + self._writeln("_gp = " + f"0x{options.opts.gp:X};") # Write a series of statements which compute a symbol that represents the highest address among a list of segments' end addresses def write_max_vram_end_sym(self, symbol: str, overlays: List[Segment]): @@ -141,159 +193,251 @@ class LinkerWriter: def add(self, segment: Segment, max_vram_syms: List[Tuple[str, List[Segment]]]): entries = segment.get_linker_entries() self.entries.extend(entries) + self.dependencies_entries.extend(entries) - seg_name = segment_cname(segment) + seg_name = segment.get_cname() for sym, segs in max_vram_syms: self.write_max_vram_end_sym(sym, segs) - section_labels: OrderedDict[str, LinkerSection] = OrderedDict( - { - l: LinkerSection(l) - for l in options.opts.section_order - if l in options.opts.ld_section_labels - } - ) + if options.opts.ld_legacy_generation: + self.add_legacy(segment, entries) + return - # Start the first linker section + section_entries: OrderedDict[str, List[LinkerEntry]] = OrderedDict() + for l in segment.section_order: + if l in options.opts.ld_section_labels: + section_entries[l] = [] - self._write_symbol(f"{seg_name}_ROM_START", "__romPos") + # Add all entries to section_entries + prev_entry = None + for entry in entries: + if entry.section_order_type in section_entries: + # Search for the very first section type + # This is required in case the very first entry is a type that's not listed on ld_section_labels (like linker_offset) because it would be dropped + prev_entry = entry.section_order_type + break - if entries[0].section_type == ".bss": - self._begin_bss_segment(segment, is_first=True) - self._write_symbol(f"{seg_name}_BSS_START", ".") - if ".bss" in section_labels: - section_labels[".bss"].started = True - else: - self._begin_segment(segment) + any_load = False + any_noload = False + for entry in entries: + if entry.section_order_type in section_entries: + section_entries[entry.section_order_type].append(entry) + elif prev_entry is not None: + # If this section is not present in section_order or ld_section_labels then pretend it is part of the last seen section, mainly for handling linker_offset + section_entries[prev_entry].append(entry) + any_load = any_load or not entry.noload + any_noload = any_noload or entry.noload + prev_entry = entry.section_order_type - last_seen_sections: Dict[LinkerEntry, str] = {} + seg_rom_start = get_segment_rom_start(seg_name) + self._write_symbol(seg_rom_start, "__romPos") + + is_first = True + if any_load: + # Only emit normal segment if there's at least one normal entry + self._write_segment_sections( + segment, seg_name, section_entries, noload=False, is_first=is_first + ) + is_first = False + + if any_noload: + # Only emit NOLOAD segment if there is at least one noload entry + self._write_segment_sections( + segment, seg_name, section_entries, noload=True, is_first=is_first + ) + is_first = False + + self._end_segment(segment, all_bss=not any_load) + + def add_legacy(self, segment: Segment, entries: List[LinkerEntry]): + seg_name = segment.get_cname() + + # To keep track which sections has been started + started_sections: Dict[str, bool] = { + l: False for l in options.opts.ld_section_labels + } # Find where sections are last seen + last_seen_sections: Dict[LinkerEntry, str] = {} for entry in reversed(entries): if ( - entry.section_type in section_labels.keys() - and entry.section_type not in last_seen_sections.values() + entry.section_order_type in options.opts.ld_section_labels + and entry.section_order_type not in last_seen_sections.values() ): - last_seen_sections[entry] = entry.section_type + last_seen_sections[entry] = entry.section_order_type - cur_section = None - prev_section = None + seg_rom_start = get_segment_rom_start(seg_name) + self._write_symbol(seg_rom_start, "__romPos") + + self._begin_segment(segment, seg_name, noload=False, is_first=True) + + i = 0 for entry in entries: - entering_bss = False - leaving_bss = False - cur_section = entry.section_type + if entry.noload: + break - if cur_section == "linker_offset": - self._write_symbol(f"{segment_cname(entry.segment)}_OFFSET", ".") - continue + started = started_sections.get(entry.section_order_type, True) + if not started: + self._begin_section(seg_name, entry.section_order_type) + started_sections[entry.section_order_type] = True - for i, section in enumerate(section_labels.values()): - # If we haven't seen this section yet - if not section.started and section.section_type == entry.section_type: - if prev_section == ".bss": - leaving_bss = True - elif cur_section == ".bss": - entering_bss = True + self._write_linker_entry(entry) - if not ( - entering_bss or leaving_bss - ): # Don't write a START symbol if we are about to end the section - self._write_symbol( - f"{seg_name}{entry.section_type.upper()}_START", "." - ) - section_labels[entry.section_type].started = True + if entry in last_seen_sections: + self._end_section(seg_name, entry.section_order_type) - if ( - entry.object_path - and cur_section == ".data" - and entry.segment.type != "lib" - ): - path_cname = re.sub( - r"[^0-9a-zA-Z_]", - "_", - str(entry.segment.dir / entry.segment.name) - + ".".join(entry.object_path.suffixes[:-1]), + i += 1 + + if any(entry.noload for entry in entries): + self._end_block() + + self._begin_segment(segment, seg_name, noload=True, is_first=False) + + for entry in entries[i:]: + started = started_sections.get(entry.section_order_type, True) + if not started: + self._begin_section(seg_name, entry.section_order_type) + started_sections[entry.section_order_type] = True + + self._write_linker_entry(entry) + + if entry in last_seen_sections: + self._end_section(seg_name, entry.section_order_type) + + self._end_segment(segment, all_bss=False) + + def add_referenced_partial_segment( + self, segment: Segment, max_vram_syms: List[Tuple[str, List[Segment]]] + ): + entries = segment.get_linker_entries() + self.entries.extend(entries) + + segments_path = options.opts.ld_partial_build_segments_path + assert segments_path is not None + + seg_name = segment.get_cname() + + for sym, segs in max_vram_syms: + self.write_max_vram_end_sym(sym, segs) + + seg_rom_start = get_segment_rom_start(seg_name) + self._write_symbol(seg_rom_start, "__romPos") + + any_load = any(not e.noload for e in entries) + is_first = True + if any_load: + # Only emit normal segment if there's at least one normal entry + + self._begin_segment(segment, seg_name, noload=False, is_first=is_first) + + for l in segment.section_order: + if l not in options.opts.ld_section_labels: + continue + if l == ".bss": + continue + + entry = LinkerEntry( + segment, [], segments_path / f"{seg_name}.o", l, l, noload=False ) - self._write_symbol(path_cname, ".") + self.dependencies_entries.append(entry) + self._write_linker_entry(entry) + is_first = False - wildcard = "*" if options.opts.ld_wildcard_sections else "" - - # Create new linker section for BSS - if entering_bss or leaving_bss: - # If this is the last entry of its type, add the END marker for the section we're ending - if ( - entry in last_seen_sections - and section_labels[entry.section_type].started - ): - seg_name_section = to_cname( - f"{seg_name}{last_seen_sections[entry].upper()}" - ) - self._write_symbol(f"{seg_name_section}_END", ".") - self._write_symbol( - f"{seg_name_section}_SIZE", - f"ABSOLUTE({seg_name_section}_END - {seg_name_section}_START)", - ) - section_labels[last_seen_sections[entry]].ended = True + if any(e.noload for e in entries): + # Only emit NOLOAD segment if there is at least one noload entry + if not is_first: self._end_block() - if entering_bss: - self._begin_bss_segment(segment) - else: - self._begin_segment(segment) + self._begin_segment(segment, seg_name, noload=True, is_first=is_first) - self._write_symbol(f"{seg_name}{entry.section_type.upper()}_START", ".") - section_labels[cur_section].started = True + # Check if any section has the bss_contains_common option + bss_contains_common = False + for entry in entries: + if entry.segment.bss_contains_common: + bss_contains_common = True + break - # Write THIS linker entry - self._writeln(f"{entry.object_path}({entry.section}{wildcard});") - else: - # Write THIS linker entry - if entry.section == ".bss" and entry.segment.bss_contains_common: - self._writeln(f"{entry.object_path}(.bss COMMON .scommon);") - else: - self._writeln(f"{entry.object_path}({entry.section}{wildcard});") + entry = LinkerEntry( + segment, + [], + segments_path / f"{seg_name}.o", + ".bss", + ".bss", + noload=True, + ) + entry.bss_contains_common = bss_contains_common + self.dependencies_entries.append(entry) + self._write_linker_entry(entry) - # If this is the last entry of its type, add the END marker for the section we're ending - if entry in last_seen_sections: - seg_name_section = to_cname(f"{seg_name}{cur_section.upper()}") - self._write_symbol(f"{seg_name_section}_END", ".") - self._write_symbol( - f"{seg_name_section}_SIZE", - f"ABSOLUTE({seg_name_section}_END - {seg_name_section}_START)", - ) - section_labels[cur_section].ended = True + self._end_segment(segment, all_bss=not any_load) - prev_section = cur_section + def add_partial_segment(self, segment: Segment): + entries = segment.get_linker_entries() + self.entries.extend(entries) + self.dependencies_entries.extend(entries) - # End all un-ended sections - for section in section_labels.values(): - if section.started and not section.ended: - seg_name_section = to_cname(f"{seg_name}{section.name.upper()}") - self._write_symbol(f"{seg_name_section}_END", ".") - self._write_symbol( - f"{seg_name_section}_SIZE", - f"ABSOLUTE({seg_name_section}_END - {seg_name_section}_START)", - ) + seg_name = segment.get_cname() - all_bss = all(e.section == ".bss" for e in entries) - self._end_segment(segment, all_bss) + section_entries: OrderedDict[str, List[LinkerEntry]] = OrderedDict() + for l in segment.section_order: + if l in options.opts.ld_section_labels: + section_entries[l] = [] - def save_linker_script(self): - if self.linker_discard_section: + # Add all entries to section_entries + prev_entry = None + for entry in entries: + if entry.section_order_type in section_entries: + section_entries[entry.section_order_type].append(entry) + elif prev_entry is not None: + # If this section is not present in section_order or ld_section_labels then pretend it is part of the last seen section, mainly for handling linker_offset + section_entries[prev_entry].append(entry) + prev_entry = entry.section_order_type + + for section_name, entries in section_entries.items(): + if len(entries) == 0: + continue + first_entry = entries[0] + + self._begin_partial_segment(section_name, segment, first_entry.noload) + + self._begin_section(seg_name, section_name) + + for entry in entries: + self._write_linker_entry(entry) + + self._end_section(seg_name, section_name) + + self._end_partial_segment(section_name) + + def save_linker_script(self, output_path: Path): + if len(self.sections_allowlist) > 0: + address = " 0" + if self.is_partial: + address = "" + for sect in self.sections_allowlist: + self._writeln(f"{sect}{address} :") + self._begin_block() + self._writeln(f"*({sect});") + self._end_block() + + self._writeln("") + + if self.linker_discard_section or len(self.sections_denylist) > 0: self._writeln("/DISCARD/ :") self._begin_block() - self._writeln("*(*);") + for sect in self.sections_denylist: + self._writeln(f"*({sect});") + if self.linker_discard_section: + self._writeln("*(*);") self._end_block() self._end_block() # SECTIONS assert self._indent_level == 0 - write_file_if_different( - options.opts.ld_script_path, "\n".join(self.buffer) + "\n" - ) + write_file_if_different(output_path, "\n".join(self.buffer) + "\n") def save_symbol_header(self): path = options.opts.ld_symbol_header_path @@ -306,11 +450,28 @@ class LinkerWriter: "\n" '#include "common.h"\n' "\n" - + "".join(f"extern Addr {symbol};\n" for symbol in self.header_symbols) + + "".join( + f"extern Addr {symbol};\n" for symbol in sorted(self.header_symbols) + ) + "\n" "#endif\n", ) + def save_dependencies_file(self, output_path: Path, target_elf_path: Path): + output = f"{target_elf_path}:" + + for entry in self.dependencies_entries: + if entry.object_path is None: + continue + output += f" \\\n {entry.object_path}" + + output += "\n" + for entry in self.dependencies_entries: + if entry.object_path is None: + continue + output += f"{entry.object_path}:\n" + write_file_if_different(output_path, output) + def _writeln(self, line: str): if len(line) == 0: self.buffer.append(line) @@ -335,9 +496,14 @@ class LinkerWriter: self.header_symbols.add(symbol) - def _begin_segment(self, segment: Segment): - if options.opts.ld_use_follows and segment.vram_of_symbol: - vram_str = segment.vram_of_symbol + " " + def _begin_segment( + self, segment: Segment, seg_name: str, noload: bool, is_first: bool + ): + if ( + options.opts.ld_use_symbolic_vram_addresses + and segment.vram_symbol is not None + ): + vram_str = segment.vram_symbol + " " else: vram_str = ( f"0x{segment.vram_start:X} " @@ -345,47 +511,33 @@ class LinkerWriter: else "" ) - name = segment_cname(segment) - - self._write_symbol(f"{name}_VRAM", f"ADDR(.{name})") - - line = f".{name} {vram_str}: AT({name}_ROM_START)" - if segment.subalign != None: - line += f" SUBALIGN({segment.subalign})" - - self._writeln(line) - self._begin_block() - - def _begin_bss_segment(self, segment: Segment, is_first: bool = False): - if options.opts.ld_use_follows and segment.vram_of_symbol: - vram_str = segment.vram_of_symbol + " " - else: - vram_str = ( - f"0x{segment.vram_start:X} " - if isinstance(segment.vram_start, int) - else "" - ) - - name = segment_cname(segment) + "_bss" - - self._write_symbol(f"{name}_VRAM", f"ADDR(.{name})") - + addr_str = " " if is_first: - addr_str = vram_str + "(NOLOAD)" - else: - addr_str = "(NOLOAD)" + addr_str += f"{vram_str}" + if noload: + seg_name += "_bss" + addr_str += "(NOLOAD) " - line = f".{name} {addr_str} :" + seg_vram_start = get_segment_vram_start(seg_name) + self._write_symbol(seg_vram_start, f"ADDR(.{seg_name})") + + line = f".{seg_name}{addr_str}:" + if not noload: + seg_rom_start = get_segment_rom_start(seg_name) + line += f" AT({seg_rom_start})" if segment.subalign != None: line += f" SUBALIGN({segment.subalign})" self._writeln(line) self._begin_block() + if segment.ld_fill_value is not None: + self._writeln(f"FILL(0x{segment.ld_fill_value:08X});") + def _end_segment(self, segment: Segment, all_bss=False): self._end_block() - name = segment_cname(segment) + name = segment.get_cname() if not all_bss: self._writeln(f"__romPos += SIZEOF(.{name});") @@ -395,7 +547,8 @@ class LinkerWriter: if segment.align: self._writeln(f"__romPos = ALIGN(__romPos, {segment.align});") - self._write_symbol(f"{name}_ROM_END", "__romPos") + seg_rom_end = get_segment_rom_end(name) + self._write_symbol(seg_rom_end, "__romPos") self._write_symbol(get_segment_vram_end_symbol_name(segment), ".") # Align directive @@ -404,3 +557,85 @@ class LinkerWriter: self._writeln(f"__romPos = ALIGN(__romPos, {segment.align});") self._writeln("") + + def _begin_partial_segment(self, section_name: str, segment: Segment, noload: bool): + line = f"{section_name}" + if noload: + line += " (NOLOAD)" + line += " :" + if segment.subalign != None: + line += f" SUBALIGN({segment.subalign})" + + self._writeln(line) + self._begin_block() + + def _end_partial_segment(self, section_name: str, all_bss=False): + self._end_block() + + self._writeln("") + + def _begin_section(self, seg_name: str, cur_section: str) -> None: + section_start = get_segment_section_start(seg_name, cur_section) + self._write_symbol(section_start, ".") + + def _end_section(self, seg_name: str, cur_section: str) -> None: + section_start = get_segment_section_start(seg_name, cur_section) + section_end = get_segment_section_end(seg_name, cur_section) + section_size = get_segment_section_size(seg_name, cur_section) + self._write_symbol(section_end, ".") + self._write_symbol( + section_size, + f"ABSOLUTE({section_end} - {section_start})", + ) + + def _write_linker_entry(self, entry: LinkerEntry): + if entry.section_link_type == "linker_offset": + self._write_symbol(f"{entry.segment.get_cname()}_OFFSET", ".") + return + + # TODO: option to turn this off? + if ( + entry.object_path + and entry.section_link_type == ".data" + and entry.segment.type != "lib" + ): + path_cname = re.sub( + r"[^0-9a-zA-Z_]", + "_", + str(entry.segment.dir / entry.segment.name) + + ".".join(entry.object_path.suffixes[:-1]), + ) + self._write_symbol(path_cname, ".") + + if entry.noload and entry.bss_contains_common: + self._writeln(f"{entry.object_path}(.bss COMMON .scommon);") + else: + wildcard = "*" if options.opts.ld_wildcard_sections else "" + + self._writeln(f"{entry.object_path}({entry.section_link}{wildcard});") + + def _write_segment_sections( + self, + segment: Segment, + seg_name: str, + section_entries: OrderedDict[str, List[LinkerEntry]], + noload: bool, + is_first: bool, + ): + if not is_first: + self._end_block() + + self._begin_segment(segment, seg_name, noload=noload, is_first=is_first) + + for section_name, entries in section_entries.items(): + if len(entries) == 0: + continue + + first_entry = entries[0] + if first_entry.noload != noload: + continue + + self._begin_section(seg_name, section_name) + for entry in entries: + self._write_linker_entry(entry) + self._end_section(seg_name, section_name) diff --git a/tools/splat/segtypes/n64/gfx.py b/tools/splat/segtypes/n64/gfx.py index b73e1c0d93..45f4a21cac 100644 --- a/tools/splat/segtypes/n64/gfx.py +++ b/tools/splat/segtypes/n64/gfx.py @@ -36,12 +36,15 @@ from pygfxd import ( gfxd_f3dexb, gfxd_f3dex2, ) +from segtypes.segment import Segment from util import log, options from util.log import error from segtypes.common.codesubsegment import CommonSegCodeSubsegment +from util import symbols + LIGHTS_RE = re.compile(r"\*\(Lightsn \*\)0x[0-9A-F]{8}") @@ -67,6 +70,7 @@ class N64SegGfx(CommonSegCodeSubsegment): ) self.file_text = None self.data_only = isinstance(yaml, dict) and yaml.get("data_only", False) + self.in_segment = not isinstance(yaml, dict) or yaml.get("in_segment", True) def format_sym_name(self, sym) -> str: return sym.name @@ -98,71 +102,84 @@ class N64SegGfx(CommonSegCodeSubsegment): def tlut_handler(self, addr, idx, count): sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True + addr=addr, in_segment=self.in_segment, type="data", reference=True ) gfxd_printf(self.format_sym_name(sym)) return 1 def timg_handler(self, addr, fmt, size, width, height, pal): sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True + addr=addr, in_segment=self.in_segment, type="data", reference=True ) gfxd_printf(self.format_sym_name(sym)) return 1 def cimg_handler(self, addr, fmt, size, width): sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True + addr=addr, in_segment=self.in_segment, type="data", reference=True ) gfxd_printf(self.format_sym_name(sym)) return 1 def zimg_handler(self, addr): sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True + addr=addr, in_segment=self.in_segment, type="data", reference=True ) gfxd_printf(self.format_sym_name(sym)) return 1 def dl_handler(self, addr): - sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True - ) + # Look for 'Gfx'-typed symbols first + sym = self.retrieve_sym_type(symbols.all_symbols_dict, addr, "Gfx") + + if not sym: + sym = self.create_symbol( + addr=addr, in_segment=self.in_segment, type="data", reference=True + ) gfxd_printf(self.format_sym_name(sym)) return 1 def mtx_handler(self, addr): sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True + addr=addr, in_segment=self.in_segment, type="data", reference=True ) gfxd_printf(f"&{self.format_sym_name(sym)}") return 1 def lookat_handler(self, addr, count): sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True + addr=addr, in_segment=self.in_segment, type="data", reference=True ) gfxd_printf(self.format_sym_name(sym)) return 1 def light_handler(self, addr, count): sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True + addr=addr, in_segment=self.in_segment, type="data", reference=True ) gfxd_printf(self.format_sym_name(sym)) return 1 def vtx_handler(self, addr, count): - sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True, search_ranges=True - ) + # Look for 'Vtx'-typed symbols first + sym = self.retrieve_sym_type(symbols.all_symbols_dict, addr, "Vtx") + + if not sym: + sym = self.create_symbol( + addr=addr, + in_segment=self.in_segment, + type="Vtx", + reference=True, + search_ranges=True, + ) + index = int((addr - sym.vram_start) / 0x10) gfxd_printf(f"&{self.format_sym_name(sym)}[{index}]") return 1 def vp_handler(self, addr): sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True + addr=addr, in_segment=self.in_segment, type="data", reference=True ) gfxd_printf(f"&{self.format_sym_name(sym)}") return 1 @@ -234,7 +251,7 @@ class N64SegGfx(CommonSegCodeSubsegment): light = match.group(0) addr = int(light[12:], 0) sym = self.create_symbol( - addr=addr, in_segment=True, type="data", reference=True + addr=addr, in_segment=self.in_segment, type="data", reference=True ) return self.format_sym_name(sym) diff --git a/tools/splat/segtypes/n64/linker_offset.py b/tools/splat/segtypes/n64/linker_offset.py index ac4d94546a..b13a190d1c 100644 --- a/tools/splat/segtypes/n64/linker_offset.py +++ b/tools/splat/segtypes/n64/linker_offset.py @@ -7,4 +7,8 @@ class N64SegLinker_offset(N64Segment): def get_linker_entries(self): from segtypes.linker_entry import LinkerEntry - return [LinkerEntry(self, [], Path(self.name), "linker_offset")] + return [ + LinkerEntry( + self, [], Path(self.name), "linker_offset", "linker_offset", False + ) + ] diff --git a/tools/splat/segtypes/n64/palette.py b/tools/splat/segtypes/n64/palette.py index 553f642286..7ede8d0d1f 100644 --- a/tools/splat/segtypes/n64/palette.py +++ b/tools/splat/segtypes/n64/palette.py @@ -6,6 +6,7 @@ from util import log, options from util.color import unpack_color from segtypes.n64.segment import N64Segment +from util.symbols import to_cname if TYPE_CHECKING: from segtypes.n64.ci import N64SegCi as Raster @@ -60,6 +61,9 @@ class N64SegPalette(N64Segment): f"Error: {self.name} (0x{actual_len:X} bytes) is not a valid palette size ({', '.join(hex(s) for s in VALID_SIZES)})\n{hint_msg}" ) + def get_cname(self) -> str: + return super().get_cname() + "_pal" + def split(self, rom_bytes): if self.raster is None: # TODO: output with no raster @@ -94,7 +98,9 @@ class N64SegPalette(N64Segment): self, [options.opts.asset_path / self.dir / f"{self.name}.png"], options.opts.asset_path / self.dir / f"{self.name}.pal", - self.get_linker_section(), + self.get_linker_section_order(), + self.get_linker_section_linksection(), + self.is_noload(), ) ] diff --git a/tools/splat/segtypes/ps2/__init__.py b/tools/splat/segtypes/ps2/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/tools/splat/segtypes/ps2/asm.py b/tools/splat/segtypes/ps2/asm.py new file mode 100644 index 0000000000..53e4a44920 --- /dev/null +++ b/tools/splat/segtypes/ps2/asm.py @@ -0,0 +1,23 @@ +from util import options + +from segtypes.common.asm import CommonSegAsm + + +class Ps2SegAsm(CommonSegAsm): + @staticmethod + def get_file_header(): + ret = [] + + ret.append('.include "macro.inc"') + ret.append("") + ret.append(".set noat") + ret.append(".set noreorder") + ret.append("") + preamble = options.opts.generated_s_preamble + if preamble: + ret.append(preamble) + ret.append("") + ret.append('.section .text, "ax"') + ret.append("") + + return ret diff --git a/tools/splat/segtypes/segment.py b/tools/splat/segtypes/segment.py index c7f43e4085..94e6d2f6fd 100644 --- a/tools/splat/segtypes/segment.py +++ b/tools/splat/segtypes/segment.py @@ -5,7 +5,9 @@ from pathlib import Path from typing import Dict, List, Optional, Set, Type, TYPE_CHECKING, Union from intervaltree import Interval, IntervalTree +from util import vram_classes +from util.vram_classes import VramClass from util import log, options, symbols from util.symbols import Symbol, to_cname @@ -21,6 +23,25 @@ def parse_segment_vram(segment: Union[dict, list]) -> Optional[int]: return None +def parse_segment_vram_symbol(segment: Union[dict, list]) -> Optional[str]: + if isinstance(segment, dict) and "vram_symbol" in segment: + return str(segment["vram_symbol"]) + else: + return None + + +def parse_segment_vram_class(segment: Union[dict, list]) -> Optional[VramClass]: + if isinstance(segment, dict) and "vram_class" in segment: + return vram_classes.resolve(segment["vram_class"]) + return None + + +def parse_segment_follows_vram(segment: Union[dict, list]) -> Optional[str]: + if isinstance(segment, dict): + return segment.get("follows_vram", None) + return None + + def parse_segment_align(segment: Union[dict, list]) -> Optional[int]: if isinstance(segment, dict) and "align" in segment: return int(segment["align"]) @@ -44,18 +65,6 @@ def parse_segment_section_order(segment: Union[dict, list]) -> List[str]: return default -def parse_segment_follows_vram(segment: Union[dict, list]) -> Optional[str]: - if isinstance(segment, dict): - return segment.get("follows_vram", None) - return None - - -def parse_segment_vram_of_symbol(segment: Union[dict, list]) -> Optional[str]: - if isinstance(segment, dict): - return segment.get("vram_of_symbol", segment.get("follows_vram_symbol", None)) - return None - - class Segment: require_unique_name = True @@ -177,6 +186,26 @@ class Segment: else: return False + @staticmethod + def parse_linker_section_order(yaml: Union[dict, list]) -> Optional[str]: + if isinstance(yaml, dict) and "linker_section_order" in yaml: + return str(yaml["linker_section_order"]) + return None + + @staticmethod + def parse_linker_section(yaml: Union[dict, list]) -> Optional[str]: + if isinstance(yaml, dict) and "linker_section" in yaml: + return str(yaml["linker_section"]) + return None + + @staticmethod + def parse_ld_fill_value( + yaml: Union[dict, list], default: Optional[int] + ) -> Optional[int]: + if isinstance(yaml, dict) and "ld_fill_value" in yaml: + return yaml["ld_fill_value"] + return default + def __init__( self, rom_start: Optional[int], @@ -198,6 +227,9 @@ class Segment: self.exclusive_ram_id: Optional[str] = None self.given_dir: Path = Path() + # Default to global options. + self.given_find_file_boundaries: Optional[bool] = None + # Symbols known to be in this segment self.given_seg_symbols: Dict[int, List[Symbol]] = {} @@ -206,8 +238,10 @@ class Segment: self.symbol_ranges_rom: IntervalTree = IntervalTree() self.given_section_order: List[str] = options.opts.section_order + + self.vram_class: Optional[VramClass] = None self.given_follows_vram: Optional[str] = None - self.vram_of_symbol: Optional[str] = None + self.given_vram_symbol: Optional[str] = None self.given_symbol_name_format: str = options.opts.symbol_name_format self.given_symbol_name_format_no_rom: str = ( @@ -216,6 +250,7 @@ class Segment: self.parent: Optional[Segment] = None self.sibling: Optional[Segment] = None + self.data_sibling: Optional[Segment] = None self.rodata_sibling: Optional[Segment] = None self.file_path: Optional[Path] = None @@ -236,6 +271,14 @@ class Segment: # For segments which are not in the usual VRAM segment space, like N64's IPL3 which lives in 0xA4... self.special_vram_segment: bool = False + self.linker_section_order: Optional[str] = self.parse_linker_section_order(yaml) + self.linker_section: Optional[str] = self.parse_linker_section(yaml) + + # If not defined on the segment then default to the global option + self.ld_fill_value: Optional[int] = self.parse_ld_fill_value( + yaml, options.opts.ld_fill_value + ) + if self.rom_start is not None and self.rom_end is not None: if self.rom_start > self.rom_end: log.error( @@ -252,7 +295,15 @@ class Segment: ): type = Segment.parse_segment_type(yaml) name = Segment.parse_segment_name(cls, rom_start, yaml) - vram_start = vram if vram is not None else parse_segment_vram(yaml) + + vram_class = parse_segment_vram_class(yaml) + + if vram is not None: + vram_start = vram + elif vram_class: + vram_start = vram_class.vram + else: + vram_start = parse_segment_vram(yaml) args: List[str] = [] if isinstance(yaml, dict) else yaml[3:] @@ -267,11 +318,14 @@ class Segment: ) ret.given_section_order = parse_segment_section_order(yaml) ret.given_subalign = parse_segment_subalign(yaml) + if isinstance(yaml, dict): ret.extract = bool(yaml.get("extract", ret.extract)) ret.exclusive_ram_id = yaml.get("exclusive_ram_id") ret.given_dir = Path(yaml.get("dir", "")) ret.has_linker_entry = bool(yaml.get("linker_entry", True)) + ret.given_find_file_boundaries = yaml.get("find_file_boundaries", None) + ret.given_symbol_name_format = Segment.parse_segment_symbol_name_format(yaml) ret.given_symbol_name_format_no_rom = ( Segment.parse_segment_symbol_name_format_no_rom(yaml) @@ -279,11 +333,20 @@ class Segment: ret.file_path = Segment.parse_segment_file_path(yaml) ret.bss_contains_common = Segment.parse_segment_bss_contains_common(yaml) - if not ret.given_follows_vram: - ret.given_follows_vram = parse_segment_follows_vram(yaml) - if not ret.vram_of_symbol: - ret.vram_of_symbol = parse_segment_vram_of_symbol(yaml) + ret.given_follows_vram = parse_segment_follows_vram(yaml) + ret.given_vram_symbol = parse_segment_vram_symbol(yaml) + + if vram_class: + ret.vram_class = vram_class + if ret.given_follows_vram: + log.error( + f"Error: segment {ret.name} has both a vram class and a follows_vram property" + ) + if ret.given_vram_symbol: + log.error( + f"Error: segment {ret.name} has both a vram class and a vram_symbol property" + ) if not ret.align: ret.align = parse_segment_align(yaml) @@ -294,6 +357,11 @@ class Segment: def is_text() -> bool: return False + # For read-write segments (.data); like data + @staticmethod + def is_data() -> bool: + return False + # For readonly segments (.rodata); like rodata or rdata @staticmethod def is_rodata() -> bool: @@ -319,6 +387,18 @@ class Segment: else: return self.given_dir + @property + def show_file_boundaries(self) -> bool: + # If the segment has explicitly set `find_file_boundaries`, use it. + if self.given_find_file_boundaries is not None: + return self.given_find_file_boundaries + + # If the segment has no parent, use options as default. + if not self.parent: + return options.opts.find_file_boundaries + + return self.parent.show_file_boundaries + @property def symbol_name_format(self) -> str: return self.given_symbol_name_format @@ -334,6 +414,15 @@ class Segment: else: return self.given_subalign + @property + def vram_symbol(self) -> Optional[str]: + if self.vram_class and self.vram_class.vram_symbol: + return self.vram_class.vram_symbol + elif self.given_vram_symbol: + return self.given_vram_symbol + else: + return None + def get_exclusive_ram_id(self) -> Optional[str]: if self.parent: return self.parent.get_exclusive_ram_id() @@ -383,6 +472,13 @@ class Segment: self.section_order.index(".rodata") - self.section_order.index(".data") == 1 ) + def get_cname(self) -> str: + name = self.name + if self.parent: + name = self.parent.name + "_" + name + + return to_cname(name) + def contains_vram(self, vram: int) -> bool: if self.vram_start is not None and self.vram_end is not None: return vram >= self.vram_start and vram < self.vram_end @@ -428,6 +524,42 @@ class Segment: def get_linker_section(self) -> str: return ".data" + def get_linker_section_order(self) -> str: + """ + Used to override the linking _order_ of a specific section + + Useful for files that may have non-conventional orderings (like putting .data with the other .rodata sections) + """ + if self.linker_section_order is not None: + return self.linker_section_order + return self.get_linker_section() + + def get_linker_section_linksection(self) -> str: + """ + The actual section that will be used when linking + """ + if self.linker_section is not None: + return self.linker_section + return self.get_linker_section() + + def get_section_flags(self) -> Optional[str]: + """ + Allows specifying flags for a section. + + This can be useful when creating a custom section, since sections not recognized by the linker will not be linked properly. + + GNU as docs about the section directive and flags: https://sourceware.org/binutils/docs/as/Section.html#ELF-Version + + Example: + + ``` + def get_section_flags(self) -> Optional[str]: + # Tells the linker to allocate this section + return "a" + ``` + """ + return None + def out_path(self) -> Optional[Path]: return None @@ -448,7 +580,16 @@ class Segment: path = self.out_path() if path: - return [LinkerEntry(self, [path], path, self.get_linker_section())] + return [ + LinkerEntry( + self, + [path], + path, + self.get_linker_section_order(), + self.get_linker_section_linksection(), + self.is_noload(), + ) + ] else: return [] @@ -504,6 +645,27 @@ class Segment: return None return items[0] + def retrieve_sym_type( + self, syms: Dict[int, List[Symbol]], addr: int, type: str + ) -> Optional[symbols.Symbol]: + if addr not in syms: + return None + + items = syms[addr] + + items = [ + i + for i in items + if i.segment is None + or Segment.visible_ram(self, i.segment) + and (type == i.type) + ] + + if len(items) == 0: + return None + + return items[0] + def get_symbol( self, addr: int, @@ -514,7 +676,6 @@ class Segment: reference: bool = False, search_ranges: bool = False, local_only: bool = False, - dead: bool = True, ) -> Optional[Symbol]: ret: Optional[Symbol] = None rom: Optional[int] = None @@ -545,10 +706,6 @@ class Segment: if cands: ret = cands.pop().data - # Reject dead symbols unless we allow them - if not dead and ret and ret.dead: - ret = None - # Create the symbol if it doesn't exist if not ret and create: ret = Symbol(addr, rom=rom, type=type) @@ -584,7 +741,6 @@ class Segment: reference: bool = False, search_ranges: bool = False, local_only: bool = False, - dead: bool = True, ) -> Symbol: ret = self.get_symbol( addr, @@ -595,7 +751,6 @@ class Segment: reference=reference, search_ranges=search_ranges, local_only=local_only, - dead=dead, ) assert ret is not None diff --git a/tools/splat/split.py b/tools/splat/split.py index 7ec4b6998e..2e0bbbc812 100755 --- a/tools/splat/split.py +++ b/tools/splat/split.py @@ -5,21 +5,26 @@ import hashlib import importlib import pickle from typing import Any, Dict, List, Optional, Set, Tuple, Union +from pathlib import Path from disassembler import disassembler_instance -import tqdm +from util import progress_bar, vram_classes + +# This unused import makes the yaml library faster. don't remove +import pylibyaml # pyright: ignore import yaml + from colorama import Fore, Style from intervaltree import Interval, IntervalTree +import sys from segtypes.linker_entry import ( LinkerWriter, get_segment_vram_end_symbol_name, - to_cname, ) from segtypes.segment import Segment from util import log, options, palettes, symbols, relocs -VERSION = "0.16.1" +VERSION = "0.19.0" parser = argparse.ArgumentParser( description="Split a rom given a rom, a config, and output directory" @@ -35,6 +40,14 @@ parser.add_argument( action="store_true", help="Skips the disassembler's version check", ) +parser.add_argument( + "--stdout-only", help="Print all output to stdout", action="store_true" +) +parser.add_argument( + "--disassemble-all", + help="Disasemble matched functions and migrated data", + action="store_true", +) linker_writer: LinkerWriter config: Dict[str, Any] @@ -119,7 +132,7 @@ def initialize_segments(config_segments: Union[dict, list]) -> List[Segment]: log.error( f"segment '{segment.given_follows_vram}', the 'follows_vram' value for segment '{segment.name}', does not exist" ) - segment.vram_of_symbol = get_segment_vram_end_symbol_name( + segment.given_vram_symbol = get_segment_vram_end_symbol_name( segments_by_name[segment.given_follows_vram] ) @@ -209,9 +222,46 @@ def brief_seg_name(seg: Segment, limit: int, ellipsis="…") -> str: return s -def main(config_path, modes, verbose, use_cache=True, skip_version_check=False): +# Return a mapping of vram classes to segments that need to be part of their vram symbol's calculation +def calc_segment_dependences( + all_segments: List[Segment], +) -> Dict[vram_classes.VramClass, List[Segment]]: + # Map vram class names to segments that have that vram class + vram_class_to_segments: Dict[str, List[Segment]] = {} + for seg in all_segments: + if seg.vram_class is not None: + if seg.vram_class.name not in vram_class_to_segments: + vram_class_to_segments[seg.vram_class.name] = [] + vram_class_to_segments[seg.vram_class.name].append(seg) + + # Map vram class names to segments that the vram class follows + vram_class_to_follows_segments: Dict[vram_classes.VramClass, List[Segment]] = {} + for vram_class in vram_classes._vram_classes.values(): + if vram_class.follows_classes: + vram_class_to_follows_segments[vram_class] = [] + + for follows_class in vram_class.follows_classes: + if follows_class in vram_class_to_segments: + vram_class_to_follows_segments[ + vram_class + ] += vram_class_to_segments[follows_class] + return vram_class_to_follows_segments + + +def main( + config_path, + modes, + verbose, + use_cache=True, + skip_version_check=False, + stdout_only=False, + disassemble_all=False, +): global config + if stdout_only: + progress_bar.out_file = sys.stdout + # Load config config = {} for entry in config_path: @@ -219,7 +269,9 @@ def main(config_path, modes, verbose, use_cache=True, skip_version_check=False): additional_config = yaml.load(f.read(), Loader=yaml.SafeLoader) config = merge_configs(config, additional_config) - options.initialize(config, config_path, modes, verbose) + vram_classes.initialize(config.get("vram_classes")) + + options.initialize(config, config_path, modes, verbose, disassemble_all) disassembler_instance.create_disassembler_instance(options.opts.platform) disassembler_instance.get_instance().check_version(skip_version_check, VERSION) @@ -232,6 +284,8 @@ def main(config_path, modes, verbose, use_cache=True, skip_version_check=False): e_sha1 = config["sha1"].lower() if e_sha1 != sha1: log.error(f"sha1 mismatch: expected {e_sha1}, was {sha1}") + else: + log.write("Warning: no sha1 in config") # Create main output dir options.opts.base_path.mkdir(parents=True, exist_ok=True) @@ -289,7 +343,7 @@ def main(config_path, modes, verbose, use_cache=True, skip_version_check=False): palettes.initialize(all_segments) # Scan - scan_bar = tqdm.tqdm(all_segments, total=len(all_segments)) + scan_bar = progress_bar.get_progress_bar(all_segments) for segment in scan_bar: assert isinstance(segment, Segment) scan_bar.set_description(f"Scanning {brief_seg_name(segment, 20)}") @@ -319,10 +373,7 @@ def main(config_path, modes, verbose, use_cache=True, skip_version_check=False): symbols.mark_c_funcs_as_defined() # Split - split_bar = tqdm.tqdm( - all_segments, - total=len(all_segments), - ) + split_bar = progress_bar.get_progress_bar(all_segments) for segment in split_bar: split_bar.set_description(f"Splitting {brief_seg_name(segment, 20)}") @@ -349,50 +400,88 @@ def main(config_path, modes, verbose, use_cache=True, skip_version_check=False): if ( options.opts.is_mode_active("ld") and options.opts.platform != "gc" ): # TODO move this to platform initialization when it gets implemented - # Calculate list of segments for which we need to find the largest, so we can safely place the symbol after it - max_vram_end_syms: Dict[str, List[Segment]] = {} - for sym in symbols.appears_after_overlays_syms: - max_vram_end_syms[sym.name] = [ - seg - for seg in all_segments - if isinstance(seg.vram_start, int) - and seg.vram_start == sym.appears_after_overlays_addr - ] - max_vram_end_sym_names: Set[str] = set(max_vram_end_syms.keys()) + vram_class_dependencies = calc_segment_dependences(all_segments) + vram_classes_to_search = set(vram_class_dependencies.keys()) max_vram_end_insertion_points: Dict[ Segment, List[Tuple[str, List[Segment]]] ] = {} - # Find the last segment whose vram_of_symbol is one of the max_vram_end_syms - for segment in reversed(all_segments): - vram_of_sym = segment.vram_of_symbol - if vram_of_sym is not None and vram_of_sym in max_vram_end_sym_names: - if segment not in max_vram_end_insertion_points: - max_vram_end_insertion_points[segment] = [] - max_vram_end_insertion_points[segment].append( - (vram_of_sym, max_vram_end_syms[vram_of_sym]) + for seg in reversed(all_segments): + if seg.vram_class in vram_classes_to_search: + assert seg.vram_class.vram_symbol is not None + if seg not in max_vram_end_insertion_points: + max_vram_end_insertion_points[seg] = [] + max_vram_end_insertion_points[seg].append( + ( + seg.vram_class.vram_symbol, + vram_class_dependencies[seg.vram_class], + ) ) - max_vram_end_sym_names.remove(vram_of_sym) + vram_classes_to_search.remove(seg.vram_class) global linker_writer linker_writer = LinkerWriter() - linker_bar = tqdm.tqdm( - all_segments, - total=len(all_segments), - ) + linker_bar = progress_bar.get_progress_bar(all_segments) + + partial_linking = options.opts.ld_partial_linking + partial_scripts_path = options.opts.ld_partial_scripts_path + segments_path = options.opts.ld_partial_build_segments_path + if partial_linking: + if partial_scripts_path is None: + log.error( + "Partial linking is enabled but `ld_partial_scripts_path` has not been set" + ) + if options.opts.ld_partial_build_segments_path is None: + log.error( + "Partial linking is enabled but `ld_partial_build_segments_path` has not been set" + ) for segment in linker_bar: + assert isinstance(segment, Segment) linker_bar.set_description(f"Linker script {brief_seg_name(segment, 20)}") - linker_writer.add(segment, max_vram_end_insertion_points.get(segment, [])) - linker_writer.save_linker_script() + max_vram_syms = max_vram_end_insertion_points.get(segment, []) + + if options.opts.ld_partial_linking: + linker_writer.add_referenced_partial_segment(segment, max_vram_syms) + + # Create linker script for segment + sub_linker_writer = LinkerWriter(is_partial=True) + sub_linker_writer.add_partial_segment(segment) + + assert partial_scripts_path is not None + assert segments_path is not None + + seg_name = segment.get_cname() + + sub_linker_writer.save_linker_script( + partial_scripts_path / f"{seg_name}.ld" + ) + if options.opts.ld_dependencies: + sub_linker_writer.save_dependencies_file( + partial_scripts_path / f"{seg_name}.d", + segments_path / f"{seg_name}.o", + ) + else: + linker_writer.add(segment, max_vram_syms) + + linker_writer.save_linker_script(options.opts.ld_script_path) linker_writer.save_symbol_header() + if options.opts.ld_dependencies: + elf_path = options.opts.elf_path + if elf_path is None: + log.error( + "Generation of dependency file for linker script requested but `elf_path` was not provided in the yaml options" + ) + linker_writer.save_dependencies_file( + options.opts.ld_script_path.with_suffix(".d"), elf_path + ) # write elf_sections.txt - this only lists the generated sections in the elf, not subsections # that the elf combines into one section if options.opts.elf_section_list_path: section_list = "" for segment in all_segments: - section_list += "." + to_cname(segment.name) + "\n" + section_list += "." + segment.get_cname() + "\n" with open(options.opts.elf_section_list_path, "w", newline="\n") as f: f.write(section_list) @@ -401,7 +490,7 @@ def main(config_path, modes, verbose, use_cache=True, skip_version_check=False): to_write = [ s for s in symbols.all_symbols - if s.referenced and not s.defined and not s.dead and s.type == "func" + if s.referenced and not s.defined and s.type == "func" ] to_write.sort(key=lambda x: x.vram_start) @@ -416,7 +505,6 @@ def main(config_path, modes, verbose, use_cache=True, skip_version_check=False): for s in symbols.all_symbols if s.referenced and not s.defined - and not s.dead and s.type not in {"func", "label", "jtbl_label"} ] to_write.sort(key=lambda x: x.vram_start) @@ -448,14 +536,12 @@ def main(config_path, modes, verbose, use_cache=True, skip_version_check=False): pickle.dump(cache, f4) if options.opts.dump_symbols and options.opts.is_mode_active("code"): - from pathlib import Path - splat_hidden_folder = Path(".splat/") splat_hidden_folder.mkdir(exist_ok=True) with open(splat_hidden_folder / "splat_symbols.csv", "w") as f: f.write( - "vram_start,given_name,name,type,given_size,size,rom,defined,user_declared,referenced,dead,extract\n" + "vram_start,given_name,name,type,given_size,size,rom,defined,user_declared,referenced,extract\n" ) for s in sorted(symbols.all_symbols, key=lambda x: x.vram_start): f.write(f"{s.vram_start:X},{s.given_name},{s.name},{s.type},") @@ -468,13 +554,19 @@ def main(config_path, modes, verbose, use_cache=True, skip_version_check=False): f.write(f"0x{s.rom:X},") else: f.write("None,") - f.write( - f"{s.defined},{s.user_declared},{s.referenced},{s.dead},{s.extract}\n" - ) + f.write(f"{s.defined},{s.user_declared},{s.referenced},{s.extract}\n") symbols.spim_context.saveContextToFile(splat_hidden_folder / "spim_context.csv") if __name__ == "__main__": args = parser.parse_args() - main(args.config, args.modes, args.verbose, args.use_cache, args.skip_version_check) + main( + args.config, + args.modes, + args.verbose, + args.use_cache, + args.skip_version_check, + args.stdout_only, + args.disassemble_all, + ) diff --git a/tools/splat/test.py b/tools/splat/test.py index 3685541145..549c112106 100644 --- a/tools/splat/test.py +++ b/tools/splat/test.py @@ -47,6 +47,7 @@ class Testing(unittest.TestCase): self.get_right_only_files(sub_dcmp, out) def test_basic_app(self): + spimdisasm.common.GlobalConfig.ASM_GENERATED_BY = False main(["test/basic_app/splat.yaml"], None, None) comparison = filecmp.dircmp("test/basic_app/split", "test/basic_app/expected") @@ -340,8 +341,7 @@ class SymbolsInitialize(unittest.TestCase): test_init() sym_addrs_lines = [ - "func_1 = 0x100 // type:func size:10 rom:100 segment:test_segment name_end:the_name_end " - "appears_after_overlays_addr:1234" + "func_1 = 0x100; // type:func size:10 rom:100 segment:test_segment name_end:the_name_end " ] all_segments = [ @@ -365,7 +365,6 @@ class SymbolsInitialize(unittest.TestCase): assert symbols.all_symbols[0].rom == 100 assert symbols.all_symbols[0].segment == all_segments[0] assert symbols.all_symbols[0].given_name_end == "the_name_end" - assert symbols.appears_after_overlays_syms[0] == symbols.all_symbols[0] def test_boolean_attrs(self): import pathlib @@ -374,7 +373,7 @@ class SymbolsInitialize(unittest.TestCase): test_init() sym_addrs_lines = [ - "func_1 = 0x100 // dead:True defined:True extract:True force_migration:True force_not_migration:True " + "func_1 = 0x100; // defined:True extract:True force_migration:True force_not_migration:True " "allow_addend:True dont_allow_addend:True" ] @@ -393,7 +392,6 @@ class SymbolsInitialize(unittest.TestCase): symbols.handle_sym_addrs( pathlib.Path("/tmp/thing"), sym_addrs_lines, all_segments ) - assert symbols.all_symbols[0].dead == True assert symbols.all_symbols[0].defined == True assert symbols.all_symbols[0].force_migration == True assert symbols.all_symbols[0].force_not_migration == True @@ -407,7 +405,7 @@ class SymbolsInitialize(unittest.TestCase): symbols.reset_symbols() test_init() - sym_addrs_lines = ["func_1 = 0x100 // ignore:True size:4"] + sym_addrs_lines = ["func_1 = 0x100; // ignore:True size:4"] all_segments = [ Segment( @@ -424,8 +422,8 @@ class SymbolsInitialize(unittest.TestCase): symbols.handle_sym_addrs( pathlib.Path("/tmp/thing"), sym_addrs_lines, all_segments ) - assert symbols.spim_context.bannedRangedSymbols[0].start == 16 - assert symbols.spim_context.bannedRangedSymbols[0].end == 20 + assert symbols.spim_context.bannedRangedSymbols[0].start == 0x100 + assert symbols.spim_context.bannedRangedSymbols[0].end == 0x100 + 4 class InitializeSpimContext(unittest.TestCase): diff --git a/tools/splat/test/basic_app/.gitignore b/tools/splat/test/basic_app/.gitignore new file mode 100644 index 0000000000..df3d40d83c --- /dev/null +++ b/tools/splat/test/basic_app/.gitignore @@ -0,0 +1,3 @@ +build/ +split/ +gcc-2.7.2/ diff --git a/tools/splat/test/basic_app/build.sh b/tools/splat/test/basic_app/build.sh index 0e11e369ef..0eb0ff12cc 100755 --- a/tools/splat/test/basic_app/build.sh +++ b/tools/splat/test/basic_app/build.sh @@ -1,3 +1,7 @@ +#!/bin/bash + +set -e + mkdir -p build echo "Building..." export PATH=/gcc-2.7.2:$PATH diff --git a/tools/splat/test/basic_app/expected/.splache b/tools/splat/test/basic_app/expected/.splache index c855f15853..8f17e1346d 100644 Binary files a/tools/splat/test/basic_app/expected/.splache and b/tools/splat/test/basic_app/expected/.splache differ diff --git a/tools/splat/test/basic_app/expected/basic_app.ld b/tools/splat/test/basic_app/expected/basic_app.ld index 0779b7e40e..bd3d10bced 100644 --- a/tools/splat/test/basic_app/expected/basic_app.ld +++ b/tools/splat/test/basic_app/expected/basic_app.ld @@ -6,6 +6,7 @@ SECTIONS header_VRAM = ADDR(.header); .header : AT(header_ROM_START) SUBALIGN(16) { + FILL(0x00000000); header_DATA_START = .; header_s = .; build/split/asm/header.s.o(.data); @@ -20,6 +21,7 @@ SECTIONS dummy_ipl3_VRAM = ADDR(.dummy_ipl3); .dummy_ipl3 0xA4000040 : AT(dummy_ipl3_ROM_START) SUBALIGN(16) { + FILL(0x00000000); dummy_ipl3_DATA_START = .; dummy_ipl3_bin = .; build/split/assets/dummy_ipl3.bin.o(.data); @@ -35,6 +37,7 @@ SECTIONS boot_VRAM = ADDR(.boot); .boot 0x80000400 : AT(boot_ROM_START) SUBALIGN(16) { + FILL(0x00000000); boot_TEXT_START = .; build/split/src/main.c.o(.text); build/split/asm/handwritten.s.o(.text); @@ -53,6 +56,7 @@ SECTIONS boot_bss_VRAM = ADDR(.boot_bss); .boot_bss (NOLOAD) : SUBALIGN(16) { + FILL(0x00000000); boot_BSS_START = .; build/split/asm/data/main.bss.s.o(.bss); boot_BSS_END = .; diff --git a/tools/splat/test/basic_app/splat.yaml b/tools/splat/test/basic_app/splat.yaml index c1d2cf9377..d4d4a41c14 100644 --- a/tools/splat/test/basic_app/splat.yaml +++ b/tools/splat/test/basic_app/splat.yaml @@ -12,7 +12,6 @@ options: undefined_funcs_auto_path: split/undefined_funcs_auto.txt undefined_syms_auto_path: split/undefined_syms_auto.txt asset_path: split/assets - asm_generated_by: False compiler: GCC segments: - name: header diff --git a/tools/splat/util/compiler.py b/tools/splat/util/compiler.py index e1666dc24e..3c67e5989d 100644 --- a/tools/splat/util/compiler.py +++ b/tools/splat/util/compiler.py @@ -6,6 +6,7 @@ from typing import Optional class Compiler: name: str asm_function_macro: str = "glabel" + asm_function_alt_macro: str = "glabel" asm_jtbl_label_macro: str = "glabel" asm_data_macro: str = "glabel" asm_end_label: str = "" diff --git a/tools/splat/util/log.py b/tools/splat/util/log.py index df6ef53b53..4f296da1bd 100644 --- a/tools/splat/util/log.py +++ b/tools/splat/util/log.py @@ -1,5 +1,6 @@ import sys from typing import NoReturn, Optional +from pathlib import Path from colorama import Fore, init, Style @@ -26,7 +27,7 @@ def error(*args, **kwargs) -> NoReturn: # The line_num is expected to be zero-indexed -def parsing_error_preamble(path, line_num, line): +def parsing_error_preamble(path: Path, line_num: int, line: str): write("") write(f"error reading {path}, line {line_num + 1}:", status="error") write(f"\t{line}") diff --git a/tools/splat/util/options.py b/tools/splat/util/options.py index 09db8f0565..c1c1b19336 100644 --- a/tools/splat/util/options.py +++ b/tools/splat/util/options.py @@ -20,6 +20,8 @@ class SplatOpts: base_path: Path # Determines the path to the target binary target_path: Path + # Path to the final elf target + elf_path: Optional[Path] # Determines the platform of the target binary platform: str # Determines the compiler used to compile the target binary @@ -37,6 +39,8 @@ class SplatOpts: use_o_as_suffix: bool # the value of the $gp register to correctly calculate offset to %gp_rel relocs gp: Optional[int] + # Checks and errors if there are any non consecutive segment types + check_consecutive_segment_types: bool # Paths asset_path: Path @@ -93,17 +97,38 @@ class SplatOpts: # Determines the desired path to the linker symbol header, # which exposes externed definitions for all segment ram/rom start/end locations ld_symbol_header_path: Optional[Path] - # Determines whether to add a discard section to the linker script + # Determines whether to add a discard section with a wildcard to the linker script ld_discard_section: bool + # A list of sections to preserve during link time. It can be useful to preserve debugging sections + ld_sections_allowlist: List[str] + # A list of sections to discard during link time. It can be useful to avoid using the wildcard discard. Note that this option does not turn off `ld_discard_section` + ld_sections_denylist: List[str] # Determines the list of section labels that are to be added to the linker script ld_section_labels: List[str] # Determines whether to add wildcards for section linking in the linker script (.rodata* for example) ld_wildcard_sections: bool - # Determines whether to use "follows" settings to determine locations of overlays in the linker script. - # If disabled, this effectively ignores "follows" directives in the yaml. - ld_use_follows: bool + # Determines whether to use `follows_vram` (segment option) and + # `vram_symbol` / `follows_classes` (vram_class options) to calculate vram addresses in the linker script. + # If disabled, this uses the plain integer values for vram addresses defined in the yaml. + ld_use_symbolic_vram_addresses: bool + # Change linker script generation to allow partially linking segments. Requires both `ld_partial_scripts_path` and `ld_partial_build_segments_path` to be set. + ld_partial_linking: bool + # Folder were each intermediary linker script will be written to. + ld_partial_scripts_path: Optional[Path] + # Folder where the built partially linked segments will be placed by the build system. + ld_partial_build_segments_path: Optional[Path] + # Generate a dependency file for every linker script generated. Dependency files will have the same path and name as the corresponding linker script, but changing the extension to `.d`. Requires `elf_path` to be set. + ld_dependencies: bool + # Legacy linker script generation does not impose the section_order specified in the yaml options or per-segment options. + ld_legacy_generation: bool # If enabled, the end symbol for each segment will be placed before the alignment directive for the segment segment_end_before_align: bool + # Controls the style of the auto-generated segment symbols in the linker script. Possible values: splat, makerom + segment_symbols_style: str + # Specifies the starting offset for rom address symbols in the linker script. + ld_rom_start: int + # The value passed to the FILL statement on each segment. `None` disables using FILL statements on the linker script. Defaults to a fill value of 0. + ld_fill_value: Optional[int] ################################################################################ # C file options @@ -136,6 +161,8 @@ class SplatOpts: asm_inc_header: str # Determines the macro used to declare functions in asm files asm_function_macro: str + # Determines the macro used to declare symbols in the middle of functions in asm files (which may be alternative entries) + asm_function_alt_macro: str # Determines the macro used to declare jumptable labels in asm files asm_jtbl_label_macro: str # Determines the macro used to declare data symbols in asm files @@ -171,12 +198,12 @@ class SplatOpts: data_string_guesser_level: Optional[int] # Global option for allowing data symbols using addends on symbol references. It can be overriden per symbol allow_data_addends: bool - # Determines whether to include the "Generated by spimdisasm" text in the asm - asm_generated_by: bool # Tells the disassembler to try disassembling functions with unknown instructions instead of falling back to disassembling as raw data disasm_unknown: bool # Tries to detect redundant and unreferenced functions ends and merge them together. This option is ignored if the compiler is not set to IDO. detect_redundant_function_end: bool + # Don't skip disassembling already matched functions and migrated sections + disassemble_all: bool ################################################################################ # N64-specific options @@ -188,6 +215,8 @@ class SplatOpts: gfx_ucode: str # Use named libultra symbols by default. Those will need to be added to a linker script manually by the user libultra_symbols: bool + # Use named libultra symbols by default. Those will need to be added to a linker script manually by the user + ique_symbols: bool # Use named hardware register symbols by default. Those will need to be added to a linker script manually by the user hardware_regs: bool @@ -279,6 +308,7 @@ def _parse_yaml( config_paths: List[str], modes: List[str], verbose: bool = False, + disasm_all: bool = False, ) -> SplatOpts: p = OptParser(yaml) @@ -317,6 +347,7 @@ def _parse_yaml( modes=modes, base_path=base_path, target_path=p.parse_path(base_path, "target_path"), + elf_path=p.parse_optional_path(base_path, "elf_path"), platform=platform, compiler=comp, endianness=parse_endianness(), @@ -329,6 +360,9 @@ def _parse_yaml( generated_s_preamble=p.parse_opt("generated_s_preamble", str, ""), use_o_as_suffix=p.parse_opt("o_as_suffix", bool, False), gp=p.parse_opt("gp_value", int, 0), + check_consecutive_segment_types=p.parse_opt( + "check_consecutive_segment_types", bool, True + ), asset_path=p.parse_path(base_path, "asset_path", "assets"), symbol_addrs_paths=p.parse_path_list( base_path, "symbol_addrs_path", "symbol_addrs.txt" @@ -364,14 +398,32 @@ def _parse_yaml( ld_script_path=p.parse_path(base_path, "ld_script_path", f"{basename}.ld"), ld_symbol_header_path=p.parse_optional_path(base_path, "ld_symbol_header_path"), ld_discard_section=p.parse_opt("ld_discard_section", bool, True), + ld_sections_allowlist=p.parse_opt("ld_sections_allowlist", list, []), + ld_sections_denylist=p.parse_opt("ld_sections_denylist", list, []), ld_section_labels=p.parse_opt( "ld_section_labels", list, [".text", ".data", ".rodata", ".bss"], ), ld_wildcard_sections=p.parse_opt("ld_wildcard_sections", bool, False), - ld_use_follows=p.parse_opt("ld_use_follows", bool, True), + ld_use_symbolic_vram_addresses=p.parse_opt( + "ld_use_symbolic_vram_addresses", bool, True + ), + ld_partial_linking=p.parse_opt("ld_partial_linking", bool, False), + ld_partial_scripts_path=p.parse_optional_path( + base_path, "ld_partial_scripts_path" + ), + ld_partial_build_segments_path=p.parse_optional_path( + base_path, "ld_partial_build_segments_path" + ), + ld_dependencies=p.parse_opt("ld_dependencies", bool, False), + ld_legacy_generation=p.parse_opt("ld_legacy_generation", bool, False), segment_end_before_align=p.parse_opt("segment_end_before_align", bool, False), + segment_symbols_style=p.parse_opt_within( + "segment_symbols_style", str, ["splat", "makerom"], "splat" + ), + ld_rom_start=p.parse_opt("ld_rom_start", int, 0), + ld_fill_value=p.parse_opt("ld_fill_value", int, 0), create_c_files=p.parse_opt("create_c_files", bool, True), auto_decompile_empty_functions=p.parse_opt( "auto_decompile_empty_functions", bool, True @@ -391,6 +443,9 @@ def _parse_yaml( asm_function_macro=p.parse_opt( "asm_function_macro", str, comp.asm_function_macro ), + asm_function_alt_macro=p.parse_opt( + "asm_function_alt_macro", str, comp.asm_function_alt_macro + ), asm_jtbl_label_macro=p.parse_opt( "asm_jtbl_label_macro", str, comp.asm_jtbl_label_macro ), @@ -433,14 +488,18 @@ def _parse_yaml( "f3dex2", ), libultra_symbols=p.parse_opt("libultra_symbols", bool, False), + ique_symbols=p.parse_opt("ique_symbols", bool, False), hardware_regs=p.parse_opt("hardware_regs", bool, False), use_legacy_include_asm=p.parse_opt("use_legacy_include_asm", bool, True), filesystem_path=p.parse_optional_path(base_path, "filesystem_path"), - asm_generated_by=p.parse_opt("asm_generated_by", bool, True), disasm_unknown=p.parse_opt("disasm_unknown", bool, False), detect_redundant_function_end=p.parse_opt( "detect_redundant_function_end", bool, True ), + # Command line argument takes precedence over yaml option + disassemble_all=disasm_all + if disasm_all + else p.parse_opt("disassemble_all", bool, False), ) p.check_no_unread_opts() return ret @@ -451,10 +510,11 @@ def initialize( config_paths: List[str], modes: Optional[List[str]] = None, verbose=False, + disasm_all=False, ): global opts if not modes: modes = ["all"] - opts = _parse_yaml(config["options"], config_paths, modes, verbose) + opts = _parse_yaml(config["options"], config_paths, modes, verbose, disasm_all) diff --git a/tools/splat/util/progress_bar.py b/tools/splat/util/progress_bar.py new file mode 100644 index 0000000000..caec2cee8c --- /dev/null +++ b/tools/splat/util/progress_bar.py @@ -0,0 +1,8 @@ +import tqdm +import sys + +out_file = sys.stderr + + +def get_progress_bar(elements: list) -> tqdm.tqdm: + return tqdm.tqdm(elements, total=len(elements), file=out_file) diff --git a/tools/splat/util/psx/__init__.py b/tools/splat/util/psx/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/tools/splat/util/psx/psxexeinfo.py b/tools/splat/util/psx/psxexeinfo.py new file mode 100755 index 0000000000..490bb6d819 --- /dev/null +++ b/tools/splat/util/psx/psxexeinfo.py @@ -0,0 +1,117 @@ +#! /usr/bin/env python3 + +from __future__ import annotations + +import argparse + +import hashlib +import struct + +import dataclasses + +from pathlib import Path + + +@dataclasses.dataclass +class PsxExe: + # Based on https://psx-spx.consoledev.net/cdromdrive/#filenameexe-general-purpose-executable + initial_pc: int # offset: 0x10 + initial_gp: int # offset: 0x14 + destination_vram: int # offset: 0x18 + file_size: int # offset: 0x1C + data_vram: int # offset: 0x20 + data_size: int # offset: 0x24 + bss_vram: int # offset: 0x28 + bss_size: int # offset: 0x2C + initial_sp_base: int # offset: 0x30 + initial_sp_offset: int # offset: 0x34 + + size: int + sha1: str + + @property + def text_offset(self) -> int: + return self.initial_pc - self.destination_vram + 0x800 + + @property + def data_offset(self) -> int: + if self.data_vram == 0 or self.data_size == 0: + return 0 + return self.data_vram - self.destination_vram + 0x800 + + @staticmethod + def get_info(exe_path: Path, exe_bytes: bytes) -> PsxExe: + initial_pc = struct.unpack(" =
// attr0:val0 attr1:val1 [...]") + log.write("Line must be of the form") + log.write(" =
; // attr0:val0 attr1:val1 [...]") log.write("with
in hex preceded by 0x, or dec") log.write("") raise @@ -179,10 +181,6 @@ def handle_sym_addrs( if attr_name == "name_end": sym.given_name_end = attr_val continue - if attr_name == "appears_after_overlays_addr": - sym.appears_after_overlays_addr = int(attr_val, 0) - appears_after_overlays_syms.append(sym) - continue except: log.parsing_error_preamble(path, line_num, line) log.write( @@ -207,9 +205,6 @@ def handle_sym_addrs( log.write([*TRUEY_VALS, *FALSEY_VALS]) log.error("") else: - if attr_name == "dead": - sym.dead = tf_val - continue if attr_name == "defined": sym.defined = tf_val continue @@ -249,6 +244,29 @@ def handle_sym_addrs( sym.segment.add_symbol(sym) sym.user_declared = True + + if sym.name in seen_symbols: + log.parsing_error_preamble(path, line_num, line) + log.error( + f"Duplicate symbol detected! {sym.name} has already been defined at 0x{seen_symbols[sym.name].vram_start:X}" + ) + + if addr in all_symbols_dict: + items = all_symbols_dict[addr] + for item in items: + if ( + sym.rom == item.rom + or None in (sym.rom, item.rom) + or sym.segment == item.segment + or None in (sym.segment, item.rom) + ): + log.parsing_error_preamble(path, line_num, line) + log.error( + f"Duplicate symbol detected! {sym.name} clashes with {item.name} defined at 0x{addr:X}" + ) + + seen_symbols[sym.name] = sym + add_symbol(sym) @@ -543,7 +561,6 @@ class Symbol: defined: bool = False referenced: bool = False - dead: bool = False extract: bool = True user_declared: bool = False @@ -558,8 +575,6 @@ class Symbol: _generated_default_name: Optional[str] = None _last_type: Optional[str] = None - appears_after_overlays_addr: Optional[int] = None - def __str__(self): return self.name @@ -659,10 +674,8 @@ def reset_symbols(): global all_symbols_ranges global ignored_addresses global to_mark_as_defined - global appears_after_overlays_syms all_symbols = [] all_symbols_dict = {} all_symbols_ranges = IntervalTree() ignored_addresses = set() to_mark_as_defined = set() - appears_after_overlays_syms = [] diff --git a/tools/splat/util/vram_classes.py b/tools/splat/util/vram_classes.py new file mode 100644 index 0000000000..c296bbbd59 --- /dev/null +++ b/tools/splat/util/vram_classes.py @@ -0,0 +1,102 @@ +from dataclasses import dataclass, field +from typing import Any, Dict, List, Optional + +from util import log + + +@dataclass(frozen=True) +class VramClass: + name: str + vram: int + given_vram_symbol: Optional[str] = None + follows_classes: List[str] = field(default_factory=list, compare=False) + + @property + def vram_symbol(self) -> Optional[str]: + if self.given_vram_symbol is not None: + return self.given_vram_symbol + elif self.follows_classes: + return self.name + "_CLASS_VRAM" + else: + return None + + +_vram_classes: Dict[str, VramClass] = {} + + +def initialize(yaml: Any): + global _vram_classes + + _vram_classes = {} + + if yaml is None: + return + + if not isinstance(yaml, list): + log.error("vram_classes must be a list") + + class_names = set() + for vram_class in yaml: + if isinstance(vram_class, dict): + if "name" not in vram_class: + log.error(f"vram_class ({vram_class}) must have a name") + class_names.add(vram_class["name"]) + elif isinstance(vram_class, list): + class_names.add(vram_class[0]) + + for vram_class in yaml: + name: str + vram: int + vram_symbol: Optional[str] = None + follows_classes: List[str] = [] + + if isinstance(vram_class, dict): + if "name" not in vram_class: + log.error(f"vram_class ({vram_class}) must have a name") + name = vram_class["name"] + + if "vram" not in vram_class: + log.error(f"vram_class ({vram_class}) must have a vram") + vram = vram_class["vram"] + + if "vram_symbol" in vram_class: + vram_symbol = vram_class["vram_symbol"] + if not isinstance(vram_symbol, str): + log.error( + f"vram_symbol ({vram_symbol})must be a string, got {type(vram_symbol)}" + ) + + if "follows_classes" in vram_class: + follows_classes = vram_class["follows_classes"] + if not isinstance(follows_classes, list): + log.error( + f"vram_symbol ({follows_classes})must be a list, got {type(follows_classes)}" + ) + for follows_class in follows_classes: + if follows_class not in class_names: + log.error( + f"follows_class ({follows_class}) not found in vram_classes" + ) + elif isinstance(vram_class, list): + if len(vram_class) != 2: + log.error( + f"vram_class ({vram_class}) must have 2 elements, got {len(vram_class)}" + ) + name = vram_class[0] + vram = vram_class[1] + else: + log.error(f"vram_class must be a dict or list, got {type(vram_class)}") + + if not isinstance(name, str): + log.error(f"vram_class name ({name}) must be a string, got {type(name)}") + if not isinstance(vram, int): + log.error(f"vram_class vram ({vram}) must be an int, got {type(vram)}") + if name in _vram_classes: + log.error(f"Duplicate vram class name '{name}'") + _vram_classes[name] = VramClass(name, vram, vram_symbol, follows_classes) + + +def resolve(name: str) -> VramClass: + if name not in _vram_classes: + log.error(f"Unknown vram class '{name}'") + return _vram_classes[name] diff --git a/tools/splat_ext/pm_charset.py b/tools/splat_ext/pm_charset.py index ecd169b8e2..012883d057 100644 --- a/tools/splat_ext/pm_charset.py +++ b/tools/splat_ext/pm_charset.py @@ -92,5 +92,6 @@ class N64SegPm_charset(N64Segment): [fs_dir / f"{i:02X}.png" for i in range(self.yaml[5])], fs_dir.with_suffix(".dat"), ".data", + ".data", ), ] diff --git a/tools/splat_ext/pm_charset_palettes.py b/tools/splat_ext/pm_charset_palettes.py index cfe04a8f3c..c15ea30653 100644 --- a/tools/splat_ext/pm_charset_palettes.py +++ b/tools/splat_ext/pm_charset_palettes.py @@ -56,5 +56,6 @@ class N64SegPm_charset_palettes(N64Segment): [fs_dir / f"{i:02X}.png" for i in range(self.yaml[3])], fs_dir.with_suffix(".dat"), ".data", + ".data", ), ] diff --git a/tools/splat_ext/pm_effect_loads.py b/tools/splat_ext/pm_effect_loads.py index 14cec5c867..293b0282d3 100644 --- a/tools/splat_ext/pm_effect_loads.py +++ b/tools/splat_ext/pm_effect_loads.py @@ -131,6 +131,7 @@ glabel fx_{name} [self.effect_s_path(effect.name)], self.effect_s_path(effect.name), ".text", + ".text", ) ) diff --git a/tools/splat_ext/pm_effect_shims.py b/tools/splat_ext/pm_effect_shims.py index 0b5240dbc5..9f39475eaf 100644 --- a/tools/splat_ext/pm_effect_shims.py +++ b/tools/splat_ext/pm_effect_shims.py @@ -67,6 +67,6 @@ glabel {name} ret = [] for shim in self.shims: - ret.append(LinkerEntry(self, [self.shim_path(shim)], self.shim_path(shim), ".text")) + ret.append(LinkerEntry(self, [self.shim_path(shim)], self.shim_path(shim), ".text", ".text")) return ret diff --git a/tools/splat_ext/pm_icons.py b/tools/splat_ext/pm_icons.py index 2ad35fe447..8425a45a62 100644 --- a/tools/splat_ext/pm_icons.py +++ b/tools/splat_ext/pm_icons.py @@ -119,5 +119,6 @@ class N64SegPm_icons(N64Segment): [options.opts.asset_path / "icon" / "Icons.xml"], options.opts.asset_path / "icons.bin", self.get_linker_section(), + self.get_linker_section(), ) ] diff --git a/tools/splat_ext/pm_imgfx_data.py b/tools/splat_ext/pm_imgfx_data.py index 3ec39f50b0..c79ab29330 100644 --- a/tools/splat_ext/pm_imgfx_data.py +++ b/tools/splat_ext/pm_imgfx_data.py @@ -122,5 +122,6 @@ class N64SegPm_imgfx_data(N64Segment): [self.OUT_DIR / f"{name}.json" for name, _ in self.yaml.get("animations")], options.opts.asset_path / "imgfx" / f"{self.name}.c", self.get_linker_section(), + self.get_linker_section(), ) ] diff --git a/tools/splat_ext/pm_map_data.py b/tools/splat_ext/pm_map_data.py index b47b516510..0f45163ac6 100644 --- a/tools/splat_ext/pm_map_data.py +++ b/tools/splat_ext/pm_map_data.py @@ -211,5 +211,6 @@ class N64SegPm_map_data(N64Segment): [fs_dir / add_file_ext(name, linker=True) for name in self.files], fs_dir.with_suffix(".dat"), ".data", + ".data", ), ] diff --git a/tools/splat_ext/pm_msg.py b/tools/splat_ext/pm_msg.py index 7fce2326b5..b924b175c0 100644 --- a/tools/splat_ext/pm_msg.py +++ b/tools/splat_ext/pm_msg.py @@ -480,7 +480,7 @@ class N64SegPm_msg(N64Segment): base_path = options.opts.asset_path / f"{self.name}" out_paths = [base_path / Path(f + ".msg") for f in self.files] - return [LinkerEntry(self, out_paths, base_path, ".data")] + return [LinkerEntry(self, out_paths, base_path, ".data", ".data")] @staticmethod def get_default_name(addr): diff --git a/tools/splat_ext/pm_sbn.py b/tools/splat_ext/pm_sbn.py index 665db01825..1c3d0c0297 100644 --- a/tools/splat_ext/pm_sbn.py +++ b/tools/splat_ext/pm_sbn.py @@ -562,6 +562,7 @@ if splat_loaded: [dir], out, ".data", + ".data", ), ] diff --git a/tools/splat_ext/pm_sprite_shading_profiles.py b/tools/splat_ext/pm_sprite_shading_profiles.py index 7441870063..278af18afc 100644 --- a/tools/splat_ext/pm_sprite_shading_profiles.py +++ b/tools/splat_ext/pm_sprite_shading_profiles.py @@ -219,5 +219,6 @@ class N64SegPm_sprite_shading_profiles(N64Segment): [self.OUT_DIR / f"{self.name}.json"], options.opts.asset_path / self.dir / f"{self.name}.bin", self.get_linker_section(), + self.get_linker_section(), ) ] diff --git a/tools/splat_ext/pm_sprites.py b/tools/splat_ext/pm_sprites.py index 59fe0d30f1..b251255cd2 100644 --- a/tools/splat_ext/pm_sprites.py +++ b/tools/splat_ext/pm_sprites.py @@ -838,7 +838,7 @@ class N64SegPm_sprites(N64Segment): # for NPC src_paths += [options.opts.asset_path / "sprite" / "npc" / sprite_name for sprite_name in self.npc_cfg] - return [LinkerEntry(self, src_paths, self.out_path(), self.get_linker_section())] + return [LinkerEntry(self, src_paths, self.out_path(), self.get_linker_section(), self.get_linker_section())] def cache(self): return (self.yaml, self.rom_end, self.player_cfg, self.npc_cfg) diff --git a/ver/ique/splat-shift.yaml b/ver/ique/splat-shift.yaml index bdc2c9fec4..0930dd2c19 100644 --- a/ver/ique/splat-shift.yaml +++ b/ver/ique/splat-shift.yaml @@ -1,2 +1,2 @@ options: - ld_use_follows: True + ld_use_symbolic_vram_addresses: True diff --git a/ver/ique/splat.yaml b/ver/ique/splat.yaml index 5b22e2f4ab..1fefbaeaec 100644 --- a/ver/ique/splat.yaml +++ b/ver/ique/splat.yaml @@ -1,4 +1,5 @@ name: Paper Mario (iQue) +sha1: 5c724685085eba796537573dd6f84aaddedc8582 options: basename: papermario find_file_boundaries: True @@ -486,7 +487,7 @@ segments: - [0x10e120, bin] - - name: ui_images + - name: ui_images_filemenu_pause type: bin start: 0x0000000000179fc0 vram: 0x8023E000 @@ -554,7 +555,6 @@ segments: dir: filemenu start: 0x1AC100 vram: 0x80242ba0 - follows_vram: ui_images subsegments: - [0x1AC100, c, filemenu_common] - [0x1AE190, c, filemenu_main] diff --git a/ver/ique/symbol_addrs.txt b/ver/ique/symbol_addrs.txt index 55632eba93..543bff66ec 100644 --- a/ver/ique/symbol_addrs.txt +++ b/ver/ique/symbol_addrs.txt @@ -32,8 +32,6 @@ theater_floor_pal = 0x800744f0; theater_floor_png = 0x800743f0; ui_no_controller_png = 0x80074db0; __osBbHackFlags = 0x8000038C; -__osMaxControllers = 0x800991d2; -__divdi3 = 0x8006ce10; __osBbPakAddress = 0x80000374; osRomBase = 0x80000308; osTvType = 0x80000300; @@ -69,12 +67,9 @@ get_clamped_angle_diff = 0x800298f8; get_npc_by_index = 0x8003818c; nuBoot = 0x8005df60; title_screen_draw_copyright = 0x800374c4; -decode_yay0 = 0x8006e380; -lldiv = 0x8006cc9c; osViModeTable = 0x800932c0; osViModeNtscLan1 = 0x80094440; osViModeMpalLan1 = 0x80094490; -osUnmapTLB = 0x80064ee0; nuAuTaskStop = 0x80076de0; AlFrameSize = 0x800a0044; AlCmdListBuffers = 0x8009ff20; @@ -208,7 +203,6 @@ __osSetTimerIntr = 0x80064ad4; __osInsertTimer = 0x80064ba8; osMapTLB = 0x80064d60; __osProbeTLB = 0x80064e20; -osUnmapTLB = 0x80064ee0; osUnmapTLBAll = 0x80064f20; osViGetCurrentFramebuffer = 0x80064f70; osViGetNextFramebuffer = 0x80064fb0; @@ -404,7 +398,6 @@ __osCurrentHandle = 0x80094540; __osSiAccessQueue = 0x800d9008; // size:0x18 siAccessBuf = 0x800ad300; -__osSiAccessQueue = 0x800d9008; // size:0x18 __Dom1SpeedParam + 0x4 = 0x800b2f6c; __Dom1SpeedParam + 0x5 = 0x800b2f6d; __Dom1SpeedParam + 0x6 = 0x800B2F6E; @@ -430,7 +423,6 @@ __osEventStateTab = 0x800d825c; // size:0x110 __osThreadSave = 0x800AF740; gMainGfxPos = 0x80099244; -piEventQueue = 0x800af6e0; // size:24 __osFinalrom = 0x80099238; pause_banner_hp_png = 0x8026c640; // segment:pause @@ -445,8 +437,6 @@ pause_banner_hammer_png = 0x8026d5c0; // segment:pause pause_banner_hammer_pal = 0x8026d740; // segment:pause pause_banner_star_energy_png = 0x8026d940; // segment:pause pause_banner_star_energy_pal = 0x8026dac0; // segment:pause -pause_available_png = 0x8026dcc0; // segment:pause -pause_available_pal = 0x8026dec0; // segment:pause pause_arrows_png = 0x8026c440; // segment:pause pause_stats_bar_png = 0x8026e740; // segment:pause pause_stats_bar_pal = 0x8026e9c0; // segment:pause @@ -520,7 +510,6 @@ filemenu_draw_message = 0x80249d08; // segment:filemenu filemenu_draw_char = 0x802493a0; // segment:filemenu filemenu_get_menu_message = 0x80249e68; // segment:filemenu filemenu_hudElemIDs = 0x8024c470; // segment:filemenu -filemenu_get_menu_message = 0x80249e68; // segment:filemenu filemenu_menus = 0x80249f64; // segment:filemenu filemenu_specialSymbols = 0x8024bb30; // segment:filemenu filemenu_draw_rect = 0x80242ba0; // segment:filemenu @@ -568,8 +557,6 @@ MsgCharImgSubtitle = 0x802f39d0; sfx_play_sound_with_params = 0x80148248; heap_malloc = 0x8002a9b4; D_80159180 = 0x8015b500; -MsgCharImgTitle = 0x802ed970; -MsgCharImgSubtitle = 0x802f39d0; charset_postcard_png = 0x00054fa8; charset_postcard_pal + 5 = 0x00056e70; D_80159B50 = 0x8015bed0; @@ -593,12 +580,10 @@ gHudElementCacheBuffer = 0x8014faa4; gHudElementCacheSize = 0x8014facc; gHudElementCacheTablePalette = 0x8014fa60; gGameStatusPtr = 0x80072e0c; -gEncounterState = 0x800991cc; imgfx_appendGfx_component = 0x80139700; get_msg_properties = 0x801242f8; appendGfx_message = 0x80126140; msg_draw_char = 0x8012a75c; -D_8014AD24 = 0x8014ad24; D_801544A0 = 0x801544a0; D_8013A520 = 0x8013a520; D_8014AD24 = 0x8014ad24; @@ -617,7 +602,6 @@ ui_msg_sign_side_right_png = 0x802ecab0; ui_msg_sign_side_left_png = 0x802ec970; ui_msg_sign_side_top_png = 0x802ec870; ui_msg_sign_corner_topright_png = 0x802ec670; -D_80151338 = 0x8014fac8; gMsgGlobalWaveCounter = 0x8014fa74; D_8014C500 = 0x8014ac90; spr_get_npc_raster_info = 0x802de9d8; diff --git a/ver/jp/splat-shift.yaml b/ver/jp/splat-shift.yaml index bdc2c9fec4..0930dd2c19 100644 --- a/ver/jp/splat-shift.yaml +++ b/ver/jp/splat-shift.yaml @@ -1,2 +1,2 @@ options: - ld_use_follows: True + ld_use_symbolic_vram_addresses: True diff --git a/ver/jp/splat.yaml b/ver/jp/splat.yaml index 942d2659a8..ab0cd0d73e 100644 --- a/ver/jp/splat.yaml +++ b/ver/jp/splat.yaml @@ -26,6 +26,7 @@ options: undefined_syms_auto_path: ver/jp/undefined_syms_auto.txt symbol_name_format: JP_$VRAM symbol_name_format_no_rom: JP_$VRAM_$SEG + ld_legacy_generation: True asset_stack: - jp segments: @@ -440,7 +441,6 @@ segments: type: code start: 0x75990 vram: 0x800dc4e0 - # vram_of_symbol: overlays_start # TODO once this symbol is implemented subsegments: - [auto, hasm, bss2] - [auto, c, npc_collision] @@ -469,16 +469,16 @@ segments: - [auto, .rodata, inventory] - [auto, .rodata, world/partners] - [auto, .rodata, 891b0_len_fb0] - - [0xA5910, bin] - - [0xa5f90] + - [0xA5910, bin, A5910] + - [0xA5F90] - name: engine4 dir: engine4 type: code - start: 0xa5f90 + start: 0xA5F90 vram: 0x8010f890 subsegments: - - [0xa5f90, bin] + - [0xA5F90, bin] - [0xa9770] - name: engine2 diff --git a/ver/pal/splat-shift.yaml b/ver/pal/splat-shift.yaml index bdc2c9fec4..0930dd2c19 100644 --- a/ver/pal/splat-shift.yaml +++ b/ver/pal/splat-shift.yaml @@ -1,2 +1,2 @@ options: - ld_use_follows: True + ld_use_symbolic_vram_addresses: True diff --git a/ver/pal/splat.yaml b/ver/pal/splat.yaml index f2e425e65e..4c659d4f37 100644 --- a/ver/pal/splat.yaml +++ b/ver/pal/splat.yaml @@ -38,7 +38,6 @@ segments: type: code start: 0x71D80 vram: 0x800D8C70 - # vram_of_symbol: overlays_start # TODO once this symbol is implemented subsegments: - [auto, hasm, bss2] - [auto, c, npc_collision] @@ -549,7 +548,6 @@ segments: type: code start: 0xA4520 vram: 0x8010E1D0 - follows_vram: engine1 subsegments: - [auto, hasm, bss3] - [auto, c, entity] @@ -608,7 +606,6 @@ segments: dir: evt start: 0xE61D0 vram: 0x802C6000 - # follows_vram: world_use_item # TODO this causes the vram to be wrong subsegments: - [auto, c, script_list] - [auto, c, evt] @@ -629,7 +626,6 @@ segments: type: code start: 0x100910 vram: 0x802E2020 - follows_vram: evt subsegments: - [auto, c, sprite] - [auto, c, 101b90_len_8f0] @@ -637,7 +633,6 @@ segments: type: code start: 0x1040F0 vram: 0x802E7070 - follows_vram: engine4 subsegments: - [auto, c, entity/Shadow] - [auto, c, entity/SaveBlock] @@ -754,7 +749,7 @@ segments: - [0x132C28, palette, letter_content_12] - [0x132E28, bin] # length 0x18, non zero - - name: ui_images + - name: ui_images_filemenu_pause type: code start: 0x132E40 vram: 0x8023E000 @@ -12188,7 +12183,6 @@ segments: start: 0xE8DEC0 name: speech_bubble vram: 0x802B7000 - # vram_of_symbol: world_action_vram_end subsegments: - [auto, c, speech_bubble] - start: 0xE8E5D0 @@ -12204,7 +12198,6 @@ segments: start: 0xE8E880 name: pulse_stone vram: 0x802B7000 - # vram_of_symbol: world_action_vram_end subsegments: - [auto, c, pulse_stone] - start: 0xE8EEC0 @@ -12221,7 +12214,6 @@ segments: start: 0xE8F5C0 name: i_spy vram: 0x802B7000 - # vram_of_symbol: world_action_vram_end subsegments: - [auto, c, i_spy] - start: 0xE8FB40 @@ -12240,7 +12232,6 @@ segments: name: model_clear_render_tasks start: 0xE90270 vram: 0x802B7E00 -# vram_of_symbol: world_misc_vram_end subsegments: - [auto, c, model_clear_render_tasks] - type: code @@ -12248,7 +12239,6 @@ segments: dir: world/action start: 0xE90270 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, idle] - type: code @@ -12256,7 +12246,6 @@ segments: dir: world/action start: 0xE906F0 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, walk] - type: code @@ -12264,7 +12253,6 @@ segments: dir: world/action start: 0xE91050 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, jump] - type: code @@ -12272,7 +12260,6 @@ segments: dir: world/action start: 0xE915E0 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, step_up] - type: code @@ -12280,7 +12267,6 @@ segments: dir: world/action start: 0xE91930 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, land] - type: code @@ -12288,7 +12274,6 @@ segments: dir: world/action start: 0xE91EE0 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, hammer] - type: code @@ -12296,7 +12281,6 @@ segments: dir: world/action start: 0xE92D70 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, spin] - type: code @@ -12304,7 +12288,6 @@ segments: dir: world/action start: 0xE93720 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, tornado_jump] - type: code @@ -12312,7 +12295,6 @@ segments: dir: world/action start: 0xE93DF0 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, spin_jump] - type: code @@ -12320,7 +12302,6 @@ segments: dir: world/action start: 0xE94520 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, slide] - type: code @@ -12328,7 +12309,6 @@ segments: dir: world/action start: 0xE94CA0 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, hit_fire] - type: code @@ -12336,7 +12316,6 @@ segments: dir: world/action start: 0xE94F50 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, hit_lava] - type: code @@ -12344,7 +12323,6 @@ segments: dir: world/action start: 0xE95800 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, knockback] - type: code @@ -12352,7 +12330,6 @@ segments: dir: world/action start: 0xE95A40 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, misc] - type: code @@ -12360,7 +12337,6 @@ segments: dir: world/action start: 0xE961B0 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, use_munchlesia] - type: code @@ -12368,7 +12344,6 @@ segments: dir: world/action start: 0xE96480 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, use_spinning_flower] - type: code @@ -12376,7 +12351,6 @@ segments: dir: world/action start: 0xE97350 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, use_tweester] - type: code @@ -12384,14 +12358,12 @@ segments: dir: world/action start: 0xE976C0 vram: 0x802B6000 -# follows_vram: texture_memory subsegments: - [auto, c, sneaky_parasol] - type: code dir: entity/default start: 0xE98540 vram: 0x802BAE00 -# follows_vram: model_clear_render_tasks subsegments: - [auto, c, Padlock] - [auto, c, BoardedFloor] @@ -12400,7 +12372,6 @@ segments: dir: entity/jan_iwa start: 0xE9A740 vram: 0x802BAE00 -# follows_vram: model_clear_render_tasks subsegments: - [auto, c, Plants1] - [auto, c, Plants2] @@ -12409,7 +12380,6 @@ segments: dir: entity/sbk_omo start: 0xE9C760 vram: 0x802BAE00 -# follows_vram: model_clear_render_tasks subsegments: - [auto, c, Tweester] - [auto, c, StarBoxLauncher] diff --git a/ver/pal/symbol_addrs.txt b/ver/pal/symbol_addrs.txt index 75ebb123a6..e9b6d4e50c 100644 --- a/ver/pal/symbol_addrs.txt +++ b/ver/pal/symbol_addrs.txt @@ -2173,7 +2173,6 @@ pra_31_unk_08_mtx = 0x802479C0; // rom:0xDF2710 pra_31_unk_06_mtx = 0x80247A00; // rom:0xDF2750 pra_31_unk_04_mtx = 0x80247A40; // rom:0xDF2790 pra_31_unk_02_mtx = 0x80247A80; // rom:0xDF27D0 -pra_31_stairs_vtx = 0x80247AC0; // rom:0xDF2810 pra_31_stairs_vtx = 0x80247AC0; // rom:0xDF2810 size:0x1D0 mgm_01_panel_1_coin_img = 0x80242D20; // rom:0xE81EB0 mgm_01_panel_1_coin_pal = 0x80242F20; // rom:0xE820B0 diff --git a/ver/us/splat-shift.yaml b/ver/us/splat-shift.yaml index bdc2c9fec4..0930dd2c19 100644 --- a/ver/us/splat-shift.yaml +++ b/ver/us/splat-shift.yaml @@ -1,2 +1,2 @@ options: - ld_use_follows: True + ld_use_symbolic_vram_addresses: True diff --git a/ver/us/splat.yaml b/ver/us/splat.yaml index 66c2670fd4..5fe1da007a 100644 --- a/ver/us/splat.yaml +++ b/ver/us/splat.yaml @@ -25,13 +25,56 @@ options: undefined_funcs_auto_path: ver/us/undefined_funcs_auto.txt undefined_syms_auto_path: ver/us/undefined_syms_auto.txt ld_wildcard_sections: True - ld_use_follows: False + ld_use_symbolic_vram_addresses: False +vram_classes: + # Main + - { name: main, vram: 0x80025C00 } + - { name: engine1, vram: 0x800DC500, vram_symbol: overlays_start } # follows_classes: [main] (hard-coded in undefined_syms since BG data / map data doesn't shift currently) + - { name: engine2, vram: 0x8010F6D0, vram_symbol: engine1_VRAM_END } + - { name: heaps, vram: 0x80197000, vram_symbol: engine2_VRAM_END } + + # Battle + - { name: battle_area, vram: 0x80218000, vram_symbol: heaps_VRAM_END } + - { name: battle_area2, vram: 0x80231000, vram_symbol: Vine1Base } # ??? + - { name: battle_partner, vram: 0x80238000, follows_classes: [battle_area] } + - { name: battle_code, vram: 0x8023E000, follows_classes: [battle_partner] } + - { name: battle_move, vram: 0x802A1000, follows_classes: [battle_code] } + - { name: action_cmd, vram: 0x802A9000, follows_classes: [battle_move] } + + # File menu / Pause menu + # seems wrong, but this follows the battle partner overlay as the battle_code class does + - { name: ui_images_filemenu_pause, vram: 0x8023E000, vram_symbol: battle_code_CLASS_VRAM } # follows_classes: [battle_partner] } + - { name: filemenu_pause, vram: 0x80242BA0, vram_symbol: ui_images_filemenu_pause_VRAM_END } + + # World + - { name: world_model_anim, vram: 0x80234000, vram_symbol: Vine0Base } # ??? + - { name: map, vram: 0x80240000, follows_classes: [world_model_anim] } + - { name: heaps2, vram: 0x80267FF0, follows_classes: [map] } + - { name: world_script_api, vram: 0x80280000, follows_classes: [heaps2] } + + # Totally linear past this point + - { name: texture_memory, vram: 0x8028E000, follows_classes: [battle_code, world_script_api] } + - { name: world_action, vram: 0x802B6000, follows_classes: [texture_memory] } + - { name: indicator_icon, vram: 0x802B7000, vram_symbol: world_action_vram_end } # follows_classes: [world_action] } + - { name: model_clear_render_tasks, vram: 0x802B7E00, follows_classes: [indicator_icon] } + - { name: area_entities, vram: 0x802BAE00, vram_symbol: model_clear_render_tasks_VRAM_END } + - { name: world_partner, vram: 0x802BD100, vram_symbol: entity_data_vram_end } # follows_classes: [area_entities] } + - { name: world_use_item, vram: 0x802C0000, follows_classes: [world_partner] } + - { name: evt, vram: 0x802C3000, vram_symbol: world_use_item_VRAM_END } + - { name: engine4, vram: 0x802DBD40, vram_symbol: evt_VRAM_END } + - { name: entity, vram: 0x802E0D90, vram_symbol: engine4_VRAM_END } + - { name: font_width, vram: 0x802EB3D0, vram_symbol: entity_VRAM_END } + - { name: heaps3, vram: 0x802FB800, vram_symbol: font_width_VRAM_END } + + # Segments / misc + - [effect_gfx, 0x09000000] + - [entity_model, 0x0A000000] + - [entity_model_anim, 0x00000000] + - { name: dgb_01_smash_bridges, vram: 0x80200000, vram_symbol: D_80200000 } asset_stack: - us segments: - - name: header - type: header - start: 0x0 + - { name: header, type: header, start: 0x0000 } - name: boot type: code start: 0x0040 @@ -42,7 +85,7 @@ segments: - name: main type: code start: 0x1000 - vram: 0x80025C00 + vram_class: main subsegments: - [auto, hasm, bss] - [auto, hasm, entry_point] @@ -387,9 +430,7 @@ segments: - name: engine1 type: code start: 0x759B0 - vram: 0x800DC500 - vram_of_symbol: overlays_start - #follows_vram: main + vram_class: engine1 subsegments: - [auto, hasm, bss2] - [auto, c, npc_collision] @@ -828,8 +869,7 @@ segments: - name: engine2 type: code start: 0xA5DD0 - vram: 0x8010F6D0 - follows_vram: engine1 + vram_class: engine2 subsegments: - [auto, hasm, bss3] - [auto, c, entity] @@ -886,17 +926,15 @@ segments: - name: heaps type: code start: 0xE79B0 - vram: 0x80197000 + vram_class: heaps subalign: 0x1000 - follows_vram: engine2 subsegments: - [auto, c, heaps] - name: evt type: code dir: evt start: 0xE79B0 - vram: 0x802C3000 - follows_vram: world_use_item + vram_class: evt subsegments: - [auto, c, script_list] - [auto, c, evt] @@ -915,16 +953,14 @@ segments: - name: engine4 type: code start: 0xFEE30 - vram: 0x802DBD40 - follows_vram: evt + vram_class: engine4 subsegments: - [auto, c, sprite] - [auto, c, 101b90_len_8f0] - name: entity type: code start: 0x102610 - vram: 0x802E0D90 - follows_vram: engine4 + vram_class: entity subsegments: - [auto, c, entity/Shadow] - [auto, c, entity/SaveBlock] @@ -969,9 +1005,8 @@ segments: - [0x10C880] - type: code name: font_width - follows_vram: entity start: 0x10CC10 - vram: 0x802EB3D0 + vram_class: font_width subsegments: - [auto, c, msg_data] - [auto, c, msg_img] @@ -1055,8 +1090,7 @@ segments: - type: code name: heaps3 start: 0x10F1B0 - vram: 0x802FB800 - follows_vram: font_width + vram_class: heaps3 subsegments: - [auto, c, heaps3] - type: group @@ -1130,11 +1164,10 @@ segments: - [0x131128, linker_offset, letter_content_12_pal] - [0x131128, palette, letter_content_12] - [0x131328, bin] # length 0x18, non zero - - name: ui_images + - name: ui_images_filemenu_pause type: code start: 0x131340 - vram: 0x8023E000 - vram_of_symbol: battle_code_vram_start + vram_class: ui_images_filemenu_pause subsegments: - [auto, ci4, ui/pause/unused_badge_points, 24, 24] - [auto, palette, ui/pause/unused_badge_points] @@ -1290,8 +1323,7 @@ segments: - type: code dir: pause start: 0x135EE0 - vram: 0x80242BA0 - follows_vram: ui_images + vram_class: filemenu_pause subsegments: - [auto, c, pause_main] - [auto, c, pause_tabs] @@ -1349,8 +1381,7 @@ segments: - type: code dir: filemenu start: 0x163400 - vram: 0x80242BA0 - follows_vram: ui_images + vram_class: filemenu_pause subsegments: - [auto, c, filemenu_common] - [auto, c, filemenu_main] @@ -1377,8 +1408,7 @@ segments: - type: code start: 0x16C8E0 name: battle_code - vram: 0x8023E000 - vram_of_symbol: battle_code_vram_start + vram_class: battle_code subsegments: - [auto, c, battle/16C8E0] - [auto, c, battle/btl_states_actions] @@ -1669,95 +1699,83 @@ segments: dir: world/partner name: world_partner_goombario start: 0x317020 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, goombario] - type: code dir: world/partner name: world_partner_bombette start: 0x317E50 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, bombette] - type: code dir: world/partner name: world_partner_parakarry start: 0x319670 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, parakarry] - type: code dir: world/partner name: world_partner_kooper start: 0x31B120 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, kooper] - type: code dir: world/partner name: world_partner_watt start: 0x31CC70 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, watt] - type: code dir: world/partner name: world_partner_sushie start: 0x31DE70 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, sushie] - type: code dir: world/partner name: world_partner_lakilester start: 0x320C50 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, lakilester] - type: code dir: world/partner name: world_partner_bow start: 0x323A50 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, bow] - type: code dir: world/partner name: world_partner_goompa start: 0x324A10 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, goompa] - type: code dir: world/partner name: world_partner_goombaria start: 0x324F10 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, goombaria] - type: code dir: world/partner name: world_partner_twink start: 0x325070 - vram: 0x802BD100 - vram_of_symbol: entity_data_vram_end + vram_class: world_partner subsegments: - [auto, c, twink] - type: code start: 0x3251D0 name: world_use_item - vram: 0x802C0000 - vram_of_symbol: world_partner_vram_end + vram_class: world_use_item subsegments: - [auto, c, world_use_item] @@ -1775,7 +1793,7 @@ segments: dir: effects/gfx type: code start: 0x326410 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, big_smoke_puff] @@ -1825,7 +1843,7 @@ segments: dir: effects/gfx type: code start: 0x328EA0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, landing_dust] @@ -1885,7 +1903,7 @@ segments: dir: effects/gfx type: code start: 0x32CEC0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, flower_splash_trail] @@ -1930,7 +1948,7 @@ segments: dir: effects/gfx type: code start: 0x32EC50 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, cloud_puff_trail] @@ -1962,7 +1980,7 @@ segments: dir: effects/gfx type: code start: 0x32FB50 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, footprint] @@ -1985,7 +2003,7 @@ segments: dir: effects/gfx type: code start: 0x330460 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, floating_flower] @@ -2012,7 +2030,7 @@ segments: dir: effects/gfx type: code start: 0x330F00 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, snowflake] @@ -2039,7 +2057,7 @@ segments: dir: effects/gfx type: code start: 0x3326A0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, star] @@ -2068,7 +2086,7 @@ segments: dir: effects/gfx type: code start: 0x334C70 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, emote] @@ -2108,7 +2126,7 @@ segments: dir: effects/gfx type: code start: 0x337FC0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, sparkles] @@ -2146,7 +2164,7 @@ segments: dir: effects/gfx type: code start: 0x339F60 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, shape_spell] @@ -2176,7 +2194,7 @@ segments: dir: effects/gfx type: code start: 0x33BBD0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, gather_energy_pink] @@ -2205,7 +2223,7 @@ segments: dir: effects/gfx type: code start: 0x33D610 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, drop_leaves] @@ -2233,7 +2251,7 @@ segments: dir: effects/gfx type: code start: 0x33F000 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, dust] @@ -2263,7 +2281,7 @@ segments: dir: effects/gfx type: code start: 0x340880 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, shattering_stones] @@ -2310,7 +2328,7 @@ segments: dir: effects/gfx type: code start: 0x343040 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, damage_stars] @@ -2338,7 +2356,7 @@ segments: dir: effects/gfx type: code start: 0x343F70 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, explosion] @@ -2369,7 +2387,7 @@ segments: dir: effects/gfx type: code start: 0x3451E0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, lens_flare] @@ -2392,7 +2410,7 @@ segments: dir: effects/gfx type: code start: 0x345B40 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, got_item_outline] @@ -2426,7 +2444,7 @@ segments: dir: effects/gfx type: code start: 0x34E770 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, spiky_white_aura] @@ -2457,7 +2475,7 @@ segments: dir: effects/gfx type: code start: 0x350220 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, damage_indicator] @@ -2520,7 +2538,7 @@ segments: dir: effects/gfx type: code start: 0x352CE0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, purple_ring] @@ -2547,7 +2565,7 @@ segments: dir: effects/gfx type: code start: 0x353BB0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, flame] @@ -2589,7 +2607,7 @@ segments: dir: effects/gfx type: code start: 0x356530 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, rising_bubble] @@ -2620,7 +2638,7 @@ segments: dir: effects/gfx type: code start: 0x3573A0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, ring_blast] @@ -2644,7 +2662,7 @@ segments: dir: effects/gfx type: code start: 0x3593B0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, shockwave] @@ -2671,7 +2689,7 @@ segments: dir: effects/gfx type: code start: 0x35A5E0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, music_note] @@ -2720,7 +2738,7 @@ segments: dir: effects/gfx type: code start: 0x35C550 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, sweat] @@ -2747,7 +2765,7 @@ segments: dir: effects/gfx type: code start: 0x35D510 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, sleep_bubble] @@ -2780,7 +2798,7 @@ segments: dir: effects/gfx type: code start: 0x35F0E0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, falling_leaves] @@ -2804,7 +2822,7 @@ segments: dir: effects/gfx type: code start: 0x360A30 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, stars_spread] @@ -2827,7 +2845,7 @@ segments: dir: effects/gfx type: code start: 0x361670 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, steam_burst] @@ -2850,7 +2868,7 @@ segments: dir: effects/gfx type: code start: 0x362C50 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, stars_orbiting] @@ -2873,7 +2891,7 @@ segments: dir: effects/gfx type: code start: 0x3638C0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, big_snowflakes] @@ -2900,7 +2918,7 @@ segments: dir: effects/gfx type: code start: 0x364C00 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, debuff] @@ -2924,7 +2942,7 @@ segments: dir: effects/gfx type: code start: 0x3659B0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, green_impact] @@ -2948,7 +2966,7 @@ segments: dir: effects/gfx type: code start: 0x366D60 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, radial_shimmer] @@ -2989,7 +3007,7 @@ segments: dir: effects/gfx type: code start: 0x36AEE0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, ending_decals] @@ -3023,7 +3041,7 @@ segments: dir: effects/gfx type: code start: 0x36DF90 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, light_rays] @@ -3049,7 +3067,7 @@ segments: dir: effects/gfx type: code start: 0x36ED60 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, lightning] @@ -3107,7 +3125,7 @@ segments: dir: effects/gfx type: code start: 0x3733E0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, fire_breath] @@ -3144,7 +3162,7 @@ segments: dir: effects/gfx type: code start: 0x375510 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, energy_shockwave] @@ -3177,7 +3195,7 @@ segments: dir: effects/gfx type: code start: 0x377F80 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, aura] @@ -3220,7 +3238,7 @@ segments: dir: effects/gfx type: code start: 0x37ADD0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, bulb_glow] @@ -3248,7 +3266,7 @@ segments: dir: effects/gfx type: code start: 0x37D180 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, effect_3D] @@ -3272,7 +3290,7 @@ segments: dir: effects/gfx type: code start: 0x37D9D0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, blast] @@ -3323,7 +3341,7 @@ segments: dir: effects/gfx type: code start: 0x3803A0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, fire_flower] @@ -3360,7 +3378,7 @@ segments: dir: effects/gfx type: code start: 0x381E00 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, recover] @@ -3426,7 +3444,7 @@ segments: dir: effects/gfx type: code start: 0x3863B0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, disable_x] @@ -3488,7 +3506,7 @@ segments: dir: effects/gfx type: code start: 0x38A350 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, firework] @@ -3519,7 +3537,7 @@ segments: dir: effects/gfx type: code start: 0x38BBA0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, confetti] @@ -3547,7 +3565,7 @@ segments: dir: effects/gfx type: code start: 0x38D070 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, snowfall] @@ -3576,7 +3594,7 @@ segments: dir: effects/gfx type: code start: 0x38E990 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, effect_46] @@ -3599,7 +3617,7 @@ segments: dir: effects/gfx type: code start: 0x38F710 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, gather_magic] @@ -3625,7 +3643,7 @@ segments: dir: effects/gfx type: code start: 0x3903D0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, attack_result_text] @@ -3668,7 +3686,7 @@ segments: dir: effects/gfx type: code start: 0x392440 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, small_gold_sparkle] @@ -3700,7 +3718,7 @@ segments: dir: effects/gfx type: code start: 0x3930A0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, flashing_box_shockwave] @@ -3733,7 +3751,7 @@ segments: dir: effects/gfx type: code start: 0x394670 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, balloon] @@ -3769,7 +3787,7 @@ segments: dir: effects/gfx type: code start: 0x3960F0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, floating_rock] @@ -3796,7 +3814,7 @@ segments: dir: effects/gfx type: code start: 0x397040 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, chomp_drop] @@ -3821,7 +3839,7 @@ segments: dir: effects/gfx type: code start: 0x398BC0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, quizmo_stage] @@ -3917,7 +3935,7 @@ segments: dir: effects/gfx type: code start: 0x3A0D60 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, radiating_energy_orb] @@ -3950,7 +3968,7 @@ segments: dir: effects/gfx type: code start: 0x3A2440 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, quizmo_answer] @@ -3973,7 +3991,7 @@ segments: dir: effects/gfx type: code start: 0x3A33D0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, motion_blur_flame] @@ -3998,7 +4016,7 @@ segments: dir: effects/gfx type: code start: 0x3A4320 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, energy_orb_wave] @@ -4026,7 +4044,7 @@ segments: dir: effects/gfx type: code start: 0x3A5BE0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, merlin_house_stars] @@ -4056,7 +4074,7 @@ segments: dir: effects/gfx type: code start: 0x3A77A0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, quizmo_audience] @@ -4116,7 +4134,7 @@ segments: dir: effects/gfx type: code start: 0x3AB030 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, butterflies] @@ -4172,7 +4190,7 @@ segments: dir: effects/gfx type: code start: 0x3AF700 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, stat_change] @@ -4229,7 +4247,7 @@ segments: dir: effects/gfx type: code start: 0x3B2D90 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, snaking_static] @@ -4253,7 +4271,7 @@ segments: dir: effects/gfx type: code start: 0x3B46A0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, thunderbolt_ring] @@ -4275,7 +4293,7 @@ segments: dir: effects/gfx type: code start: 0x3B5340 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, squirt] @@ -4300,7 +4318,7 @@ segments: dir: effects/gfx type: code start: 0x3B6BF0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, water_block] @@ -4329,7 +4347,7 @@ segments: dir: effects/gfx type: code start: 0x3B78D0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, waterfall] @@ -4351,7 +4369,7 @@ segments: dir: effects/gfx type: code start: 0x3B8860 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, water_fountain] @@ -4377,7 +4395,7 @@ segments: dir: effects/gfx type: code start: 0x3B9A70 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, underwater] @@ -4410,7 +4428,7 @@ segments: dir: effects/gfx type: code start: 0x3BAEA0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, lightning_bolt] @@ -4432,7 +4450,7 @@ segments: dir: effects/gfx type: code start: 0x3BCA90 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, water_splash] @@ -4460,7 +4478,7 @@ segments: dir: effects/gfx type: code start: 0x3BD9A0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, snowman_doll] @@ -4586,7 +4604,7 @@ segments: dir: effects/gfx type: code start: 0x3C1BA0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, fright_jar] @@ -4616,7 +4634,7 @@ segments: dir: effects/gfx type: code start: 0x3CB890 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, stop_watch] @@ -4641,7 +4659,7 @@ segments: dir: effects/gfx type: code start: 0x3CD6E0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, effect_63] @@ -4680,7 +4698,7 @@ segments: dir: effects/gfx type: code start: 0x3CFAF0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, throw_spiny] @@ -4709,7 +4727,7 @@ segments: dir: effects/gfx type: code start: 0x3D11E0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, effect_65] @@ -4731,7 +4749,7 @@ segments: dir: effects/gfx type: code start: 0x3D2580 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, tubba_heart_attack] @@ -4757,7 +4775,7 @@ segments: dir: effects/gfx type: code start: 0x3D3930 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, whirlwind] @@ -4786,7 +4804,7 @@ segments: dir: effects/gfx type: code start: 0x3D4E90 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, floating_cloud_puff] @@ -4810,7 +4828,7 @@ segments: dir: effects/gfx type: code start: 0x3D5F30 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, energy_in_out] @@ -4864,7 +4882,7 @@ segments: dir: effects/gfx type: code start: 0x3D7040 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, tattle_window] @@ -4884,7 +4902,7 @@ segments: dir: effects/gfx type: code start: 0x3D7770 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, shiny_flare] @@ -4907,7 +4925,7 @@ segments: dir: effects/gfx type: code start: 0x3D80C0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, huff_puff_breath] @@ -4935,7 +4953,7 @@ segments: dir: effects/gfx type: code start: 0x3D9100 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, cold_breath] @@ -4968,7 +4986,7 @@ segments: dir: effects/gfx type: code start: 0x3DBF40 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, embers] @@ -4992,7 +5010,7 @@ segments: dir: effects/gfx type: code start: 0x3DCD50 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, hieroglyphs] @@ -5015,7 +5033,7 @@ segments: dir: effects/gfx type: code start: 0x3DEE60 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, misc_particles] @@ -5052,7 +5070,7 @@ segments: dir: effects/gfx type: code start: 0x3E12D0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, static_status] @@ -5077,7 +5095,7 @@ segments: dir: effects/gfx type: code start: 0x3E1CD0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, moving_cloud] @@ -5101,7 +5119,7 @@ segments: dir: effects/gfx type: code start: 0x3E2960 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, effect_75] @@ -5136,7 +5154,7 @@ segments: dir: effects/gfx type: code start: 0x3E5350 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, firework_rocket] @@ -5159,7 +5177,7 @@ segments: dir: effects/gfx type: code start: 0x3E5F30 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, peach_star_beam] @@ -5233,7 +5251,7 @@ segments: dir: effects/gfx type: code start: 0x3EBE60 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, chapter_change] @@ -5287,7 +5305,7 @@ segments: dir: effects/gfx type: code start: 0x3F8CC0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, ice_shard] @@ -5312,7 +5330,7 @@ segments: dir: effects/gfx type: code start: 0x3FA4B0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, spirit_card] @@ -5382,7 +5400,7 @@ segments: dir: effects/gfx type: code start: 0x3FF250 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, lil_oink] @@ -5513,7 +5531,7 @@ segments: dir: effects/gfx type: code start: 0x403BF0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, breaking_junk] @@ -5546,7 +5564,7 @@ segments: dir: effects/gfx type: code start: 0x404F40 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, partner_buff] @@ -5588,7 +5606,7 @@ segments: dir: effects/gfx type: code start: 0x407080 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, quizmo_assistant] @@ -5629,7 +5647,7 @@ segments: dir: effects/gfx type: code start: 0x40A1C0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, ice_pillar] @@ -5663,7 +5681,7 @@ segments: dir: effects/gfx type: code start: 0x40BBA0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, sun] @@ -5704,7 +5722,7 @@ segments: dir: effects/gfx type: code start: 0x40D290 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, star_spirits_energy] @@ -5756,7 +5774,7 @@ segments: dir: effects/gfx type: code start: 0x413FA0 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, star_outline] @@ -5781,7 +5799,7 @@ segments: dir: effects/gfx type: code start: 0x415060 - vram: 0x09000000 + vram_class: effect_gfx symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, effect_86] @@ -5823,46 +5841,40 @@ segments: - type: code start: 0x415D90 name: btl_states_menus - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, battle/btl_states_menus] - type: code start: 0x4219F0 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_jump subsegments: - [auto, c, jump] - type: code start: 0x422000 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_hammer subsegments: - [auto, c, hammer] - type: code start: 0x422AD0 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_flee subsegments: - [auto, c, flee] - type: code start: 0x4233F0 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_break_free subsegments: - [auto, c, break_free] - type: code start: 0x423C70 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_whirlwind subsegments: @@ -5891,88 +5903,77 @@ segments: - [0x425550] - type: code start: 0x425590 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_stop_leech subsegments: - [auto, c, stop_leech] - type: code start: 0x425B50 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_07 subsegments: - [auto, c, "07"] - type: code start: 0x426170 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_dizzy_shell subsegments: - [auto, c, dizzy_shell] - type: code start: 0x4269D0 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_fire_shell subsegments: - [auto, c, fire_shell] - type: code start: 0x4273B0 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_0A subsegments: - [auto, c, 0A] - type: code start: 0x427A70 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_bomb subsegments: - [auto, c, bomb] - type: code start: 0x4282E0 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_body_slam subsegments: - [auto, c, body_slam] - type: code start: 0x428A70 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_air_lift subsegments: - [auto, c, air_lift] - type: code start: 0x429320 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_air_raid subsegments: - [auto, c, air_raid] - type: code start: 0x429D20 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_squirt subsegments: - [auto, c, squirt] - type: code start: 0x42A4F0 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_water_block subsegments: @@ -6001,56 +6002,49 @@ segments: - [0x42C6F0] - type: code start: 0x42C6F0 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_tidal_wave subsegments: - [auto, c, tidal_wave] - type: code start: 0x42CF10 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_power_shock subsegments: - [auto, c, power_shock] - type: code start: 0x42DA10 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_mega_shock subsegments: - [auto, c, mega_shock] - type: code start: 0x42E3A0 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_smack subsegments: - [auto, c, smack] - type: code start: 0x42EE20 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_spiny_surge subsegments: - [auto, c, spiny_surge] - type: code start: 0x42F6E0 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_hurricane subsegments: - [auto, c, hurricane] - type: code start: 0x430020 - vram: 0x802A9000 - vram_of_symbol: battle_move_end + vram_class: action_cmd dir: battle/action_cmd name: action_cmd_spook subsegments: @@ -6062,8 +6056,7 @@ segments: - dir: battle/area/kmr_part_1 type: code start: 0x4309A0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subalign: 4 subsegments: - [auto, c, area] @@ -6078,8 +6071,7 @@ segments: - dir: battle/area/kmr_part_2 type: code start: 0x439A90 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subalign: 4 subsegments: - [auto, c, area] @@ -6097,8 +6089,7 @@ segments: - dir: battle/area/kmr_part_3 type: code start: 0x447440 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subalign: 4 subsegments: - [auto, c, area] @@ -6124,8 +6115,7 @@ segments: - dir: battle/area/mac type: code start: 0x464490 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/chan] - [auto, c, actor/lee] @@ -6138,8 +6128,7 @@ segments: - dir: battle/area/hos type: code start: 0x47F0B0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/goombario_tutor] - [auto, c, actor/ember] @@ -6151,8 +6140,7 @@ segments: - dir: battle/area/nok type: code start: 0x48D1A0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subalign: 4 subsegments: - [auto, c, area] @@ -6170,8 +6158,7 @@ segments: - dir: battle/area/trd_part_1 type: code start: 0x4A10A0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, area] - [auto, c, actor/bullet_bill] @@ -6196,8 +6183,7 @@ segments: - dir: battle/area/trd_part_2 type: code start: 0x4B11F0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subalign: 4 subsegments: - [auto, c, area] @@ -6221,8 +6207,7 @@ segments: - dir: battle/area/trd_part_3 type: code start: 0x4CF1B0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, area] - [auto, c, actor/eldstar] @@ -6230,8 +6215,7 @@ segments: - dir: battle/area/iwa type: code start: 0x4D01F0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subalign: 4 subsegments: - [auto, c, area] @@ -6245,8 +6229,7 @@ segments: - dir: battle/area/sbk type: code start: 0x4DA5E0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subalign: 16 # BSS alignment hack subsegments: - [auto, c, actor/pokey] @@ -6256,8 +6239,7 @@ segments: - dir: battle/area/isk_part_1 type: code start: 0x4E2740 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/pokey_mummy] - [auto, c, actor/swooper] @@ -6281,8 +6263,7 @@ segments: - dir: battle/area/isk_part_2 type: code start: 0x4EF4A0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/chain_chomp] - [auto, c, actor/tutankoopa] @@ -6302,8 +6283,7 @@ segments: - dir: battle/area/mim type: code start: 0x4F7BE0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/forest_fuzzy] - [auto, c, actor/bzzap] @@ -6313,8 +6293,7 @@ segments: - dir: battle/area/arn type: code start: 0x4FEA50 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/hyper_goomba] - [auto, c, actor/hyper_paragoomba] @@ -6331,8 +6310,7 @@ segments: - dir: battle/area/dgb type: code start: 0x50F020 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/clubba] - [auto, c, actor/tubba_blubba] @@ -6345,8 +6323,7 @@ segments: - dir: battle/area/omo type: code start: 0x5125D0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/red_shy_guy] - [auto, c, actor/blue_shy_guy] @@ -6372,8 +6349,7 @@ segments: - dir: battle/area/omo2 type: code start: 0x52B6A0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/general_guy] - [auto, c, actor/toy_tank] @@ -6383,50 +6359,43 @@ segments: - dir: battle/area/omo2_1 type: code start: 0x543570 - vram: 0x80231000 - vram_of_symbol: Vine1Base + vram_class: battle_area2 subsegments: - [auto, c, actor/shy_squad] - dir: battle/area/omo2_2 type: code start: 0x5483E0 - vram: 0x80231000 - vram_of_symbol: Vine1Base + vram_class: battle_area2 subsegments: - [auto, c, actor/stilt_guy] - dir: battle/area/omo2_3 type: code start: 0x54CC70 - vram: 0x80231000 - vram_of_symbol: Vine1Base + vram_class: battle_area2 subsegments: - [auto, c, actor/shy_stack] - dir: battle/area/omo2_4 type: code start: 0x552440 - vram: 0x80231000 - vram_of_symbol: Vine1Base + vram_class: battle_area2 subsegments: - [auto, c, actor/signal_guy] - dir: battle/area/omo2_5 type: code start: 0x552BB0 - vram: 0x80231000 - vram_of_symbol: Vine1Base + vram_class: battle_area2 subsegments: - [auto, c, actor/shy_squad_redux] - dir: battle/area/omo2_6 type: code start: 0x556C90 - vram: 0x80231000 - vram_of_symbol: Vine1Base + vram_class: battle_area2 subsegments: - [auto, c, actor/shy_squad_stub] - dir: battle/area/omo3 type: code start: 0x5573E0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/big_lantern_ghost] - [auto, c, stage/omo_01] @@ -6449,8 +6418,7 @@ segments: - dir: battle/area/kgr type: code start: 0x56E2A0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/fuzzipede] - [auto, c, stage/kgr_01] @@ -6458,8 +6426,7 @@ segments: - dir: battle/area/jan type: code start: 0x573920 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/spear_guy] - [auto, c, actor/hurt_plant] @@ -6479,8 +6446,7 @@ segments: - dir: battle/area/jan2 type: code start: 0x584940 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/putrid_piranha] - [auto, c, actor/white_magikoopa] @@ -6496,8 +6462,7 @@ segments: - dir: battle/area/kzn type: code start: 0x58C2F0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/lava_bubble] - [auto, c, actor/putrid_piranha] @@ -6516,8 +6481,7 @@ segments: - dir: battle/area/kzn2 type: code start: 0x59E6E0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, anim/unused_gfx] @@ -6593,8 +6557,7 @@ segments: - dir: battle/area/flo type: code start: 0x5B14B0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/lakitu] - [auto, c, actor/spiny] @@ -6621,8 +6584,7 @@ segments: - dir: battle/area/flo2 type: code start: 0x5CE690 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/huff_n_puff] - [auto, c, actor/tuff_puff] @@ -6642,8 +6604,7 @@ segments: - dir: battle/area/tik type: code start: 0x5EC490 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/dark_koopa] - [auto, c, actor/dark_paratroopa] @@ -6662,8 +6623,7 @@ segments: - dir: battle/area/tik2 type: code start: 0x608AB0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/blooper] - [auto, c, actor/electro_blooper] @@ -6678,8 +6638,7 @@ segments: - dir: battle/area/tik3 type: code start: 0x6186F0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/swooper] - [auto, c, actor/swoopula] @@ -6692,8 +6651,7 @@ segments: - dir: battle/area/sam type: code start: 0x623BA0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/duplighost] - [auto, c, actor/gulpit] @@ -6711,8 +6669,7 @@ segments: - dir: battle/area/sam2 type: code start: 0x63D1E0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/monstar] - [auto, c, actor/paragoomba] @@ -6752,8 +6709,7 @@ segments: - dir: battle/area/pra type: code start: 0x648E10 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/swoopula] - [auto, c, actor/albino_dino] @@ -6773,8 +6729,7 @@ segments: - dir: battle/area/pra2 type: code start: 0x660750 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subalign: 16 # BSS alignment hack subsegments: - [auto, c, actor/crystal_king] @@ -6784,8 +6739,7 @@ segments: - dir: battle/area/pra3 type: code start: 0x669D80 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/duplighost] - [auto, c, actor/swoopula] @@ -6802,8 +6756,7 @@ segments: - dir: battle/area/kpa type: code start: 0x684A30 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/bony_beetle] - [auto, c, actor/dry_bones] @@ -6829,8 +6782,7 @@ segments: - dir: battle/area/kpa2 type: code start: 0x69F200 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/unused_bowser] - [auto, c, actor/intro_bowser] @@ -6844,8 +6796,7 @@ segments: - dir: battle/area/kpa3 type: code start: 0x6BBB90 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/anti_guy] - [auto, c, actor/duplighost] @@ -6854,8 +6805,7 @@ segments: - dir: battle/area/kpa4 type: code start: 0x6CC070 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/bombshell_blaster] - [auto, c, actor/bombshell_bill] @@ -6879,8 +6829,7 @@ segments: - dir: battle/area/kkj type: code start: 0x6DBDA0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, area] - [auto, c, actor/kammy_koopa] @@ -6888,8 +6837,7 @@ segments: - dir: battle/area/dig type: code start: 0x6DDDC0 - vram: 0x80218000 - follows_vram: heaps + vram_class: battle_area subsegments: - [auto, c, actor/koopa_troopa] - [auto, c, actor/fuzzy] @@ -6918,80 +6866,70 @@ segments: dir: battle/partner type: code start: 0x6F0B30 - vram: 0x80238000 - vram_of_symbol: battle_partner_vram_start + vram_class: battle_partner subsegments: - [auto, c, goompa] - name: battle_partner_goombario dir: battle/partner type: code start: 0x6F10E0 - vram: 0x80238000 - vram_of_symbol: battle_partner_vram_start + vram_class: battle_partner subsegments: - [auto, c, goombario] - name: battle_partner_kooper dir: battle/partner type: code start: 0x6F5E80 - vram: 0x80238000 - vram_of_symbol: battle_partner_vram_start + vram_class: battle_partner subsegments: - [auto, c, kooper] - name: battle_partner_bombette dir: battle/partner type: code start: 0x6FAD10 - vram: 0x80238000 - vram_of_symbol: battle_partner_vram_start + vram_class: battle_partner subsegments: - [auto, c, bombette] - name: battle_partner_parakarry dir: battle/partner type: code start: 0x6FFD80 - vram: 0x80238000 - vram_of_symbol: battle_partner_vram_start + vram_class: battle_partner subsegments: - [auto, c, parakarry] - name: battle_partner_watt dir: battle/partner type: code start: 0x703AF0 - vram: 0x80238000 - vram_of_symbol: battle_partner_vram_start + vram_class: battle_partner subsegments: - [auto, c, watt] - name: battle_partner_sushie dir: battle/partner type: code start: 0x707CA0 - vram: 0x80238000 - vram_of_symbol: battle_partner_vram_start + vram_class: battle_partner subsegments: - [auto, c, sushie] - name: battle_partner_lakilester dir: battle/partner type: code start: 0x70BD10 - vram: 0x80238000 - vram_of_symbol: battle_partner_vram_start + vram_class: battle_partner subsegments: - [auto, c, lakilester] - name: battle_partner_bow dir: battle/partner type: code start: 0x710EF0 - vram: 0x80238000 - vram_of_symbol: battle_partner_vram_start + vram_class: battle_partner subsegments: - [auto, c, bow] - name: battle_partner_twink dir: battle/partner type: code start: 0x714CF0 - vram: 0x80238000 - vram_of_symbol: battle_partner_vram_start + vram_class: battle_partner subsegments: - [auto, c, twink] @@ -7002,24 +6940,21 @@ segments: dir: battle/move/item type: code start: 0x715850 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, mushroom] - name: fire_flower dir: battle/move/item type: code start: 0x716C60 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, fire_flower] - name: dusty_hammer dir: battle/move/item type: code start: 0x7179D0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, dusty_hammer] - start: 0x717C10 @@ -7033,16 +6968,14 @@ segments: dir: battle/move/item type: code start: 0x718850 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, pow_block] - name: pebble dir: battle/move/item type: code start: 0x719970 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, pebble] - start: 0x719BB0 @@ -7056,48 +6989,42 @@ segments: dir: battle/move/item type: code start: 0x71A7F0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, volt_shroom] - name: thunder_rage dir: battle/move/item type: code start: 0x71B1A0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, thunder_rage] - name: snowman_doll dir: battle/move/item type: code start: 0x71BE30 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, snowman_doll] - name: dried_shroom dir: battle/move/item type: code start: 0x71CCE0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, dried_shroom] - name: shooting_star dir: battle/move/item type: code start: 0x71D770 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, shooting_star] - name: sleepy_sheep dir: battle/move/item type: code start: 0x71E650 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, sleepy_sheep] - start: 0x71EFC0 @@ -7116,88 +7043,77 @@ segments: dir: battle/move/item type: code start: 0x7215A0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, stone_cap] - name: tasty_tonic dir: battle/move/item type: code start: 0x722000 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, tasty_tonic] - name: thunder_bolt dir: battle/move/item type: code start: 0x722B40 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, thunder_bolt] - name: ultra_shroom dir: battle/move/item type: code start: 0x723780 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, ultra_shroom] - name: unknown_item dir: battle/move/item type: code start: 0x724240 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, unknown_item] - name: super_soda dir: battle/move/item type: code start: 0x724CE0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, super_soda] - name: hustle_drink dir: battle/move/item type: code start: 0x725F60 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, hustle_drink] - name: stop_watch dir: battle/move/item type: code start: 0x726DD0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, stop_watch] - name: dizzy_dial dir: battle/move/item type: code start: 0x727910 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, dizzy_dial] - name: please_come_back dir: battle/move/item type: code start: 0x7285E0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, please_come_back] - name: egg_missile dir: battle/move/item type: code start: 0x728EC0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, egg_missile] - start: 0x7291D0 @@ -7218,8 +7134,7 @@ segments: dir: battle/move/item type: code start: 0x72A750 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, insecticide_herb] - start: 0x72AB70 @@ -7234,16 +7149,14 @@ segments: dir: battle/move/item type: code start: 0x72B910 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, fright_jar] - name: mystery dir: battle/move/item type: code start: 0x72C5B0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, mystery] - start: 0x72CF00 @@ -7258,24 +7171,21 @@ segments: dir: battle/move/item type: code start: 0x72DB70 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, repel_gel] - name: life_shroom dir: battle/move/item type: code start: 0x72E530 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, life_shroom] - name: coconut dir: battle/move/item type: code start: 0x72F720 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, coconut] - start: 0x72F960 @@ -7290,16 +7200,14 @@ segments: dir: battle/move/item type: code start: 0x7305A0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, electro_pop] - name: strange_cake dir: battle/move/item type: code start: 0x731300 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, strange_cake] - start: 0x731EA0 @@ -7318,8 +7226,7 @@ segments: dir: battle/move/item type: code start: 0x7330D0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, food] @@ -7330,96 +7237,84 @@ segments: dir: battle/move/hammer type: code start: 0x7345A0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, attack] - name: battle_move_spin_smash dir: battle/move/hammer type: code start: 0x737890 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, spin_smash] - name: battle_move_quake_hammer dir: battle/move/hammer type: code start: 0x73AED0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, quake_hammer] - name: battle_move_jump_attack dir: battle/move/jump type: code start: 0x73D860 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, attack] - name: battle_move_multibounce dir: battle/move/jump type: code start: 0x740CC0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, multibounce] - name: battle_move_power_bounce dir: battle/move/jump type: code start: 0x743DF0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, power_bounce] - name: battle_move_sleep_stomp dir: battle/move/jump type: code start: 0x746E10 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, sleep_stomp] - name: battle_move_dizzy_stomp dir: battle/move/jump type: code start: 0x748DD0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, dizzy_stomp] - name: battle_move_d_down_pound dir: battle/move/hammer type: code start: 0x74AD90 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, d_down_pound] - name: battle_move_jump_charge_0 dir: battle/move/jump type: code start: 0x74D570 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, jump_charge_0] - name: battle_move_hammer_charge_0 dir: battle/move/hammer type: code start: 0x74F130 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, hammer_charge_0] - name: battle_move_hammer_throw dir: battle/move/hammer type: code start: 0x752450 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, hammer_throw] - start: 0x752500 @@ -7445,271 +7340,237 @@ segments: dir: battle/move/hammer type: code start: 0x756780 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, mega_quake] - name: battle_move_hammer_charge_1 dir: battle/move/hammer type: code start: 0x7595B0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, hammer_charge_1] - name: battle_move_jump_charge_1 dir: battle/move/jump type: code start: 0x75C980 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, jump_charge_1] - name: battle_move_hammer_charge_2 dir: battle/move/hammer type: code start: 0x75E5D0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, hammer_charge_2] - name: battle_move_jump_charge_2 dir: battle/move/jump type: code start: 0x761920 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, jump_charge_2] - name: battle_move_auto_smash dir: battle/move/hammer type: code start: 0x763540 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, auto_smash] - name: battle_move_auto_jump dir: battle/move/jump type: code start: 0x765C20 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, auto_jump] - name: battle_move_power_quake dir: battle/move/hammer type: code start: 0x767C90 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, power_quake] - name: battle_move_auto_multibounce dir: battle/move/jump type: code start: 0x76A830 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, auto_multibounce] - name: battle_move_power_jump dir: battle/move/jump type: code start: 0x76D760 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, power_jump] - name: battle_move_super_jump dir: battle/move/jump type: code start: 0x76F330 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, super_jump] - name: battle_move_mega_jump dir: battle/move/jump type: code start: 0x770F30 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, mega_jump] - name: battle_move_power_smash dir: battle/move/hammer type: code start: 0x772BA0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, power_smash] - name: battle_move_super_smash dir: battle/move/hammer type: code start: 0x775100 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, super_smash] - name: battle_move_mega_smash dir: battle/move/hammer type: code start: 0x777690 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, mega_smash] - name: battle_move_demo_power_bounce dir: battle/move/jump type: code start: 0x779C90 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, demo_power_bounce] - name: battle_move_shrink_smash dir: battle/move/hammer type: code start: 0x77CB80 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, shrink_smash] - name: battle_move_shell_crack dir: battle/move/hammer type: code start: 0x77F240 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, shell_crack] - name: battle_move_d_down_jump dir: battle/move/jump type: code start: 0x781920 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, d_down_jump] - name: battle_move_shrink_stomp dir: battle/move/jump type: code start: 0x783BA0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, shrink_stomp] - name: battle_move_earthquake_jump dir: battle/move/jump type: code start: 0x785B20 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, earthquake_jump] - name: battle_move_focus dir: battle/move/star_power type: code start: 0x789E60 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, focus] - name: battle_move_refresh dir: battle/move/star_power type: code start: 0x78B600 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, refresh] - name: battle_move_lullaby dir: battle/move/star_power type: code start: 0x78D150 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, lullaby] - name: battle_move_star_storm dir: battle/move/star_power type: code start: 0x78E7D0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, star_storm] - name: battle_move_chill_out dir: battle/move/star_power type: code start: 0x7900D0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, chill_out] - name: battle_move_smooch dir: battle/move/star_power type: code start: 0x791D90 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, smooch] - name: battle_move_time_out dir: battle/move/star_power type: code start: 0x793D20 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, time_out] - name: battle_move_up_and_away dir: battle/move/star_power type: code start: 0x7952E0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, up_and_away] - name: battle_move_star_beam dir: battle/move/star_power type: code start: 0x796FC0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, star_beam] - name: battle_move_peach_beam dir: battle/move/star_power type: code start: 0x7997B0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, peach_beam] - name: battle_move_peach_focus dir: battle/move/star_power type: code start: 0x79BFA0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, peach_focus] - name: battle_move_peach_focus_alt dir: battle/move/star_power type: code start: 0x79D8A0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move subsegments: - [auto, c, peach_focus_alt] - type: code name: level_up start: 0x79EF40 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, level_up] @@ -7843,8 +7704,7 @@ segments: - type: code name: starpoint start: 0x7A89A0 - vram: 0x802A1000 - follows_vram: battle_code + vram_class: battle_move symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, starpoint] @@ -7926,304 +7786,266 @@ segments: dir: world/model_anim/kzn type: code start: 0x7B5960 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "01"] - name: world_model_anim_kzn_00 dir: world/model_anim/kzn type: code start: 0x7B6690 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "00"] - name: world_model_anim_kzn_04 dir: world/model_anim/kzn type: code start: 0x7B70E0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "04"] - name: world_model_anim_kzn_05 dir: world/model_anim/kzn type: code start: 0x7B8030 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "05"] - name: world_model_anim_kzn_06 dir: world/model_anim/kzn type: code start: 0x7B8D30 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "06"] - name: world_model_anim_kzn_07 dir: world/model_anim/kzn type: code start: 0x7B97E0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "07"] - name: world_model_anim_kzn_08 dir: world/model_anim/kzn type: code start: 0x7BA280 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "08"] - name: world_model_anim_kzn_09 dir: world/model_anim/kzn type: code start: 0x7BB050 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "09"] - name: world_model_anim_kzn_0A dir: world/model_anim/kzn type: code start: 0x7BBD80 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "0A"] - name: world_model_anim_kzn_0B dir: world/model_anim/kzn type: code start: 0x7BEDD0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "0B"] - name: world_model_anim_kzn_0C dir: world/model_anim/kzn type: code start: 0x7C16C0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "0C"] - name: world_model_anim_kzn_0D dir: world/model_anim/kzn type: code start: 0x7C3A00 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "0D"] - name: world_model_anim_kzn_0E dir: world/model_anim/kzn type: code start: 0x7C44D0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "0E"] - name: world_model_anim_kzn_02 dir: world/model_anim/kzn type: code start: 0x7C4F50 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "02"] - name: world_model_anim_kzn_03 dir: world/model_anim/kzn type: code start: 0x7C7410 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "03"] - name: world_model_anim_kzn_0F dir: world/model_anim/kzn type: code start: 0x7C7E50 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "0F"] - name: world_model_anim_kzn_10 dir: world/model_anim/kzn type: code start: 0x7CA850 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "10"] - name: world_model_anim_kzn_11 dir: world/model_anim/kzn type: code start: 0x7CD5F0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "11"] - name: world_model_anim_kzn_12 dir: world/model_anim/kzn type: code start: 0x7CDB30 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "12"] - name: world_model_anim_kzn_13 dir: world/model_anim/kzn type: code start: 0x7CEFF0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "13"] - name: world_model_anim_kzn_14 dir: world/model_anim/kzn type: code start: 0x7CFCC0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "14"] - name: world_model_anim_kzn_15 dir: world/model_anim/kzn type: code start: 0x7D0860 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "15"] - name: world_model_anim_kzn_16 dir: world/model_anim/kzn type: code start: 0x7D14E0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "16"] - name: world_model_anim_kzn_17 dir: world/model_anim/kzn type: code start: 0x7D2080 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "17"] - name: world_model_anim_kzn_18 dir: world/model_anim/kzn type: code start: 0x7D2960 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "18"] - name: world_model_anim_kzn_19 dir: world/model_anim/kzn type: code start: 0x7D3260 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "19"] - name: world_model_anim_kzn_1A dir: world/model_anim/kzn type: code start: 0x7D5570 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "1A"] - name: world_model_anim_kzn_1B dir: world/model_anim/kzn type: code start: 0x7D6F80 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "1B"] - name: world_model_anim_kzn_1C dir: world/model_anim/kzn type: code start: 0x7D76B0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "1C"] - name: world_model_anim_kzn_1D dir: world/model_anim/kzn type: code start: 0x7D8FF0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "1D"] - name: world_model_anim_kzn_1E dir: world/model_anim/kzn type: code start: 0x7D96E0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "1E"] - name: world_model_anim_kzn_1F dir: world/model_anim/kzn type: code start: 0x7D98E0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "1F"] - name: world_model_anim_kzn_20 dir: world/model_anim/kzn type: code start: 0x7DA140 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "20"] - name: world_model_anim_kzn_21 dir: world/model_anim/kzn type: code start: 0x7DC180 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "21"] - name: world_model_anim_kzn_22 dir: world/model_anim/kzn type: code start: 0x7DE970 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "22"] - name: world_model_anim_kzn_23 dir: world/model_anim/kzn type: code start: 0x7DF2B0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "23"] - name: world_model_anim_kzn_24 dir: world/model_anim/kzn type: code start: 0x7E03B0 - vram: 0x80234000 - vram_of_symbol: Vine0Base + vram_class: world_model_anim subsegments: - [auto, c, "24"] - name: world_script_api dir: world/script_api type: code start: 0x7E0E80 - vram: 0x80280000 - follows_vram: heaps2 + vram_class: world_script_api subsegments: - [auto, c, shops] - [auto, c, rooms] @@ -8232,21 +8054,19 @@ segments: - name: texture_memory type: code start: 0x7E73A0 - vram: 0x8028E000 - vram_of_symbol: world_battle_vram_end + vram_class: texture_memory subsegments: - [auto, c, texture_memory] ############ -### Maps ### +### maps ### ############ - name: machi dir: world/area_mac/machi type: code start: 0x7E73A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, machi_0_header] - [auto, c, machi_1_tables] @@ -8260,8 +8080,7 @@ segments: dir: world/area_mac/mac_00 type: code start: 0x7EAD10 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mac_00_0_header] - [auto, c, mac_00_1_music] @@ -8282,8 +8101,7 @@ segments: dir: world/area_mac/mac_01 type: code start: 0x800880 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mac_01_0_header] - [auto, c, mac_01_1_music] @@ -8326,8 +8144,7 @@ segments: dir: world/area_mac/mac_02 type: code start: 0x8232C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mac_02_0_header] - [auto, c, mac_02_1_music] @@ -8341,8 +8158,7 @@ segments: dir: world/area_mac/mac_03 type: code start: 0x831800 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mac_03_0_header] - [auto, c, mac_03_1_music] @@ -8357,8 +8173,7 @@ segments: dir: world/area_mac/mac_04 type: code start: 0x842BD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mac_04_0_header] - [auto, c, mac_04_1_music] @@ -8374,8 +8189,7 @@ segments: dir: world/area_mac/mac_05 type: code start: 0x852170 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mac_05_0_header] - [auto, c, mac_05_1_music] @@ -8389,8 +8203,7 @@ segments: dir: world/area_mac/mac_06 type: code start: 0x864B40 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mac_06_0_header] - [auto, c, mac_06_1_main] @@ -8400,8 +8213,7 @@ segments: dir: world/area_tik/tik_01 type: code start: 0x8694B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_01_0_header] - [auto, c, tik_01_1_music] @@ -8413,8 +8225,7 @@ segments: dir: world/area_tik/tik_02 type: code start: 0x86C740 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_02_0_header] - [auto, c, tik_02_1_music] @@ -8426,8 +8237,7 @@ segments: dir: world/area_tik/tik_03 type: code start: 0x86EB00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_03_0_header] - [auto, c, tik_03_1_music] @@ -8440,8 +8250,7 @@ segments: dir: world/area_tik/tik_04 type: code start: 0x871A30 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_04_0_header] - [auto, c, tik_04_1_music] @@ -8453,8 +8262,7 @@ segments: dir: world/area_tik/tik_05 type: code start: 0x874DC0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_05_0_header] - [auto, c, tik_05_1_music] @@ -8466,8 +8274,7 @@ segments: dir: world/area_tik/tik_06 type: code start: 0x876EE0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_06_0_header] - [auto, c, tik_06_1_music] @@ -8478,8 +8285,7 @@ segments: dir: world/area_tik/tik_07 type: code start: 0x879BE0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_07_0_header] - [auto, c, tik_07_1_music] @@ -8492,8 +8298,7 @@ segments: dir: world/area_tik/tik_08 type: code start: 0x87EDF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_08_0_header] - [auto, c, tik_08_1_music] @@ -8505,8 +8310,7 @@ segments: dir: world/area_tik/tik_09 type: code start: 0x8821C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_09_0_header] - [auto, c, tik_09_1_music] @@ -8518,8 +8322,7 @@ segments: dir: world/area_tik/tik_10 type: code start: 0x8863C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_10_0_header] - [auto, c, tik_10_1_music] @@ -8530,8 +8333,7 @@ segments: dir: world/area_tik/tik_12 type: code start: 0x888BD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_12_0_header] - [auto, c, tik_12_1_music] @@ -8543,8 +8345,7 @@ segments: dir: world/area_tik/tik_14 type: code start: 0x88D600 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_14_0_header] - [auto, c, tik_14_1_music] @@ -8555,8 +8356,7 @@ segments: dir: world/area_tik/tik_15 type: code start: 0x88FBA0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_15_0_header] - [auto, c, tik_15_1_music] @@ -8568,8 +8368,7 @@ segments: dir: world/area_tik/tik_17 type: code start: 0x892A20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_17_0_header] - [auto, c, tik_17_1_music] @@ -8579,8 +8378,7 @@ segments: dir: world/area_tik/tik_18 type: code start: 0x8956E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_18_0_header] - [auto, c, tik_18_1_music] @@ -8592,8 +8390,7 @@ segments: dir: world/area_tik/tik_19 type: code start: 0x8975E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_19_0_header] - [auto, c, tik_19_1_music] @@ -8603,8 +8400,7 @@ segments: dir: world/area_tik/tik_20 type: code start: 0x89A350 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_20_0_header] - [auto, c, tik_20_1_music] @@ -8615,8 +8411,7 @@ segments: dir: world/area_tik/tik_21 type: code start: 0x89D7A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_21_0_header] - [auto, c, tik_21_1_music] @@ -8626,8 +8421,7 @@ segments: dir: world/area_tik/tik_22 type: code start: 0x89FEC0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_22_0_header] - [auto, c, tik_22_1_music] @@ -8636,8 +8430,7 @@ segments: dir: world/area_tik/tik_23 type: code start: 0x8A23D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_23_0_header] - [auto, c, tik_23_1_music] @@ -8648,8 +8441,7 @@ segments: dir: world/area_tik/tik_24 type: code start: 0x8A5A80 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_24_0_header] - [auto, c, tik_24_1_music] @@ -8661,8 +8453,7 @@ segments: dir: world/area_tik/tik_25 type: code start: 0x8A7F80 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tik_25_0_header] - [auto, c, tik_25_1_music] @@ -8672,8 +8463,7 @@ segments: dir: world/area_kgr/kgr_01 type: code start: 0x8A9A10 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kgr_01_1_main] - [auto, c, kgr_01_2_wiggle] @@ -8682,8 +8472,7 @@ segments: dir: world/area_kgr/kgr_02 type: code start: 0x8AA450 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kgr_02_1_main] - [auto, c, kgr_02_2_unused] @@ -8693,8 +8482,7 @@ segments: dir: world/area_kmr/kmr_00 type: code start: 0x8ABF90 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_00_0_header] - [auto, c, kmr_00_1_music] @@ -8706,8 +8494,7 @@ segments: dir: world/area_kmr/kmr_02 type: code start: 0x8B0070 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_02_0_header] - [auto, c, kmr_02_1_music] @@ -8739,8 +8526,7 @@ segments: dir: world/area_kmr/kmr_03 type: code start: 0x8C7F90 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_03_0_header] - [auto, c, kmr_03_1_music] @@ -8753,8 +8539,7 @@ segments: dir: world/area_kmr/kmr_04 type: code start: 0x8CA900 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_04_0_header] - [auto, c, kmr_04_1_music] @@ -8778,8 +8563,7 @@ segments: dir: world/area_kmr/kmr_05 type: code start: 0x8CE070 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_05_0_header] - [auto, c, kmr_05_1_music] @@ -8791,8 +8575,7 @@ segments: dir: world/area_kmr/kmr_06 type: code start: 0x8D1510 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_06_0_header] - [auto, c, kmr_06_1_music] @@ -8804,8 +8587,7 @@ segments: dir: world/area_kmr/kmr_07 type: code start: 0x8D3DC0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_07_0_header] - [auto, c, kmr_07_1_music] @@ -8816,8 +8598,7 @@ segments: dir: world/area_kmr/kmr_09 type: code start: 0x8D5E00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_09_0_header] - [auto, c, kmr_09_1_music] @@ -8828,8 +8609,7 @@ segments: dir: world/area_kmr/kmr_10 type: code start: 0x8D84D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_10_0_header] - [auto, c, kmr_10_1_music] @@ -8841,8 +8621,7 @@ segments: dir: world/area_kmr/kmr_11 type: code start: 0x8DA100 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_11_0_header] - [auto, c, kmr_11_1_music] @@ -8860,8 +8639,7 @@ segments: dir: world/area_kmr/kmr_12 type: code start: 0x8EB360 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_12_0_header] - [auto, c, kmr_12_1_music] @@ -8872,8 +8650,7 @@ segments: dir: world/area_kmr/kmr_20 type: code start: 0x8EBE20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_20_0_header] - [auto, c, kmr_20_1_music] @@ -8912,8 +8689,7 @@ segments: dir: world/area_kmr/kmr_21 type: code start: 0x8FEE80 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_21_0_header] - [auto, c, kmr_21_1_main] @@ -8921,8 +8697,7 @@ segments: dir: world/area_kmr/kmr_22 type: code start: 0x8FF670 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_22_0_header] - [auto, c, kmr_22_1_main] @@ -8942,8 +8717,7 @@ segments: dir: world/area_kmr/kmr_23 type: code start: 0x907A30 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_23_0_header] - [auto, c, kmr_23_1_main] @@ -8964,8 +8738,7 @@ segments: dir: world/area_kmr/kmr_24 type: code start: 0x90B240 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_24_0_header] - [auto, c, kmr_24_1_main] @@ -8973,8 +8746,7 @@ segments: dir: world/area_kmr/kmr_30 type: code start: 0x90B6D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kmr_30_0_header] - [auto, c, kmr_30_1_main] @@ -8984,8 +8756,7 @@ segments: dir: world/area_iwa/iwa_00 type: code start: 0x90CC40 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, iwa_00_0_header] - [auto, c, iwa_00_1_main] @@ -8996,8 +8767,7 @@ segments: dir: world/area_iwa/iwa_01 type: code start: 0x90F6B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, iwa_01_0_header] - [auto, c, iwa_01_1_main] @@ -9022,8 +8792,7 @@ segments: dir: world/area_iwa/iwa_02 type: code start: 0x915D70 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, iwa_02_0_header] - [auto, c, iwa_02_1_main] @@ -9033,8 +8802,7 @@ segments: dir: world/area_iwa/iwa_03 type: code start: 0x918BB0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, iwa_03_0_header] - [auto, c, iwa_03_1_main] @@ -9045,8 +8813,7 @@ segments: dir: world/area_iwa/iwa_04 type: code start: 0x91B8E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, iwa_04_0_header] - [auto, c, iwa_04_1_music] @@ -9057,8 +8824,7 @@ segments: dir: world/area_iwa/iwa_10 type: code start: 0x91E570 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, iwa_10_0_header] - [auto, c, iwa_10_1_music] @@ -9073,8 +8839,7 @@ segments: dir: world/area_iwa/iwa_11 type: code start: 0x9269F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, iwa_11_0_header] - [auto, c, iwa_11_1_music] @@ -9086,8 +8851,7 @@ segments: dir: world/area_sbk/sbk_00 type: code start: 0x929270 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_00_0_header] - [auto, c, sbk_00_1_main] @@ -9097,8 +8861,7 @@ segments: dir: world/area_sbk/sbk_01 type: code start: 0x929A90 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_01_1_main] - [auto, c, sbk_01_2_npc] @@ -9106,8 +8869,7 @@ segments: dir: world/area_sbk/sbk_02 type: code start: 0x92A2B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_02_0_header] - [auto, c, sbk_02_1_music] @@ -9119,8 +8881,7 @@ segments: dir: world/area_sbk/sbk_03 type: code start: 0x92F8B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_03_1_main] - [auto, c, sbk_03_2_npc] @@ -9128,8 +8889,7 @@ segments: dir: world/area_sbk/sbk_04 type: code start: 0x9304D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_04_1_main] - [auto, c, sbk_04_2_npc] @@ -9137,8 +8897,7 @@ segments: dir: world/area_sbk/sbk_05 type: code start: 0x930CF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_05_1_main] - [auto, c, sbk_05_2_entity] @@ -9147,8 +8906,7 @@ segments: dir: world/area_sbk/sbk_06 type: code start: 0x9325C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_06_1_main] - [auto, c, sbk_06_2_npc] @@ -9158,8 +8916,7 @@ segments: dir: world/area_sbk/sbk_10 type: code start: 0x933C80 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_10_1_main] - [auto, c, sbk_10_2_entity] @@ -9167,8 +8924,7 @@ segments: dir: world/area_sbk/sbk_11 type: code start: 0x934040 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_11_1_main] - [auto, c, sbk_11_2_npc] @@ -9176,8 +8932,7 @@ segments: dir: world/area_sbk/sbk_12 type: code start: 0x934D40 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_12_1_main] - [auto, c, sbk_12_2_npc] @@ -9185,8 +8940,7 @@ segments: dir: world/area_sbk/sbk_13 type: code start: 0x9357E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_13_1_main] - [auto, c, sbk_13_2_npc] @@ -9194,8 +8948,7 @@ segments: dir: world/area_sbk/sbk_14 type: code start: 0x9366E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_14_1_main] - [auto, c, sbk_14_2_entity] @@ -9203,8 +8956,7 @@ segments: dir: world/area_sbk/sbk_15 type: code start: 0x936CD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_15_1_main] - [auto, c, sbk_15_2_npc] @@ -9212,8 +8964,7 @@ segments: dir: world/area_sbk/sbk_16 type: code start: 0x937570 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_16_1_main] - [auto, c, sbk_16_2_foliage] @@ -9221,8 +8972,7 @@ segments: dir: world/area_sbk/sbk_20 type: code start: 0x938590 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_20_1_main] - [auto, c, sbk_20_2_entity] @@ -9231,16 +8981,14 @@ segments: dir: world/area_sbk/sbk_21 type: code start: 0x939560 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_21_1_main] - name: sbk_22 dir: world/area_sbk/sbk_22 type: code start: 0x939930 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_22_1_main] - [auto, c, sbk_22_2_npc] @@ -9249,8 +8997,7 @@ segments: dir: world/area_sbk/sbk_23 type: code start: 0x93A760 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_23_1_main] - [auto, c, sbk_23_2_entity] @@ -9258,8 +9005,7 @@ segments: dir: world/area_sbk/sbk_24 type: code start: 0x93AC30 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_24_1_main] - [auto, c, sbk_24_2_npc] @@ -9269,8 +9015,7 @@ segments: dir: world/area_sbk/sbk_25 type: code start: 0x93C280 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_25_1_main] - [auto, c, sbk_25_2_npc] @@ -9280,8 +9025,7 @@ segments: dir: world/area_sbk/sbk_26 type: code start: 0x93DCD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_26_1_main] - [auto, c, sbk_26_2_npc] @@ -9290,8 +9034,7 @@ segments: dir: world/area_sbk/sbk_30 type: code start: 0x93F5B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_30_0_header] - [auto, c, sbk_30_1_music] @@ -9302,8 +9045,7 @@ segments: dir: world/area_sbk/sbk_31 type: code start: 0x944000 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_31_1_main] - [auto, c, sbk_31_2_npc] @@ -9311,8 +9053,7 @@ segments: dir: world/area_sbk/sbk_32 type: code start: 0x944A60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_32_1_main] - [auto, c, sbk_32_2_npc] @@ -9320,8 +9061,7 @@ segments: dir: world/area_sbk/sbk_33 type: code start: 0x9459D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: # unusual organization - [auto, c, sbk_33_0_header] - [auto, c, sbk_33_1_entity] @@ -9330,8 +9070,7 @@ segments: dir: world/area_sbk/sbk_34 type: code start: 0x945ED0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_34_1_main] - [auto, c, sbk_34_2_npc] @@ -9340,8 +9079,7 @@ segments: dir: world/area_sbk/sbk_35 type: code start: 0x9486B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_35_1_main] - [auto, c, sbk_35_2_npc] @@ -9350,8 +9088,7 @@ segments: dir: world/area_sbk/sbk_36 type: code start: 0x949E60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_36_1_main] - [auto, c, sbk_36_2_foliage] @@ -9360,8 +9097,7 @@ segments: dir: world/area_sbk/sbk_40 type: code start: 0x94B3A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_40_1_main] - [auto, c, sbk_40_2_npc] @@ -9370,8 +9106,7 @@ segments: dir: world/area_sbk/sbk_41 type: code start: 0x94C040 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_41_1_main] - [auto, c, sbk_41_2_entity] @@ -9379,8 +9114,7 @@ segments: dir: world/area_sbk/sbk_42 type: code start: 0x94C510 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_42_1_main] - [auto, c, sbk_42_2_npc] @@ -9388,8 +9122,7 @@ segments: dir: world/area_sbk/sbk_43 type: code start: 0x94D170 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_43_1_main] - [auto, c, sbk_43_2_entity] @@ -9397,8 +9130,7 @@ segments: dir: world/area_sbk/sbk_44 type: code start: 0x94D5A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_44_1_main] - [auto, c, sbk_44_2_npc] @@ -9406,8 +9138,7 @@ segments: dir: world/area_sbk/sbk_45 type: code start: 0x94E4A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_45_1_main] - [auto, c, sbk_45_2_entity] @@ -9415,8 +9146,7 @@ segments: dir: world/area_sbk/sbk_46 type: code start: 0x94E9A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_46_1_main] - [auto, c, sbk_46_2_npc] @@ -9426,16 +9156,14 @@ segments: dir: world/area_sbk/sbk_50 type: code start: 0x950610 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_50_1_main] - name: sbk_51 dir: world/area_sbk/sbk_51 type: code start: 0x950970 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_51_1_main] - [auto, c, sbk_51_2_npc] @@ -9443,8 +9171,7 @@ segments: dir: world/area_sbk/sbk_52 type: code start: 0x951670 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_52_1_main] - [auto, c, sbk_52_2_entity] @@ -9452,8 +9179,7 @@ segments: dir: world/area_sbk/sbk_53 type: code start: 0x951AE0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_53_1_main] - [auto, c, sbk_53_2_npc] @@ -9461,8 +9187,7 @@ segments: dir: world/area_sbk/sbk_54 type: code start: 0x952580 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_54_1_main] - [auto, c, sbk_54_2_entity] @@ -9470,8 +9195,7 @@ segments: dir: world/area_sbk/sbk_55 type: code start: 0x952A50 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_55_1_main] - [auto, c, sbk_55_2_npc] @@ -9481,8 +9205,7 @@ segments: dir: world/area_sbk/sbk_56 type: code start: 0x953FC0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_56_1_main] - [auto, c, sbk_56_2_entity] @@ -9491,8 +9214,7 @@ segments: dir: world/area_sbk/sbk_60 type: code start: 0x9569F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_60_1_main] - [auto, c, sbk_60_2_npc] @@ -9500,8 +9222,7 @@ segments: dir: world/area_sbk/sbk_61 type: code start: 0x956F90 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_61_1_main] - [auto, c, sbk_61_2_entity] @@ -9509,8 +9230,7 @@ segments: dir: world/area_sbk/sbk_62 type: code start: 0x957350 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_62_1_main] - [auto, c, sbk_62_2_npc] @@ -9518,8 +9238,7 @@ segments: dir: world/area_sbk/sbk_63 type: code start: 0x957D70 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_63_1_main] - [auto, c, sbk_63_2_npc] @@ -9527,8 +9246,7 @@ segments: dir: world/area_sbk/sbk_64 type: code start: 0x958590 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_64_1_main] - [auto, c, sbk_64_2_entity] @@ -9536,16 +9254,14 @@ segments: dir: world/area_sbk/sbk_65 type: code start: 0x958950 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_65_1_main] - name: sbk_66 dir: world/area_sbk/sbk_66 type: code start: 0x958CB0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_66_1_main] - [auto, c, sbk_66_2_npc] @@ -9555,8 +9271,7 @@ segments: dir: world/area_sbk/sbk_99 type: code start: 0x95AEB0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sbk_99_1_main] - [auto, c, sbk_99_2_entity] @@ -9564,8 +9279,7 @@ segments: dir: world/area_dro/dro_01 type: code start: 0x95B200 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dro_01_0_header] - [auto, c, dro_01_1_music] @@ -9579,8 +9293,7 @@ segments: dir: world/area_dro/dro_02 type: code start: 0x9691C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dro_02_0_header] - [auto, c, dro_02_1_music] @@ -9613,8 +9326,7 @@ segments: dir: world/area_isk/isk_01 type: code start: 0x978140 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_01_0_header] - [auto, c, isk_01_1_music] @@ -9625,8 +9337,7 @@ segments: dir: world/area_isk/isk_02 type: code start: 0x978710 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_02_0_header] - [auto, c, isk_02_1_main] @@ -9638,8 +9349,7 @@ segments: dir: world/area_isk/isk_03 type: code start: 0x979E50 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_03_0_header] - [auto, c, isk_03_1_main] @@ -9650,8 +9360,7 @@ segments: dir: world/area_isk/isk_04 type: code start: 0x97B630 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_04_0_header] - [auto, c, isk_04_1_music] @@ -9664,8 +9373,7 @@ segments: dir: world/area_isk/isk_05 type: code start: 0x97DAD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_05_0_header] - [auto, c, isk_05_1_main] @@ -9675,8 +9383,7 @@ segments: dir: world/area_isk/isk_06 type: code start: 0x980A20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_06_0_header] - [auto, c, isk_06_1_main] @@ -9687,8 +9394,7 @@ segments: dir: world/area_isk/isk_07 type: code start: 0x982440 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_07_0_header] - [auto, c, isk_07_1_main] @@ -9702,8 +9408,7 @@ segments: dir: world/area_isk/isk_08 type: code start: 0x984E30 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_08_0_header] - [auto, c, isk_08_1_main] @@ -9713,8 +9418,7 @@ segments: dir: world/area_isk/isk_09 type: code start: 0x9864E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_09_0_header] - [auto, c, isk_09_1_music] @@ -9726,8 +9430,7 @@ segments: dir: world/area_isk/isk_10 type: code start: 0x988B60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_10_0_header] - [auto, c, isk_10_1_main] @@ -9737,8 +9440,7 @@ segments: dir: world/area_isk/isk_11 type: code start: 0x98AA10 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_11_0_header] - [auto, c, isk_11_1_music] @@ -9751,8 +9453,7 @@ segments: dir: world/area_isk/isk_12 type: code start: 0x98D640 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_12_0_header] - [auto, c, isk_12_1_main] @@ -9763,8 +9464,7 @@ segments: dir: world/area_isk/isk_13 type: code start: 0x98F7E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_13_0_header] - [auto, c, isk_13_1_main] @@ -9774,8 +9474,7 @@ segments: dir: world/area_isk/isk_14 type: code start: 0x992730 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_14_0_header] - [auto, c, isk_14_1_main] @@ -9785,8 +9484,7 @@ segments: dir: world/area_isk/isk_16 type: code start: 0x9951F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_16_0_header] - [auto, c, isk_16_1_main] @@ -9797,8 +9495,7 @@ segments: dir: world/area_isk/isk_18 type: code start: 0x997F70 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_18_0_header] - [auto, c, isk_18_1_main] @@ -9808,8 +9505,7 @@ segments: dir: world/area_isk/isk_19 type: code start: 0x999740 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, isk_19_0_header] - [auto, c, isk_19_1_music] @@ -9819,8 +9515,7 @@ segments: dir: world/area_trd/trd_00 type: code start: 0x999C70 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_00_0_header] - [auto, c, trd_00_1_main] @@ -9830,8 +9525,7 @@ segments: dir: world/area_trd/trd_01 type: code start: 0x99C990 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_01_0_header] - [auto, c, trd_01_1_main] @@ -9841,8 +9535,7 @@ segments: dir: world/area_trd/trd_02 type: code start: 0x9A0FE0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_02_0_header] - [auto, c, trd_02_1_main] @@ -9852,8 +9545,7 @@ segments: dir: world/area_trd/trd_03 type: code start: 0x9A4650 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_03_0_header] - [auto, c, trd_03_1_main] @@ -9864,8 +9556,7 @@ segments: dir: world/area_trd/trd_04 type: code start: 0x9A83F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_04_0_header] - [auto, c, trd_04_1_main] @@ -9875,8 +9566,7 @@ segments: dir: world/area_trd/trd_05 type: code start: 0x9AE700 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_05_0_header] - [auto, c, trd_05_1_main] @@ -9887,8 +9577,7 @@ segments: dir: world/area_trd/trd_06 type: code start: 0x9B1790 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_06_0_header] - [auto, c, trd_06_1_main] @@ -9900,8 +9589,7 @@ segments: dir: world/area_trd/trd_07 type: code start: 0x9B6980 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_07_0_header] - [auto, c, trd_07_1_main] @@ -9911,8 +9599,7 @@ segments: dir: world/area_trd/trd_08 type: code start: 0x9BB2A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_08_0_header] - [auto, c, trd_08_1_main] @@ -9922,8 +9609,7 @@ segments: dir: world/area_trd/trd_09 type: code start: 0x9BD660 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_09_0_header] - [auto, c, trd_09_1_main] @@ -9934,8 +9620,7 @@ segments: dir: world/area_trd/trd_10 type: code start: 0x9C2910 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, trd_10_0_header] - [auto, c, trd_10_1_main] @@ -9945,8 +9630,7 @@ segments: dir: world/area_nok/nok_01 type: code start: 0x9C53E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, nok_01_0_header] - [auto, c, nok_01_1_music] @@ -9961,8 +9645,7 @@ segments: dir: world/area_nok/nok_02 type: code start: 0x9D7020 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, nok_02_0_header] - [auto, c, nok_02_1_music] @@ -9979,8 +9662,7 @@ segments: dir: world/area_nok/nok_03 type: code start: 0x9EB7F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, nok_03_0_header] - [auto, c, nok_03_1_music] @@ -9991,8 +9673,7 @@ segments: dir: world/area_nok/nok_04 type: code start: 0x9EDBF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, nok_04_0_header] - [auto, c, nok_04_1_music] @@ -10004,8 +9685,7 @@ segments: dir: world/area_nok/nok_11 type: code start: 0x9F4A40 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, nok_11_0_header] - [auto, c, nok_11_1_music] @@ -10016,8 +9696,7 @@ segments: dir: world/area_nok/nok_12 type: code start: 0x9FA7F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, nok_12_0_header] - [auto, c, nok_12_1_music] @@ -10031,8 +9710,7 @@ segments: dir: world/area_nok/nok_13 type: code start: 0xA00600 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, nok_13_0_header] - [auto, c, nok_13_1_music] @@ -10044,8 +9722,7 @@ segments: dir: world/area_nok/nok_14 type: code start: 0xA02840 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, nok_14_0_header] - [auto, c, nok_14_1_music] @@ -10057,8 +9734,7 @@ segments: dir: world/area_nok/nok_15 type: code start: 0xA06F00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, nok_15_0_header] - [auto, c, nok_15_1_music] @@ -10070,8 +9746,7 @@ segments: dir: world/area_hos/hos_00 type: code start: 0xA0BCF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, hos_00_0_header] - [auto, c, hos_00_1_music] @@ -10085,8 +9760,7 @@ segments: dir: world/area_hos/hos_01 type: code start: 0xA10880 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, hos_01_0_header] - [auto, c, hos_01_1_music] @@ -10099,8 +9773,7 @@ segments: dir: world/area_hos/hos_02 type: code start: 0xA16220 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, hos_02_0_header] - [auto, c, hos_02_1_music] @@ -10113,8 +9786,7 @@ segments: dir: world/area_hos/hos_03 type: code start: 0xA1B100 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, hos_03_0_header] - [auto, c, hos_03_1_music] @@ -10129,8 +9801,7 @@ segments: dir: world/area_hos/hos_04 type: code start: 0xA26ED0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, hos_04_0_header] - [auto, c, hos_04_1_music] @@ -10144,8 +9815,7 @@ segments: dir: world/area_hos/hos_05 type: code start: 0xA2A240 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, hos_05_0_header] - [auto, c, hos_05_1_music] @@ -10160,8 +9830,7 @@ segments: dir: world/area_hos/hos_06 type: code start: 0xA394E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, hos_06_0_header] - [auto, c, hos_06_1_entity] @@ -10174,8 +9843,7 @@ segments: dir: world/area_hos/hos_10 type: code start: 0xA3F740 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, hos_10_0_header] - [auto, c, hos_10_1_music] @@ -10189,8 +9857,7 @@ segments: dir: world/area_hos/hos_20 type: code start: 0xA45930 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, hos_20_0_header] - [auto, c, hos_20_1_main] @@ -10199,8 +9866,7 @@ segments: dir: world/area_kpa/kpa_01 type: code start: 0xA46F60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_01_0_header] - [auto, c, kpa_01_1_music] @@ -10211,8 +9877,7 @@ segments: dir: world/area_kpa/kpa_03 type: code start: 0xA485C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_03_0_header] - [auto, c, kpa_03_1_music] @@ -10223,8 +9888,7 @@ segments: dir: world/area_kpa/kpa_04 type: code start: 0xA4BF60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_04_0_header] - [auto, c, kpa_04_1_music] @@ -10234,8 +9898,7 @@ segments: dir: world/area_kpa/kpa_08 type: code start: 0xA4CA20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_08_0_header] - [auto, c, kpa_08_1_music] @@ -10246,8 +9909,7 @@ segments: dir: world/area_kpa/kpa_09 type: code start: 0xA4F000 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_09_0_header] - [auto, c, kpa_09_1_music] @@ -10258,8 +9920,7 @@ segments: dir: world/area_kpa/kpa_10 type: code start: 0xA51980 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_10_0_header] - [auto, c, kpa_10_1_music] @@ -10270,8 +9931,7 @@ segments: dir: world/area_kpa/kpa_11 type: code start: 0xA528C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_11_0_header] - [auto, c, kpa_11_1_music] @@ -10282,8 +9942,7 @@ segments: dir: world/area_kpa/kpa_12 type: code start: 0xA54950 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_12_0_header] - [auto, c, kpa_12_1_music] @@ -10293,8 +9952,7 @@ segments: dir: world/area_kpa/kpa_13 type: code start: 0xA55F20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_13_0_header] - [auto, c, kpa_13_1_music] @@ -10305,8 +9963,7 @@ segments: dir: world/area_kpa/kpa_14 type: code start: 0xA574B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_14_0_header] - [auto, c, kpa_14_1_music] @@ -10317,8 +9974,7 @@ segments: dir: world/area_kpa/kpa_15 type: code start: 0xA59390 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_15_0_header] - [auto, c, kpa_15_1_music] @@ -10328,8 +9984,7 @@ segments: dir: world/area_kpa/kpa_16 type: code start: 0xA5A030 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_16_0_header] - [auto, c, kpa_16_1_music] @@ -10340,8 +9995,7 @@ segments: dir: world/area_kpa/kpa_17 type: code start: 0xA5CA20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_17_0_header] - [auto, c, kpa_17_1_music] @@ -10352,8 +10006,7 @@ segments: dir: world/area_kpa/kpa_32 type: code start: 0xA5E0C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_32_0_header] - [auto, c, kpa_32_1_music] @@ -10363,8 +10016,7 @@ segments: dir: world/area_kpa/kpa_33 type: code start: 0xA5F080 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_33_0_header] - [auto, c, kpa_33_1_music] @@ -10374,8 +10026,7 @@ segments: dir: world/area_kpa/kpa_40 type: code start: 0xA60040 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_40_0_header] - [auto, c, kpa_40_1_music] @@ -10384,8 +10035,7 @@ segments: dir: world/area_kpa/kpa_41 type: code start: 0xA60470 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_41_0_header] - [auto, c, kpa_41_1_music] @@ -10394,8 +10044,7 @@ segments: dir: world/area_kpa/kpa_50 type: code start: 0xA609D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_50_0_header] - [auto, c, kpa_50_1_music] @@ -10405,8 +10054,7 @@ segments: dir: world/area_kpa/kpa_51 type: code start: 0xA64090 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_51_0_header] - [auto, c, kpa_51_1_music] @@ -10416,8 +10064,7 @@ segments: dir: world/area_kpa/kpa_52 type: code start: 0xA67100 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_52_0_header] - [auto, c, kpa_52_1_music] @@ -10428,8 +10075,7 @@ segments: dir: world/area_kpa/kpa_53 type: code start: 0xA6ACA0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_53_0_header] - [auto, c, kpa_53_1_music] @@ -10440,8 +10086,7 @@ segments: dir: world/area_kpa/kpa_60 type: code start: 0xA6CB00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_60_0_header] - [auto, c, kpa_60_1_music] @@ -10452,8 +10097,7 @@ segments: dir: world/area_kpa/kpa_61 type: code start: 0xA6E3E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_61_0_header] - [auto, c, kpa_61_1_music] @@ -10464,8 +10108,7 @@ segments: dir: world/area_kpa/kpa_62 type: code start: 0xA72220 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_62_0_header] - [auto, c, kpa_62_1_music] @@ -10475,8 +10118,7 @@ segments: dir: world/area_kpa/kpa_63 type: code start: 0xA735B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_63_0_header] - [auto, c, kpa_63_1_music] @@ -10487,8 +10129,7 @@ segments: dir: world/area_kpa/kpa_70 type: code start: 0xA74870 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_70_0_header] - [auto, c, kpa_70_1_music] @@ -10500,8 +10141,7 @@ segments: dir: world/area_kpa/kpa_81 type: code start: 0xA784C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_81_0_header] - [auto, c, kpa_81_1_music] @@ -10511,8 +10151,7 @@ segments: dir: world/area_kpa/kpa_82 type: code start: 0xA7A500 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_82_0_header] - [auto, c, kpa_82_1_music] @@ -10522,8 +10161,7 @@ segments: dir: world/area_kpa/kpa_83 type: code start: 0xA83490 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_83_0_header] - [auto, c, kpa_83_1_music] @@ -10533,8 +10171,7 @@ segments: dir: world/area_kpa/kpa_90 type: code start: 0xA867B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_90_0_header] - [auto, c, kpa_90_1_music] @@ -10543,8 +10180,7 @@ segments: dir: world/area_kpa/kpa_91 type: code start: 0xA86A50 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_91_0_header] - [auto, c, kpa_91_1_music] @@ -10555,8 +10191,7 @@ segments: dir: world/area_kpa/kpa_94 type: code start: 0xA8C7C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_94_0_header] - [auto, c, kpa_94_1_music] @@ -10565,8 +10200,7 @@ segments: dir: world/area_kpa/kpa_95 type: code start: 0xA8CA80 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_95_0_header] - [auto, c, kpa_95_1_music] @@ -10577,8 +10211,7 @@ segments: dir: world/area_kpa/kpa_96 type: code start: 0xA927C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_96_0_header] - [auto, c, kpa_96_1_music] @@ -10588,8 +10221,7 @@ segments: dir: world/area_kpa/kpa_100 type: code start: 0xA93160 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_100_0_header] - [auto, c, kpa_100_1_music] @@ -10599,8 +10231,7 @@ segments: dir: world/area_kpa/kpa_101 type: code start: 0xA93440 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_101_0_header] - [auto, c, kpa_101_1_music] @@ -10610,8 +10241,7 @@ segments: dir: world/area_kpa/kpa_102 type: code start: 0xA93740 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_102_0_header] - [auto, c, kpa_102_1_music] @@ -10621,8 +10251,7 @@ segments: dir: world/area_kpa/kpa_111 type: code start: 0xA99590 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_111_0_header] - [auto, c, kpa_111_1_music] @@ -10634,8 +10263,7 @@ segments: dir: world/area_kpa/kpa_112 type: code start: 0xA9C990 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_112_0_header] - [auto, c, kpa_112_1_music] @@ -10644,8 +10272,7 @@ segments: dir: world/area_kpa/kpa_113 type: code start: 0xA9CC30 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_113_0_header] - [auto, c, kpa_113_1_music] @@ -10657,8 +10284,7 @@ segments: dir: world/area_kpa/kpa_114 type: code start: 0xA9E980 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_114_0_header] - [auto, c, kpa_114_1_music] @@ -10668,8 +10294,7 @@ segments: dir: world/area_kpa/kpa_115 type: code start: 0xA9ED40 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_115_0_header] - [auto, c, kpa_115_1_music] @@ -10680,8 +10305,7 @@ segments: dir: world/area_kpa/kpa_116 type: code start: 0xAA1EE0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_116_0_header] - [auto, c, kpa_116_1_music] @@ -10690,8 +10314,7 @@ segments: dir: world/area_kpa/kpa_117 type: code start: 0xAA2180 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_117_0_header] - [auto, c, kpa_117_1_music] @@ -10700,8 +10323,7 @@ segments: dir: world/area_kpa/kpa_118 type: code start: 0xAA23C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_118_0_header] - [auto, c, kpa_118_1_music] @@ -10710,8 +10332,7 @@ segments: dir: world/area_kpa/kpa_119 type: code start: 0xAA2660 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_119_0_header] - [auto, c, kpa_119_1_music] @@ -10721,8 +10342,7 @@ segments: dir: world/area_kpa/kpa_121 type: code start: 0xAA28F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_121_0_header] - [auto, c, kpa_121_1_music] @@ -10731,8 +10351,7 @@ segments: dir: world/area_kpa/kpa_130 type: code start: 0xAA2D20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_130_0_header] - [auto, c, kpa_130_1_music] @@ -10742,8 +10361,7 @@ segments: dir: world/area_kpa/kpa_133 type: code start: 0xAA7480 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_133_0_header] - [auto, c, kpa_133_1_music] @@ -10756,8 +10374,7 @@ segments: dir: world/area_kpa/kpa_134 type: code start: 0xAA8FA0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kpa_134_0_header] - [auto, c, kpa_134_1_music] @@ -10770,8 +10387,7 @@ segments: dir: world/area_osr/osr_00 type: code start: 0xAAC830 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, osr_00_0_header] - [auto, c, osr_00_1_music] @@ -10783,8 +10399,7 @@ segments: dir: world/area_osr/osr_01 type: code start: 0xAAFFF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, osr_01_0_header] - [auto, c, osr_01_1_music] @@ -10794,8 +10409,7 @@ segments: dir: world/area_osr/osr_02 type: code start: 0xAB2170 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, osr_02_0_header] - [auto, c, osr_02_1_main] @@ -10806,8 +10420,7 @@ segments: dir: world/area_osr/osr_03 type: code start: 0xAB6290 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, osr_03_0_header] - [auto, c, osr_03_1_main] @@ -10820,8 +10433,7 @@ segments: dir: world/area_osr/osr_04 type: code start: 0xAB92B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, osr_04_0_header] - [auto, c, osr_04_1_main] @@ -10830,8 +10442,7 @@ segments: dir: world/area_kkj/kkj_00 type: code start: 0xABB290 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_00_0_header] - [auto, c, kkj_00_1_music] @@ -10844,8 +10455,7 @@ segments: dir: world/area_kkj/kkj_01 type: code start: 0xAC5170 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_01_0_header] - [auto, c, kkj_01_1_music] @@ -10855,8 +10465,7 @@ segments: dir: world/area_kkj/kkj_02 type: code start: 0xAC8D20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_02_0_header] - [auto, c, kkj_02_1_music] @@ -10866,8 +10475,7 @@ segments: dir: world/area_kkj/kkj_03 type: code start: 0xAC9710 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_03_0_header] - [auto, c, kkj_03_1_music] @@ -10878,8 +10486,7 @@ segments: dir: world/area_kkj/kkj_10 type: code start: 0xACAB20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_10_0_header] - [auto, c, kkj_10_1_main] @@ -10890,8 +10497,7 @@ segments: dir: world/area_kkj/kkj_11 type: code start: 0xACE140 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_11_0_header] - [auto, c, kkj_11_1_main] @@ -10904,8 +10510,7 @@ segments: dir: world/area_kkj/kkj_12 type: code start: 0xAD4090 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_12_0_header] - [auto, c, kkj_12_1_main] @@ -10914,8 +10519,7 @@ segments: dir: world/area_kkj/kkj_13 type: code start: 0xAD5ED0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_13_0_header] - [auto, c, kkj_13_1_music] @@ -10927,8 +10531,7 @@ segments: dir: world/area_kkj/kkj_14 type: code start: 0xADAEA0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_14_0_header] - [auto, c, kkj_14_1_music] @@ -10950,8 +10553,7 @@ segments: dir: world/area_kkj/kkj_15 type: code start: 0xAE5590 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_15_0_header] - [auto, c, kkj_15_1_music] @@ -10968,8 +10570,7 @@ segments: dir: world/area_kkj/kkj_16 type: code start: 0xAED410 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_16_0_header] - [auto, c, kkj_16_1_main] @@ -10981,8 +10582,7 @@ segments: dir: world/area_kkj/kkj_17 type: code start: 0xAF1C60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_17_0_header] - [auto, c, kkj_17_1_main] @@ -10992,8 +10592,7 @@ segments: dir: world/area_kkj/kkj_18 type: code start: 0xAF2CA0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_18_0_header] - [auto, c, kkj_18_1_music] @@ -11004,8 +10603,7 @@ segments: dir: world/area_kkj/kkj_19 type: code start: 0xAF7950 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_19_0_header] - [auto, c, kkj_19_1_music] @@ -11017,8 +10615,7 @@ segments: dir: world/area_kkj/kkj_20 type: code start: 0xAFDB40 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_20_0_header] - [auto, c, kkj_20_1_music] @@ -11029,8 +10626,7 @@ segments: dir: world/area_kkj/kkj_21 type: code start: 0xB022A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_21_0_header] - [auto, c, kkj_21_1_main] @@ -11038,8 +10634,7 @@ segments: dir: world/area_kkj/kkj_22 type: code start: 0xB024F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_22_0_header] - [auto, c, kkj_22_1_music] @@ -11048,8 +10643,7 @@ segments: dir: world/area_kkj/kkj_23 type: code start: 0xB02880 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_23_0_header] - [auto, c, kkj_23_1_music] @@ -11061,8 +10655,7 @@ segments: dir: world/area_kkj/kkj_24 type: code start: 0xB06570 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_24_0_header] - [auto, c, kkj_24_1_music] @@ -11072,8 +10665,7 @@ segments: dir: world/area_kkj/kkj_25 type: code start: 0xB06A00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_25_0_header] - [auto, c, kkj_25_1_main] @@ -11089,8 +10681,7 @@ segments: dir: world/area_kkj/kkj_26 type: code start: 0xB13120 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_26_0_header] - [auto, c, kkj_26_1_main] @@ -11100,8 +10691,7 @@ segments: dir: world/area_kkj/kkj_27 type: code start: 0xB13D70 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_27_0_header] - [auto, c, kkj_27_1_music] @@ -11111,8 +10701,7 @@ segments: dir: world/area_kkj/kkj_28 type: code start: 0xB14EA0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_28_0_header] - [auto, c, kkj_28_1_main] @@ -11120,8 +10709,7 @@ segments: dir: world/area_kkj/kkj_29 type: code start: 0xB150B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kkj_29_0_header] - [auto, c, kkj_29_1_main] @@ -11131,8 +10719,7 @@ segments: dir: world/area_tst/tst_01 type: code start: 0xB1A900 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tst_01_1_main] - [auto, c, tst_01_2_entity] @@ -11140,8 +10727,7 @@ segments: dir: world/area_tst/tst_02 type: code start: 0xB1AC30 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tst_02_1_main] - [auto, c, tst_02_2_entity] @@ -11149,8 +10735,7 @@ segments: dir: world/area_tst/tst_03 type: code start: 0xB1AF80 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tst_03_1_main] - [auto, c, tst_03_2_entity] @@ -11158,8 +10743,7 @@ segments: dir: world/area_tst/tst_04 type: code start: 0xB1B570 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tst_04_1_main] - [auto, c, tst_04_2_entity] @@ -11169,16 +10753,14 @@ segments: dir: world/area_tst/tst_10 type: code start: 0xB1C540 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tst_10_1_main] - name: tst_11 dir: world/area_tst/tst_11 type: code start: 0xB1CA50 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tst_11_1_main] - [auto, c, tst_11_2_extra] @@ -11186,16 +10768,14 @@ segments: dir: world/area_tst/tst_12 type: code start: 0xB1D2F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tst_12_1_main] - name: tst_13 dir: world/area_tst/tst_13 type: code start: 0xB1D760 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tst_13_1_main] - start: 0xB1DB20 @@ -11210,16 +10790,14 @@ segments: dir: world/area_tst/tst_20 type: code start: 0xB20470 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, tst_20_1_main] - name: jan_00 dir: world/area_jan/jan_00 type: code start: 0xB20540 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_00_0_header] - [auto, c, jan_00_1_main] @@ -11231,8 +10809,7 @@ segments: dir: world/area_jan/jan_01 type: code start: 0xB28030 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_01_0_header] - [auto, c, jan_01_1_music] @@ -11244,8 +10821,7 @@ segments: dir: world/area_jan/jan_02 type: code start: 0xB2C470 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_02_0_header] - [auto, c, jan_02_1_music] @@ -11257,8 +10833,7 @@ segments: dir: world/area_jan/jan_03 type: code start: 0xB34BD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_03_0_header] - [auto, c, jan_03_1_music] @@ -11272,8 +10847,7 @@ segments: dir: world/area_jan/jan_04 type: code start: 0xB44770 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_04_0_header] - [auto, c, jan_04_1_music] @@ -11290,8 +10864,7 @@ segments: dir: world/area_jan/jan_05 type: code start: 0xB4AA70 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_05_0_header] - [auto, c, jan_05_1_music] @@ -11305,8 +10878,7 @@ segments: dir: world/area_jan/jan_06 type: code start: 0xB52830 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_06_0_header] - [auto, c, jan_06_1_main] @@ -11320,8 +10892,7 @@ segments: dir: world/area_jan/jan_07 type: code start: 0xB59870 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_07_0_header] - [auto, c, jan_07_1_music] @@ -11333,8 +10904,7 @@ segments: dir: world/area_jan/jan_08 type: code start: 0xB5E2B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_08_0_header] - [auto, c, jan_08_1_music] @@ -11347,8 +10917,7 @@ segments: dir: world/area_jan/jan_09 type: code start: 0xB65AB0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_09_0_header] - [auto, c, jan_09_1_main] @@ -11360,8 +10929,7 @@ segments: dir: world/area_jan/jan_10 type: code start: 0xB6C390 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_10_0_header] - [auto, c, jan_10_1_music] @@ -11375,8 +10943,7 @@ segments: dir: world/area_jan/jan_11 type: code start: 0xB70860 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_11_0_header] - [auto, c, jan_11_1_music] @@ -11386,8 +10953,7 @@ segments: dir: world/area_jan/jan_12 type: code start: 0xB730B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_12_0_header] - [auto, c, jan_12_1_main] @@ -11399,8 +10965,7 @@ segments: dir: world/area_jan/jan_13 type: code start: 0xB767B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_13_0_header] - [auto, c, jan_13_1_main] @@ -11411,8 +10976,7 @@ segments: dir: world/area_jan/jan_14 type: code start: 0xB7A050 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_14_0_header] - [auto, c, jan_14_1_main] @@ -11423,8 +10987,7 @@ segments: dir: world/area_jan/jan_15 type: code start: 0xB7D920 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_15_0_header] - [auto, c, jan_15_1_main] @@ -11435,8 +10998,7 @@ segments: dir: world/area_jan/jan_16 type: code start: 0xB80000 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_16_0_header] - [auto, c, jan_16_1_music] @@ -11448,8 +11010,7 @@ segments: dir: world/area_jan/jan_17 type: code start: 0xB837C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_17_0_header] - [auto, c, jan_17_1_music] @@ -11459,8 +11020,7 @@ segments: dir: world/area_jan/jan_18 type: code start: 0xB83B90 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_18_0_header] - [auto, c, jan_18_1_music] @@ -11470,8 +11030,7 @@ segments: dir: world/area_jan/jan_19 type: code start: 0xB83E60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_19_0_header] - [auto, c, jan_19_1_music] @@ -11481,8 +11040,7 @@ segments: dir: world/area_jan/jan_22 type: code start: 0xB84180 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_22_0_header] - [auto, c, jan_22_1_music] @@ -11496,8 +11054,7 @@ segments: dir: world/area_jan/jan_23 type: code start: 0xB8FCD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, jan_23_0_header] - [auto, c, jan_23_1_music] @@ -11507,8 +11064,7 @@ segments: dir: world/area_mim/mim_01 type: code start: 0xB93440 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_01_0_header] - [auto, c, mim_01_1_music] @@ -11521,8 +11077,7 @@ segments: dir: world/area_mim/mim_02 type: code start: 0xB97C00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_02_0_header] - [auto, c, mim_02_1_music] @@ -11534,8 +11089,7 @@ segments: dir: world/area_mim/mim_03 type: code start: 0xB9B480 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_03_0_header] - [auto, c, mim_03_1_music] @@ -11548,8 +11102,7 @@ segments: dir: world/area_mim/mim_04 type: code start: 0xB9D960 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_04_0_header] - [auto, c, mim_04_1_music] @@ -11562,8 +11115,7 @@ segments: dir: world/area_mim/mim_05 type: code start: 0xBA0730 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_05_0_header] - [auto, c, mim_05_1_music] @@ -11576,8 +11128,7 @@ segments: dir: world/area_mim/mim_06 type: code start: 0xBA4780 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_06_0_header] - [auto, c, mim_06_1_music] @@ -11590,8 +11141,7 @@ segments: dir: world/area_mim/mim_07 type: code start: 0xBAA140 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_07_0_header] - [auto, c, mim_07_1_music] @@ -11604,8 +11154,7 @@ segments: dir: world/area_mim/mim_08 type: code start: 0xBAD940 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_08_0_header] - [auto, c, mim_08_1_music] @@ -11617,8 +11166,7 @@ segments: dir: world/area_mim/mim_09 type: code start: 0xBB2E00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_09_0_header] - [auto, c, mim_09_1_music] @@ -11631,8 +11179,7 @@ segments: dir: world/area_mim/mim_10 type: code start: 0xBB59E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_10_0_header] - [auto, c, mim_10_1_music] @@ -11643,8 +11190,7 @@ segments: dir: world/area_mim/mim_11 type: code start: 0xBB7070 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_11_0_header] - [auto, c, mim_11_1_music] @@ -11657,8 +11203,7 @@ segments: dir: world/area_mim/mim_12 type: code start: 0xBBB380 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mim_12_0_header] - [auto, c, mim_12_1_music] @@ -11670,8 +11215,7 @@ segments: dir: world/area_obk/obk_01 type: code start: 0xBBD1A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, obk_01_0_header] - [auto, c, obk_01_1_music] @@ -11685,8 +11229,7 @@ segments: dir: world/area_obk/obk_02 type: code start: 0xBC2A90 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, obk_02_0_header] - [auto, c, obk_02_1_music] @@ -11699,8 +11242,7 @@ segments: dir: world/area_obk/obk_03 type: code start: 0xBC4280 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, obk_03_0_header] - [auto, c, obk_03_1_music] @@ -11714,8 +11256,7 @@ segments: dir: world/area_obk/obk_04 type: code start: 0xBC7E60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, obk_04_0_header] - [auto, c, obk_04_1_music] @@ -11728,8 +11269,7 @@ segments: dir: world/area_obk/obk_05 type: code start: 0xBCD060 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, obk_05_0_header] - [auto, c, obk_05_1_music] @@ -11742,8 +11282,7 @@ segments: dir: world/area_obk/obk_06 type: code start: 0xBCE690 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, obk_06_0_header] - [auto, c, obk_06_1_music] @@ -11754,8 +11293,7 @@ segments: dir: world/area_obk/obk_07 type: code start: 0xBCEBF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, obk_07_0_header] - [auto, c, obk_07_1_music] @@ -11768,8 +11306,7 @@ segments: dir: world/area_obk/obk_08 type: code start: 0xBD3870 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, obk_08_0_header] - [auto, c, obk_08_1_music] @@ -11782,8 +11319,7 @@ segments: dir: world/area_obk/obk_09 type: code start: 0xBDA7B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, obk_09_0_header] - [auto, c, obk_09_1_music] @@ -11796,8 +11332,7 @@ segments: dir: world/area_arn/arn_02 type: code start: 0xBDD1B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_02_0_header] - [auto, c, arn_02_1_music] @@ -11808,8 +11343,7 @@ segments: dir: world/area_arn/arn_03 type: code start: 0xBDED90 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_03_0_header] - [auto, c, arn_03_1_music] @@ -11820,8 +11354,7 @@ segments: dir: world/area_arn/arn_04 type: code start: 0xBE37B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_04_0_header] - [auto, c, arn_04_1_music] @@ -11832,8 +11365,7 @@ segments: dir: world/area_arn/arn_05 type: code start: 0xBE7BE0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_05_0_header] - [auto, c, arn_05_1_music] @@ -11844,8 +11376,7 @@ segments: dir: world/area_arn/arn_07 type: code start: 0xBECDF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_07_0_header] - [auto, c, arn_07_1_music] @@ -11857,8 +11388,7 @@ segments: dir: world/area_arn/arn_08 type: code start: 0xBF47A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_08_0_header] - [auto, c, arn_08_1_music] @@ -11872,8 +11402,7 @@ segments: dir: world/area_arn/arn_09 type: code start: 0xBF6060 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_09_0_header] - [auto, c, arn_09_1_music] @@ -11885,8 +11414,7 @@ segments: dir: world/area_arn/arn_10 type: code start: 0xBF6A00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_10_0_header] - [auto, c, arn_10_1_music] @@ -11897,8 +11425,7 @@ segments: dir: world/area_arn/arn_11 type: code start: 0xBF7680 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_11_0_header] - [auto, c, arn_11_1_music] @@ -11908,8 +11435,7 @@ segments: dir: world/area_arn/arn_12 type: code start: 0xBF8790 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_12_0_header] - [auto, c, arn_12_1_music] @@ -11920,8 +11446,7 @@ segments: dir: world/area_arn/arn_13 type: code start: 0xBF9410 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, arn_13_0_header] - [auto, c, arn_13_1_music] @@ -11932,8 +11457,7 @@ segments: dir: world/area_dgb/dgb_00 type: code start: 0xBFA0A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_00_0_header] - [auto, c, dgb_00_1_music] @@ -11944,8 +11468,7 @@ segments: dir: world/area_dgb/dgb_01 type: code start: 0xBFD880 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_01_0_header] - [auto, c, dgb_01_1_music] @@ -12022,8 +11545,7 @@ segments: type: code dir: world/area_dgb start: 0xC20F40 - vram: 0x80200000 - vram_of_symbol: D_80200000 + vram_class: dgb_01_smash_bridges subsegments: - [auto, c, dgb_01_smash_bridges] - start: 0xC20F40 @@ -12324,8 +11846,7 @@ segments: dir: world/area_dgb/dgb_02 type: code start: 0xC2EBA0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_02_0_header] - [auto, c, dgb_02_1_music] @@ -12335,8 +11856,7 @@ segments: dir: world/area_dgb/dgb_03 type: code start: 0xC314E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_03_0_header] - [auto, c, dgb_03_1_music] @@ -12348,8 +11868,7 @@ segments: dir: world/area_dgb/dgb_04 type: code start: 0xC36530 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_04_0_header] - [auto, c, dgb_04_1_music] @@ -12360,8 +11879,7 @@ segments: dir: world/area_dgb/dgb_05 type: code start: 0xC3AA10 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_05_0_header] - [auto, c, dgb_05_1_music] @@ -12373,8 +11891,7 @@ segments: dir: world/area_dgb/dgb_06 type: code start: 0xC3D080 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_06_0_header] - [auto, c, dgb_06_1_music] @@ -12385,8 +11902,7 @@ segments: dir: world/area_dgb/dgb_07 type: code start: 0xC3DBF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_07_0_header] - [auto, c, dgb_07_1_music] @@ -12397,8 +11913,7 @@ segments: dir: world/area_dgb/dgb_08 type: code start: 0xC3FDB0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_08_0_header] - [auto, c, dgb_08_1_music] @@ -12409,8 +11924,7 @@ segments: dir: world/area_dgb/dgb_09 type: code start: 0xC46BE0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_09_0_header] - [auto, c, dgb_09_1_music] @@ -12421,8 +11935,7 @@ segments: dir: world/area_dgb/dgb_10 type: code start: 0xC4C390 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_10_0_header] - [auto, c, dgb_10_1_music] @@ -12433,8 +11946,7 @@ segments: dir: world/area_dgb/dgb_11 type: code start: 0xC4D3E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_11_0_header] - [auto, c, dgb_11_1_music] @@ -12444,8 +11956,7 @@ segments: dir: world/area_dgb/dgb_12 type: code start: 0xC4DEF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_12_0_header] - [auto, c, dgb_12_1_music] @@ -12456,8 +11967,7 @@ segments: dir: world/area_dgb/dgb_13 type: code start: 0xC4E960 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_13_0_header] - [auto, c, dgb_13_1_music] @@ -12468,8 +11978,7 @@ segments: dir: world/area_dgb/dgb_14 type: code start: 0xC4F030 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_14_0_header] - [auto, c, dgb_14_1_music] @@ -12479,8 +11988,7 @@ segments: dir: world/area_dgb/dgb_15 type: code start: 0xC4F510 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_15_0_header] - [auto, c, dgb_15_1_music] @@ -12491,8 +11999,7 @@ segments: dir: world/area_dgb/dgb_16 type: code start: 0xC52540 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_16_0_header] - [auto, c, dgb_16_1_music] @@ -12503,8 +12010,7 @@ segments: dir: world/area_dgb/dgb_17 type: code start: 0xC55A60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_17_0_header] - [auto, c, dgb_17_1_music] @@ -12514,8 +12020,7 @@ segments: dir: world/area_dgb/dgb_18 type: code start: 0xC55F40 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, dgb_18_0_header] - [auto, c, dgb_18_1_music] @@ -12526,8 +12031,7 @@ segments: dir: world/area_kzn/kzn_01 type: code start: 0xC599D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_01_0_header] - [auto, c, kzn_01_1_main] @@ -12536,8 +12040,7 @@ segments: dir: world/area_kzn/kzn_02 type: code start: 0xC5A740 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_02_0_header] - [auto, c, kzn_02_1_main] @@ -12548,8 +12051,7 @@ segments: dir: world/area_kzn/kzn_03 type: code start: 0xC60D10 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_03_0_header] - [auto, c, kzn_03_1_main] @@ -12560,8 +12062,7 @@ segments: dir: world/area_kzn/kzn_04 type: code start: 0xC68130 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_04_0_header] - [auto, c, kzn_04_1_main] @@ -12571,8 +12072,7 @@ segments: dir: world/area_kzn/kzn_05 type: code start: 0xC6C0D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_05_0_header] - [auto, c, kzn_05_1_main] @@ -12580,8 +12080,7 @@ segments: dir: world/area_kzn/kzn_06 type: code start: 0xC6C920 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_06_0_header] - [auto, c, kzn_06_1_main] @@ -12591,8 +12090,7 @@ segments: dir: world/area_kzn/kzn_07 type: code start: 0xC6E330 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_07_0_header] - [auto, c, kzn_07_1_music] @@ -12603,8 +12101,7 @@ segments: dir: world/area_kzn/kzn_08 type: code start: 0xC71480 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_08_0_header] - [auto, c, kzn_08_1_main] @@ -12615,8 +12112,7 @@ segments: dir: world/area_kzn/kzn_09 type: code start: 0xC76CE0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_09_0_header] - [auto, c, kzn_09_1_main] @@ -12627,8 +12123,7 @@ segments: dir: world/area_kzn/kzn_10 type: code start: 0xC7E180 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_10_0_header] - [auto, c, kzn_10_1_main] @@ -12637,8 +12132,7 @@ segments: dir: world/area_kzn/kzn_11 type: code start: 0xC801A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_11_0_header] - [auto, c, kzn_11_1_main] @@ -12648,8 +12142,7 @@ segments: dir: world/area_kzn/kzn_17 type: code start: 0xC85AB0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_17_0_header] - [auto, c, kzn_17_1_main] @@ -12660,8 +12153,7 @@ segments: dir: world/area_kzn/kzn_18 type: code start: 0xC8C0A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_18_0_header] - [auto, c, kzn_18_1_main] @@ -12671,8 +12163,7 @@ segments: dir: world/area_kzn/kzn_19 type: code start: 0xC8DBB0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_19_0_header] - [auto, c, kzn_19_1_music] @@ -12700,8 +12191,7 @@ segments: dir: world/area_kzn/kzn_20 type: code start: 0xC95F30 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_20_0_header] - [auto, c, kzn_20_1_music] @@ -12711,8 +12201,7 @@ segments: dir: world/area_kzn/kzn_22 type: code start: 0xC9A200 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_22_0_header] - [auto, c, kzn_22_1_music] @@ -12723,8 +12212,7 @@ segments: dir: world/area_kzn/kzn_23 type: code start: 0xC9C300 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, kzn_23_0_header] - [auto, c, kzn_23_1_music] @@ -12734,8 +12222,7 @@ segments: dir: world/area_flo/flo_00 type: code start: 0xC9DF20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_00_0_header] - [auto, c, flo_00_1_music] @@ -12748,8 +12235,7 @@ segments: dir: world/area_flo/flo_03 type: code start: 0xCA72A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_03_0_header] - [auto, c, flo_03_1_music] @@ -12761,8 +12247,7 @@ segments: dir: world/area_flo/flo_07 type: code start: 0xCAC1F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_07_0_header] - [auto, c, flo_07_1_music] @@ -12772,8 +12257,7 @@ segments: dir: world/area_flo/flo_08 type: code start: 0xCAED40 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_08_0_header] - [auto, c, flo_08_1_music] @@ -12786,8 +12270,7 @@ segments: dir: world/area_flo/flo_09 type: code start: 0xCB5000 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_09_0_header] - [auto, c, flo_09_1_music] @@ -12799,8 +12282,7 @@ segments: dir: world/area_flo/flo_10 type: code start: 0xCB9200 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_10_0_header] - [auto, c, flo_10_1_music] @@ -12814,8 +12296,7 @@ segments: dir: world/area_flo/flo_11 type: code start: 0xCBDCD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_11_0_header] - [auto, c, flo_11_1_music] @@ -12826,8 +12307,7 @@ segments: dir: world/area_flo/flo_12 type: code start: 0xCC0E30 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_12_0_header] - [auto, c, flo_12_1_music] @@ -12837,8 +12317,7 @@ segments: dir: world/area_flo/flo_13 type: code start: 0xCC3810 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_13_0_header] - [auto, c, flo_13_1_music] @@ -12850,8 +12329,7 @@ segments: dir: world/area_flo/flo_14 type: code start: 0xCCB310 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_14_0_header] - [auto, c, flo_14_1_music] @@ -12864,8 +12342,7 @@ segments: dir: world/area_flo/flo_15 type: code start: 0xCD06C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_15_0_header] - [auto, c, flo_15_1_music] @@ -12877,8 +12354,7 @@ segments: dir: world/area_flo/flo_16 type: code start: 0xCD1E30 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_16_0_header] - [auto, c, flo_16_1_music] @@ -12891,8 +12367,7 @@ segments: dir: world/area_flo/flo_17 type: code start: 0xCD72E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_17_0_header] - [auto, c, flo_17_1_music] @@ -12904,8 +12379,7 @@ segments: dir: world/area_flo/flo_18 type: code start: 0xCDC6A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_18_0_header] - [auto, c, flo_18_1_music] @@ -12917,8 +12391,7 @@ segments: dir: world/area_flo/flo_19 type: code start: 0xCE36F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_19_0_header] - [auto, c, flo_19_1_music] @@ -12930,8 +12403,7 @@ segments: dir: world/area_flo/flo_21 type: code start: 0xCE6700 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_21_0_header] - [auto, c, flo_21_1_music] @@ -12942,8 +12414,7 @@ segments: dir: world/area_flo/flo_22 type: code start: 0xCEC240 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_22_0_header] - [auto, c, flo_22_1_music] @@ -12955,8 +12426,7 @@ segments: dir: world/area_flo/flo_23 type: code start: 0xCEE260 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_23_0_header] - [auto, c, flo_23_1_music] @@ -12967,8 +12437,7 @@ segments: dir: world/area_flo/flo_24 type: code start: 0xCF0940 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_24_0_header] - [auto, c, flo_24_1_music] @@ -12980,8 +12449,7 @@ segments: dir: world/area_flo/flo_25 type: code start: 0xCF2BD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, flo_25_0_header] - [auto, c, flo_25_1_music] @@ -12994,8 +12462,7 @@ segments: dir: world/area_sam/sam_01 type: code start: 0xCF7B70 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_01_0_header] - [auto, c, sam_01_1_music] @@ -13008,8 +12475,7 @@ segments: dir: world/area_sam/sam_02 type: code start: 0xD05730 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_02_0_header] - [auto, c, sam_02_1_music] @@ -13022,8 +12488,7 @@ segments: dir: world/area_sam/sam_03 type: code start: 0xD110C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_03_0_header] - [auto, c, sam_03_1_music] @@ -13034,8 +12499,7 @@ segments: dir: world/area_sam/sam_04 type: code start: 0xD135D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_04_0_header] - [auto, c, sam_04_1_music] @@ -13047,8 +12511,7 @@ segments: dir: world/area_sam/sam_05 type: code start: 0xD187E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_05_0_header] - [auto, c, sam_05_1_music] @@ -13089,8 +12552,7 @@ segments: dir: world/area_sam/sam_06 type: code start: 0xD1FE90 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_06_0_header] - [auto, c, sam_06_1_music] @@ -13102,8 +12564,7 @@ segments: dir: world/area_sam/sam_07 type: code start: 0xD2BD30 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_07_0_header] - [auto, c, sam_07_1_music] @@ -13115,8 +12576,7 @@ segments: dir: world/area_sam/sam_08 type: code start: 0xD2FC80 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_08_0_header] - [auto, c, sam_08_1_music] @@ -13128,8 +12588,7 @@ segments: dir: world/area_sam/sam_09 type: code start: 0xD362F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_09_0_header] - [auto, c, sam_09_1_music] @@ -13140,8 +12599,7 @@ segments: dir: world/area_sam/sam_10 type: code start: 0xD37800 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_10_0_header] - [auto, c, sam_10_1_music] @@ -13153,8 +12611,7 @@ segments: dir: world/area_sam/sam_11 type: code start: 0xD3A5D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_11_0_header] - [auto, c, sam_11_1_music] @@ -13170,8 +12627,7 @@ segments: dir: world/area_sam/sam_12 type: code start: 0xD4BA20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, sam_12_0_header] - [auto, c, sam_12_1_music] @@ -13183,8 +12639,7 @@ segments: dir: world/area_pra/pra_01 type: code start: 0xD4D040 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_01_0_header] - [auto, c, pra_01_1_music] @@ -13195,8 +12650,7 @@ segments: dir: world/area_pra/pra_02 type: code start: 0xD4FFF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_02_0_header] - [auto, c, pra_02_1_music] @@ -13207,8 +12661,7 @@ segments: dir: world/area_pra/pra_03 type: code start: 0xD53CB0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_03_0_header] - [auto, c, pra_03_1_music] @@ -13218,8 +12671,7 @@ segments: dir: world/area_pra/pra_04 type: code start: 0xD54690 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_04_0_header] - [auto, c, pra_04_1_music] @@ -13230,8 +12682,7 @@ segments: dir: world/area_pra/pra_05 type: code start: 0xD55BB0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_05_0_header] - [auto, c, pra_05_1_music] @@ -13241,8 +12692,7 @@ segments: dir: world/area_pra/pra_06 type: code start: 0xD57430 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_06_0_header] - [auto, c, pra_06_1_music] @@ -13252,8 +12702,7 @@ segments: dir: world/area_pra/pra_09 type: code start: 0xD58890 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_09_0_header] - [auto, c, pra_09_1_music] @@ -13263,8 +12712,7 @@ segments: dir: world/area_pra/pra_10 type: code start: 0xD5F2B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_10_0_header] - [auto, c, pra_10_1_music] @@ -13274,8 +12722,7 @@ segments: dir: world/area_pra/pra_11 type: code start: 0xD61500 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_11_0_header] - [auto, c, pra_11_1_music] @@ -13285,8 +12732,7 @@ segments: dir: world/area_pra/pra_12 type: code start: 0xD62D10 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_12_0_header] - [auto, c, pra_12_1_music] @@ -13296,8 +12742,7 @@ segments: dir: world/area_pra/pra_13 type: code start: 0xD645E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_13_0_header] - [auto, c, pra_13_1_music] @@ -13307,8 +12752,7 @@ segments: dir: world/area_pra/pra_14 type: code start: 0xD67D00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_14_0_header] - [auto, c, pra_14_1_music] @@ -13318,8 +12762,7 @@ segments: dir: world/area_pra/pra_15 type: code start: 0xD69810 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_15_0_header] - [auto, c, pra_15_1_music] @@ -13329,8 +12772,7 @@ segments: dir: world/area_pra/pra_16 type: code start: 0xD69B20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_16_0_header] - [auto, c, pra_16_1_music] @@ -13339,8 +12781,7 @@ segments: dir: world/area_pra/pra_18 type: code start: 0xD6B620 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_18_0_header] - [auto, c, pra_18_1_music] @@ -13350,8 +12791,7 @@ segments: dir: world/area_pra/pra_19 type: code start: 0xD6E9B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_19_0_header] - [auto, c, pra_19_1_music] @@ -13361,8 +12801,7 @@ segments: dir: world/area_pra/pra_20 type: code start: 0xD763A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_20_0_header] - [auto, c, pra_20_1_music] @@ -13371,8 +12810,7 @@ segments: dir: world/area_pra/pra_21 type: code start: 0xD77F20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_21_0_header] - [auto, c, pra_21_1_music] @@ -13382,8 +12820,7 @@ segments: dir: world/area_pra/pra_22 type: code start: 0xD78880 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_22_0_header] - [auto, c, pra_22_1_music] @@ -13393,8 +12830,7 @@ segments: dir: world/area_pra/pra_27 type: code start: 0xD799F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_27_0_header] - [auto, c, pra_27_1_music] @@ -13404,8 +12840,7 @@ segments: dir: world/area_pra/pra_28 type: code start: 0xD7B2A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_28_0_header] - [auto, c, pra_28_1_music] @@ -13415,8 +12850,7 @@ segments: dir: world/area_pra/pra_29 type: code start: 0xD7CB50 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_29_0_header] - [auto, c, pra_29_1_music] @@ -13427,8 +12861,7 @@ segments: dir: world/area_pra/pra_31 type: code start: 0xD7ED60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_31_0_header] - [auto, c, pra_31_1_music] @@ -13523,8 +12956,7 @@ segments: dir: world/area_pra/pra_32 type: code start: 0xD86A00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_32_0_header] - [auto, c, pra_32_1_music] @@ -13534,8 +12966,7 @@ segments: dir: world/area_pra/pra_33 type: code start: 0xD896E0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_33_0_header] - [auto, c, pra_33_1_music] @@ -13545,8 +12976,7 @@ segments: dir: world/area_pra/pra_34 type: code start: 0xD8B3B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_34_0_header] - [auto, c, pra_34_1_music] @@ -13556,8 +12986,7 @@ segments: dir: world/area_pra/pra_35 type: code start: 0xD8D250 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_35_0_header] - [auto, c, pra_35_1_music] @@ -13568,8 +12997,7 @@ segments: dir: world/area_pra/pra_36 type: code start: 0xD91700 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_36_0_header] - [auto, c, pra_36_1_music] @@ -13579,8 +13007,7 @@ segments: dir: world/area_pra/pra_37 type: code start: 0xD92F40 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_37_0_header] - [auto, c, pra_37_1_music] @@ -13590,8 +13017,7 @@ segments: dir: world/area_pra/pra_38 type: code start: 0xD955F0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_38_0_header] - [auto, c, pra_38_1_music] @@ -13601,8 +13027,7 @@ segments: dir: world/area_pra/pra_39 type: code start: 0xD97890 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_39_0_header] - [auto, c, pra_39_1_music] @@ -13612,8 +13037,7 @@ segments: dir: world/area_pra/pra_40 type: code start: 0xD999B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, pra_40_0_header] - [auto, c, pra_40_1_music] @@ -13623,8 +13047,7 @@ segments: dir: world/area_omo/omo_01 type: code start: 0xD9AEF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_01_0_header] - [auto, c, omo_01_1_music] @@ -13636,8 +13059,7 @@ segments: dir: world/area_omo/omo_02 type: code start: 0xD9D4D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_02_0_header] - [auto, c, omo_02_1_music] @@ -13650,8 +13072,7 @@ segments: dir: world/area_omo/omo_03 type: code start: 0xDA5240 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_03_0_header] - [auto, c, omo_03_1_music] @@ -13666,8 +13087,7 @@ segments: dir: world/area_omo/omo_04 type: code start: 0xDAD400 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_04_0_header] - [auto, c, omo_04_1_music] @@ -13680,8 +13100,7 @@ segments: dir: world/area_omo/omo_05 type: code start: 0xDB22C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_05_0_header] - [auto, c, omo_05_1_music] @@ -13693,8 +13112,7 @@ segments: dir: world/area_omo/omo_06 type: code start: 0xDB7910 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_06_0_header] - [auto, c, omo_06_1_music] @@ -13707,8 +13125,7 @@ segments: dir: world/area_omo/omo_07 type: code start: 0xDBD2B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_07_0_header] - [auto, c, omo_07_1_music] @@ -13721,8 +13138,7 @@ segments: dir: world/area_omo/omo_08 type: code start: 0xDC43D0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_08_0_header] - [auto, c, omo_08_1_music] @@ -13735,8 +13151,7 @@ segments: dir: world/area_omo/omo_09 type: code start: 0xDCCCD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_09_0_header] - [auto, c, omo_09_1_music] @@ -13751,8 +13166,7 @@ segments: dir: world/area_omo/omo_10 type: code start: 0xDD79B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_10_0_header] - [auto, c, omo_10_1_music] @@ -13765,8 +13179,7 @@ segments: dir: world/area_omo/omo_11 type: code start: 0xDDC830 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_11_0_header] - [auto, c, omo_11_1_music] @@ -13778,8 +13191,7 @@ segments: dir: world/area_omo/omo_12 type: code start: 0xDDF310 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_12_0_header] - [auto, c, omo_12_1_music] @@ -13790,8 +13202,7 @@ segments: dir: world/area_omo/omo_13 type: code start: 0xDE2490 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_13_0_header] - [auto, c, omo_13_1_music] @@ -13803,8 +13214,7 @@ segments: dir: world/area_omo/omo_14 type: code start: 0xDE56B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_14_0_header] - [auto, c, omo_14_1_music] @@ -13814,8 +13224,7 @@ segments: dir: world/area_omo/omo_15 type: code start: 0xDE8770 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_15_0_header] - [auto, c, omo_15_1_music] @@ -13825,8 +13234,7 @@ segments: dir: world/area_omo/omo_16 type: code start: 0xDEBED0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_16_0_header] - [auto, c, omo_16_1_main] @@ -13836,8 +13244,7 @@ segments: dir: world/area_omo/omo_17 type: code start: 0xDEEEA0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, omo_17_0_header] - [auto, c, omo_17_1_main] @@ -13849,8 +13256,7 @@ segments: dir: world/area_end/end_00 type: code start: 0xDF6A00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, end_00_0_header] - [auto, c, end_00_1_main] @@ -13868,8 +13274,7 @@ segments: dir: world/area_end/end_01 type: code start: 0xE05360 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, end_01_0_header] - [auto, c, end_01_1_main] @@ -13883,8 +13288,7 @@ segments: dir: world/area_mgm/mgm_00 type: code start: 0xE0E7A0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mgm_00_0_header] - [auto, c, mgm_00_1_main] @@ -13894,8 +13298,7 @@ segments: dir: world/area_mgm/mgm_01 type: code start: 0xE12760 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mgm_01_0_header] - [auto, c, mgm_01_1_main] @@ -13923,8 +13326,7 @@ segments: dir: world/area_mgm/mgm_02 type: code start: 0xE15D80 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mgm_02_0_header] - [auto, c, mgm_02_1_main] @@ -13944,8 +13346,7 @@ segments: dir: world/area_mgm/mgm_03 type: code start: 0xE1E380 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, mgm_03_0_header] - [auto, c, mgm_03_1_main] @@ -13953,23 +13354,20 @@ segments: dir: world/area_gv/gv_01 type: code start: 0xE1E460 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map subsegments: - [auto, c, gv_01_0_header] - [auto, c, gv_01_1_main] - name: heaps2 type: code start: 0xE20110 - vram: 0x80267FF0 - vram_of_symbol: map_vram_end + vram_class: heaps2 subsegments: - [auto, c, heaps2] - type: code start: 0xE20110 name: inspect_icon - vram: 0x802B7000 - vram_of_symbol: world_action_vram_end + vram_class: indicator_icon subsegments: - [auto, c, inspect_icon] - start: 0xE20B30 @@ -13984,8 +13382,7 @@ segments: - type: code start: 0xE20EB0 name: speech_bubble - vram: 0x802B7000 - vram_of_symbol: world_action_vram_end + vram_class: indicator_icon subsegments: - [auto, c, speech_bubble] - start: 0xE215C0 @@ -14000,8 +13397,7 @@ segments: - type: code start: 0xE21870 name: pulse_stone - vram: 0x802B7000 - vram_of_symbol: world_action_vram_end + vram_class: indicator_icon subsegments: - [auto, c, pulse_stone] - start: 0xE21EB0 @@ -14017,8 +13413,7 @@ segments: - type: code start: 0xE225B0 name: i_spy - vram: 0x802B7000 - vram_of_symbol: world_action_vram_end + vram_class: indicator_icon subsegments: - [auto, c, i_spy] - start: 0xE22B30 @@ -14035,159 +13430,139 @@ segments: - type: code name: model_clear_render_tasks start: 0xE23260 - vram: 0x802B7E00 - vram_of_symbol: world_misc_vram_end + vram_class: model_clear_render_tasks subsegments: - [auto, c, model_clear_render_tasks] - type: code name: world_action_idle dir: world/action start: 0xE23260 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, idle] - type: code name: world_action_walk dir: world/action start: 0xE236E0 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, walk] - type: code name: world_action_jump dir: world/action start: 0xE24040 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, jump] - type: code name: world_action_step_up dir: world/action start: 0xE245D0 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, step_up] - type: code name: world_action_land dir: world/action start: 0xE24920 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, land] - type: code name: world_action_hammer dir: world/action start: 0xE24ED0 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, hammer] - type: code name: world_action_spin dir: world/action start: 0xE25D60 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, spin] - type: code name: world_action_tornado_jump dir: world/action start: 0xE26710 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, tornado_jump] - type: code name: world_action_spin_jump dir: world/action start: 0xE26DE0 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, spin_jump] - type: code name: world_action_slide dir: world/action start: 0xE27510 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, slide] - type: code name: world_action_hit_fire dir: world/action start: 0xE27C90 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, hit_fire] - type: code name: world_action_hit_lava dir: world/action start: 0xE27F40 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, hit_lava] - type: code name: world_action_knockback dir: world/action start: 0xE287F0 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, knockback] - type: code name: world_action_misc dir: world/action start: 0xE28A30 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, misc] - type: code name: world_action_use_munchlesia dir: world/action start: 0xE291A0 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, use_munchlesia] - type: code name: world_action_use_spinning_flower dir: world/action start: 0xE29470 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, use_spinning_flower] - type: code name: world_action_use_tweester dir: world/action start: 0xE2A340 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, use_tweester] - type: code name: world_action_sneaky_parasol dir: world/action start: 0xE2A6B0 - vram: 0x802B6000 - follows_vram: texture_memory + vram_class: world_action subsegments: - [auto, c, sneaky_parasol] - type: code dir: entity/default start: 0xE2B530 - vram: 0x802BAE00 - follows_vram: model_clear_render_tasks + vram_class: area_entities subsegments: - [auto, c, Padlock] - [auto, c, BoardedFloor] @@ -14195,8 +13570,7 @@ segments: - type: code dir: entity/jan_iwa start: 0xE2D730 - vram: 0x802BAE00 - follows_vram: model_clear_render_tasks + vram_class: area_entities subsegments: - [auto, c, Plants1] - [auto, c, Plants2] @@ -14204,8 +13578,7 @@ segments: - type: code dir: entity/sbk_omo start: 0xE2F750 - vram: 0x802BAE00 - follows_vram: model_clear_render_tasks + vram_class: area_entities subsegments: - [auto, c, Tweester] - [auto, c, StarBoxLauncher] @@ -14213,7 +13586,7 @@ segments: dir: entity/model type: code start: 0xE31530 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, Hammer1Block] @@ -14229,7 +13602,7 @@ segments: dir: entity/model type: code start: 0xE31A30 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, Hammer2Block] @@ -14245,7 +13618,7 @@ segments: dir: entity/model type: code start: 0xE31F30 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, Hammer3Block] @@ -14261,7 +13634,7 @@ segments: dir: entity/model type: code start: 0xE32420 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, ShatteringHammer1Block] @@ -14277,7 +13650,7 @@ segments: dir: entity/model type: code start: 0xE35670 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, ShatteringHammer2Block] @@ -14292,7 +13665,7 @@ segments: dir: entity/model type: code start: 0xE38890 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, ShatteringHammer3Block] @@ -14308,7 +13681,7 @@ segments: dir: entity/model type: code start: 0xE3B870 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, YellowBlock] @@ -14323,7 +13696,7 @@ segments: dir: entity/model type: code start: 0xE3C320 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, RedBlock] @@ -14338,7 +13711,7 @@ segments: dir: entity/model type: code start: 0xE3CDD0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, UnusedBlock] @@ -14356,7 +13729,7 @@ segments: dir: entity/model type: code start: 0xE3DA60 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, PushBlock] @@ -14372,7 +13745,7 @@ segments: dir: entity/model type: code start: 0xE3DDB0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, BrickBlock] @@ -14388,7 +13761,7 @@ segments: dir: entity/model type: code start: 0xE3E260 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, ShatteringBrickBlock] @@ -14403,7 +13776,7 @@ segments: dir: entity/model type: code start: 0xE42240 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, InertYellowBlock] @@ -14420,7 +13793,7 @@ segments: dir: entity/model type: code start: 0xE42740 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, InertRedBlock] @@ -14436,7 +13809,7 @@ segments: dir: entity/model type: code start: 0xE431F0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, HeartBlock] @@ -14451,7 +13824,7 @@ segments: dir: entity/model type: code start: 0xE43B20 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, PowBlock] @@ -14467,7 +13840,7 @@ segments: dir: entity/model type: code start: 0xE44800 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, SuperBlock] @@ -14483,7 +13856,7 @@ segments: dir: entity/model type: code start: 0xE45110 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, UltraBlock] @@ -14499,7 +13872,7 @@ segments: dir: entity/model type: code start: 0xE459F0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, HitYellowBlock_gfx] @@ -14516,14 +13889,14 @@ segments: dir: entity/model type: code start: 0xE46E10 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, HitYellowBlock_anim] - name: entity_model_HitFloatingYellowBlock_gfx dir: entity/model type: code start: 0xE470B0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, HitFloatingYellowBlock_gfx] @@ -14540,14 +13913,14 @@ segments: dir: entity/model type: code start: 0xE484F0 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, HitFloatingYellowBlock_anim] - name: entity_model_HitRedBlock_gfx dir: entity/model type: code start: 0xE48780 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, HitRedBlock_gfx] @@ -14564,14 +13937,14 @@ segments: dir: entity/model type: code start: 0xE49BE0 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, HitRedBlock_anim] - name: entity_model_HeartBlockContent dir: entity/model type: code start: 0xE49E40 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, HeartBlockContent] @@ -14589,7 +13962,7 @@ segments: dir: entity/model type: code start: 0xE4A6A0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, SuperBlockContent] @@ -14607,7 +13980,7 @@ segments: dir: entity/model type: code start: 0xE4AA80 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, UltraBlockContent] @@ -14625,7 +13998,7 @@ segments: dir: entity/model type: code start: 0xE4B2E0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, SaveBlock] @@ -14646,7 +14019,7 @@ segments: dir: entity/model type: code start: 0xE4E7F0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, BoardedFloor] @@ -14672,7 +14045,7 @@ segments: dir: entity/model type: code start: 0xE51640 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, WoodenCrate] @@ -14691,7 +14064,7 @@ segments: dir: entity/model type: code start: 0xE55A40 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, StarBoxLauncher] @@ -14715,14 +14088,14 @@ segments: dir: entity/model type: code start: 0xE56BA0 - vram: 0x0A000000 + vram_class: entity_model subsegments: - [auto, c, HiddenPanel] - name: entity_model_Tweester dir: entity/model type: code start: 0xE56E60 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, Tweester] @@ -14744,7 +14117,7 @@ segments: dir: entity/model type: code start: 0xE58CD0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, BlueWarpPipe] @@ -14765,7 +14138,7 @@ segments: dir: entity/model type: code start: 0xE59480 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, Signpost] @@ -14782,7 +14155,7 @@ segments: dir: entity/model type: code start: 0xE59F00 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, ArrowSign] @@ -14798,7 +14171,7 @@ segments: dir: entity/model type: code start: 0xE5AB50 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, Padlock] @@ -14823,7 +14196,7 @@ segments: dir: entity/model type: code start: 0xE5CD80 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, PadlockRedFrame] @@ -14845,7 +14218,7 @@ segments: dir: entity/model type: code start: 0xE5E730 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, PadlockRedFace] @@ -14869,7 +14242,7 @@ segments: dir: entity/model type: code start: 0xE60550 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, PadlockBlueFace] @@ -14893,7 +14266,7 @@ segments: dir: entity/model type: code start: 0xE62370 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, GreenStompSwitch] @@ -14913,7 +14286,7 @@ segments: dir: entity/model type: code start: 0xE62AC0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, RedSwitch] @@ -14933,7 +14306,7 @@ segments: dir: entity/model type: code start: 0xE639C0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, BlueSwitch] @@ -14954,7 +14327,7 @@ segments: dir: entity/model type: code start: 0xE648D0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, Chest] @@ -14978,7 +14351,7 @@ segments: dir: entity/model type: code start: 0xE657A0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, ScriptSpring_gfx] @@ -15006,14 +14379,14 @@ segments: dir: entity/model type: code start: 0xE67120 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, ScriptSpring_anim] - name: entity_model_SimpleSpring_gfx dir: entity/model type: code start: 0xE68580 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, SimpleSpring_gfx] @@ -15039,14 +14412,14 @@ segments: dir: entity/model type: code start: 0xE69D50 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, SimpleSpring_anim] - name: entity_model_BellbellPlant_gfx dir: entity/model type: code start: 0xE6B1B0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, BellbellPlant_gfx] @@ -15065,14 +14438,14 @@ segments: dir: entity/model type: code start: 0xE6C440 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, BellbellPlant_anim] - name: entity_model_TrumpetPlant_gfx dir: entity/model type: code start: 0xE6D390 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, TrumpetPlant_gfx] @@ -15088,14 +14461,14 @@ segments: dir: entity/model type: code start: 0xE6E2D0 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, TrumpetPlant_anim] - name: entity_model_MunchlesiaReset_gfx dir: entity/model type: code start: 0xE6E660 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, MunchlesiaReset_gfx] @@ -15110,14 +14483,14 @@ segments: dir: entity/model type: code start: 0xE74750 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, MunchlesiaReset_anim] - name: entity_model_MunchlesiaGrab_gfx dir: entity/model type: code start: 0xE74BD0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, MunchlesiaGrab_gfx] @@ -15132,14 +14505,14 @@ segments: dir: entity/model type: code start: 0xE7ACC0 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, MunchlesiaGrab_anim] - name: entity_model_MunchlesiaEnvelop_gfx dir: entity/model type: code start: 0xE7B0E0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, MunchlesiaEnvelop_gfx] @@ -15154,14 +14527,14 @@ segments: dir: entity/model type: code start: 0xE811D0 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, MunchlesiaEnvelop_anim] - name: entity_model_MunchlesiaBeginChew_gfx dir: entity/model type: code start: 0xE815F0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, MunchlesiaBeginChew_gfx] @@ -15176,14 +14549,14 @@ segments: dir: entity/model type: code start: 0xE88030 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, MunchlesiaBeginChew_anim] - name: entity_model_MunchlesiaChewing_gfx dir: entity/model type: code start: 0xE884A0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, MunchlesiaChewing_gfx] @@ -15198,14 +14571,14 @@ segments: dir: entity/model type: code start: 0xE8A410 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, MunchlesiaChewing_anim] - name: entity_model_MunchlesiaSpitOut_gfx dir: entity/model type: code start: 0xE8A9E0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, MunchlesiaSpitOut_gfx] @@ -15220,14 +14593,14 @@ segments: dir: entity/model type: code start: 0xE91420 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, MunchlesiaSpitOut_anim] - name: entity_model_MunchlesiaReset1_gfx dir: entity/model type: code start: 0xE91890 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, MunchlesiaReset1_gfx] @@ -15242,21 +14615,21 @@ segments: dir: entity/model type: code start: 0xE982D0 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, MunchlesiaReset1_anim] - name: entity_model_CymbalPlant_anim dir: entity/model type: code start: 0xE98740 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, CymbalPlant_anim] - name: entity_model_CymbalPlant_gfx dir: entity/model type: code start: 0xE992F0 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, CymbalPlant_gfx] @@ -15280,14 +14653,14 @@ segments: dir: entity/model type: code start: 0xE9A990 - vram: 0x00000000 + vram_class: entity_model_anim subsegments: - [auto, c, PinkFlower_anim] - name: entity_model_PinkFlower_gfx dir: entity/model type: code start: 0xE9B500 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, PinkFlower_gfx] @@ -15308,7 +14681,7 @@ segments: dir: entity/model type: code start: 0xE9C900 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, SpinningFlower] @@ -15328,7 +14701,7 @@ segments: dir: entity/model type: code start: 0xE9D650 - vram: 0x0A000000 + vram_class: entity_model symbol_name_format: $VRAM_$ROM subsegments: - [auto, c, BombableRock] @@ -15353,7 +14726,7 @@ segments: # dir: world/dead/area_kzn/kzn_11 # type: code # start: 0xE9AFF0 - # vram: 0x80240000 + # vram_class: map # subsegments: # - [auto, c, kzn_11_0_header] # - [auto, c, kzn_11_1_main] @@ -15364,8 +14737,7 @@ segments: dir: world/dead/area_kzn/kzn_17 type: code start: 0xEA0900 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, kzn_17_0_header] @@ -15377,8 +14749,7 @@ segments: dir: world/dead/area_kzn/kzn_18 type: code start: 0xEA6FD0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, kzn_18_0_header] @@ -15389,8 +14760,7 @@ segments: dir: world/dead/area_kzn/kzn_19 type: code start: 0xEA8AE0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, kzn_19_0_header] @@ -15404,8 +14774,7 @@ segments: dir: world/dead/area_kzn/kzn_20 type: code start: 0xEB0E60 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, kzn_20_0_header] @@ -15416,8 +14785,7 @@ segments: dir: world/dead/area_kzn/kzn_22 type: code start: 0xEB5130 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, kzn_22_0_header] @@ -15429,8 +14797,7 @@ segments: dir: world/dead/area_kzn/kzn_23 type: code start: 0xEB7230 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, kzn_23_0_header] @@ -15441,8 +14808,7 @@ segments: dir: world/dead/area_flo/flo_00 type: code start: 0xEB8E50 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_00_0_header] @@ -15456,8 +14822,7 @@ segments: dir: world/dead/area_flo/flo_03 type: code start: 0xEC2200 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_03_0_header] @@ -15470,8 +14835,7 @@ segments: dir: world/dead/area_flo/flo_07 type: code start: 0xEC71B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_07_0_header] @@ -15482,8 +14846,7 @@ segments: dir: world/dead/area_flo/flo_08 type: code start: 0xEC9D00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_08_0_header] @@ -15497,8 +14860,7 @@ segments: dir: world/dead/area_flo/flo_09 type: code start: 0xECFFF0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_09_0_header] @@ -15511,8 +14873,7 @@ segments: dir: world/dead/area_flo/flo_10 type: code start: 0xED4220 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_10_0_header] @@ -15527,8 +14888,7 @@ segments: dir: world/dead/area_flo/flo_11 type: code start: 0xED8E20 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_11_0_header] @@ -15540,8 +14900,7 @@ segments: dir: world/dead/area_flo/flo_12 type: code start: 0xEDBFE0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_12_0_header] @@ -15552,8 +14911,7 @@ segments: dir: world/dead/area_flo/flo_13 type: code start: 0xEDE9C0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_13_0_header] @@ -15566,8 +14924,7 @@ segments: dir: world/dead/area_flo/flo_14 type: code start: 0xEE65B0 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_14_0_header] @@ -15581,8 +14938,7 @@ segments: dir: world/dead/area_flo/flo_15 type: code start: 0xEEB990 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_15_0_header] @@ -15595,8 +14951,7 @@ segments: dir: world/dead/area_flo/flo_16 type: code start: 0xEED100 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_16_0_header] @@ -15610,8 +14965,7 @@ segments: dir: world/dead/area_flo/flo_17 type: code start: 0xEF2610 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_17_0_header] @@ -15624,8 +14978,7 @@ segments: dir: world/dead/area_flo/flo_18 type: code start: 0xEF7A80 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_18_0_header] @@ -15638,8 +14991,7 @@ segments: dir: world/dead/area_flo/flo_19 type: code start: 0xEFEB00 - vram: 0x80240000 - vram_of_symbol: world_model_data_vram_end + vram_class: map dead_code: True subsegments: - [auto, c, flo_19_0_header] diff --git a/ver/us/symbol_addrs.txt b/ver/us/symbol_addrs.txt index 4599d65866..4ea143c333 100644 --- a/ver/us/symbol_addrs.txt +++ b/ver/us/symbol_addrs.txt @@ -3760,9 +3760,6 @@ D_8010C310 = 0x8010C310; // rom:0xA57C0 D_8010C318 = 0x8010C318; // rom:0xA57C8 D_8010C320 = 0x8010C320; // rom:0xA57D0 update_entities = 0x8010F6D0; // type:func rom:0xA5DD0 -D_8010C924 = 0x8010C924; // rom:0xA5DD4 -D_8010C928 = 0x8010C928; // rom:0xA5DD8 -D_8010C92C = 0x8010C92C; // rom:0xA5DDC wPartnerNpc = 0x8010C930; // rom:0xA5DE0 TweesterTouchingPlayer = 0x8010C934; // rom:0xA5DE4 PlayerNormalYaw = 0x8010C938; // rom:0xA5DE8 @@ -6092,8 +6089,6 @@ pause_draw_menu_label = 0x8024EE94; // type:func rom:0x1421D4 gPauseIconScripts = 0x8024EF60; // rom:0x1422A0 gPausePanels = 0x8024EF80; // rom:0x1422C0 D_8024EF98 = 0x8024EF98; // rom:0x1422D8 -gPauseCursorPosX = 0x8024EF9C; // rom:0x1422DC -gPauseCursorPosX = 0x8024EFA0; // rom:0x1422E0 gPauseCursorOpacity = 0x8024EFA4; // rom:0x1422E4 gPauseCursorTargetPosX = 0x8024EFA8; // rom:0x1422E8 gPauseCursorTargetPosY = 0x8024EFAC; // rom:0x1422EC @@ -6424,7 +6419,7 @@ D_80249D70 = 0x80249D70; // rom:0x16A5D0 filemenu_common_windowBPs = 0x80249DAC; // rom:0x16A60C D_80249DCC = 0x80249DCC; // rom:0x16A62C D_80249DD0 = 0x80249DD0; // rom:0x16A630 -get_stick_input_radial = 0x8023E000; // type:func rom:0x16C8E0 +// get_stick_input_radial = 0x8023E000; // type:func rom:0x16C8E0 filemenu_pressedButtons = 0x8024C084; // rom:0x16C8E4 filemenu_cursorHudElem = 0x8024C088; // rom:0x16C8E8 filemenu_heldButtons = 0x8024C08C; // rom:0x16C8EC @@ -6844,7 +6839,6 @@ hide_foreground_models_unchecked = 0x80267BDC; // type:func rom:0x1964BC show_foreground_models_unchecked = 0x80267C48; // type:func rom:0x196528 hide_foreground_models = 0x80267CB4; // type:func rom:0x196594 show_foreground_models = 0x80267D28; // type:func rom:0x196608 -NAMESPACE_StartRumbleWithParams = 0x80267D9C; // type:func rom:0x19667C start_rumble_type = 0x80267DF4; // type:func rom:0x1966D4 LoadItemScript = 0x80267ED0; // type:func rom:0x1967B0 LoadMysteryItemScript = 0x8026801C; // type:func rom:0x1968FC @@ -7614,11 +7608,9 @@ D_8029DA10 = 0x8029DA10; // rom:0x1CC2F0 D_8029DA18 = 0x8029DA18; // rom:0x1CC2F8 D_8029DA20 = 0x8029DA20; // rom:0x1CC300 create_audio_system_obfuscated = 0x80200000; // type:func rom:0x3169F0 -shim_load_engine_data_obfuscated = 0x80200080; // type:func rom:0x316A70 general_heap_create_obfuscated = 0x802AE000; // type:func rom:0x316C00 battle_heap_create_obfuscated = 0x802AE000; // type:func rom:0x316D90 shim_create_audio_system_obfuscated = 0x802B2000; // type:func rom:0x316F30 -shim_load_engine_data_obfuscated = 0x802B203C; // type:func rom:0x316F6C shim_general_heap_create_obfuscated = 0x802B2078; // type:func rom:0x316FA8 shim_battle_heap_create_obfuscated = 0x802B20B4; // type:func rom:0x316FE4 world_goombario_get_trigger_tattle = 0x802BD100; // type:func rom:0x317020 @@ -7821,7 +7813,6 @@ EVS_WorldLakilester_Update = 0x802BFE80; // rom:0x3239D0 EVS_WorldLakilester_UseAbility = 0x802BFE9C; // rom:0x3239EC EVS_WorldLakilester_PutAway = 0x802BFEB8; // rom:0x323A08 EVS_WorldLakilester_EnterMap = 0x802BFED4; // rom:0x323A24 -D_802BFEF8_323A48 = 0x802BFEF8; // rom:0x323A48 world_lakilester_PutAwayState = 0x802BFF00; // rom:0x323A50 world_lakilester_LockingPlayerInput = 0x802BFF04; // rom:0x323A54 world_lakilester_PlayerCollisionDisabled = 0x802BFF08; // rom:0x323A58 @@ -9426,13 +9417,11 @@ b_area_kmr_part_2_Stages = 0x8021987C; // rom:0x43B30C b_area_kmr_part_2_blue_goomba_1_DefenseTable_802198B0 = 0x802198B0; // rom:0x43B340 b_area_kmr_part_2_blue_goomba_1_StatusTable_802198BC = 0x802198BC; // rom:0x43B34C b_area_kmr_part_2_blue_goomba_1_ActorParts = 0x80219968; // rom:0x43B3F8 -b_area_kmr_part_2_blue_goomba_1_sinTable = 0x8021998C; // rom:0x43B41C b_area_kmr_part_2_blue_goomba_1_IdleAnimations_802199B4 = 0x802199B4; // rom:0x43B444 b_area_kmr_part_2_blue_goomba_1_IdleAnimations_80219A00 = 0x80219A00; // rom:0x43B490 b_area_kmr_part_2_blue_goomba_1_init_80219A4C = 0x80219A4C; // rom:0x43B4DC b_area_kmr_part_2_blue_goomba_1_idle_80219A98 = 0x80219A98; // rom:0x43B528 b_area_kmr_part_2_blue_goomba_1_handleEvent_80219D74 = 0x80219D74; // rom:0x43B804 -b_area_kmr_part_2_blue_goomba_1_sinTable = 0x8021A434; // rom:0x43BEC4 b_area_kmr_part_2_blue_goomba_1_takeTurn_8021A5A0 = 0x8021A5A0; // rom:0x43C030 b_area_kmr_part_2_blue_goomba_1_init_8021B268 = 0x8021B268; // rom:0x43CCF8 b_area_kmr_part_2_blue_goomba_1_takeTurn_8021B2C8 = 0x8021B2C8; // rom:0x43CD58 @@ -10105,8 +10094,6 @@ b_area_hos_magikoopa_DefenseTable = 0x8021D480; // rom:0x484530 b_area_hos_magikoopa_FlyingDefense = 0x8021D48C; // rom:0x48453C b_area_hos_magikoopa_StatusTable_8021D498 = 0x8021D498; // rom:0x484548 b_area_hos_magikoopa_StatusTable_8021D544 = 0x8021D544; // rom:0x4845F4 -b_area_hos_magikoopa_ActorParts = 0x8021D5F0; // rom:0x4846A0 -b_area_hos_magikoopa_ActorParts = 0x8021D614; // rom:0x4846C4 b_area_hos_magikoopa = 0x8021D680; // rom:0x484730 b_area_hos_magikoopa_flying = 0x8021D6A8; // rom:0x484758 b_area_hos_magikoopa_IdleAnimations_8021D6D0 = 0x8021D6D0; // rom:0x484780 @@ -10835,13 +10822,11 @@ b_area_iwa_cleft_80219BA0 = 0x80219BA0; // rom:0x4D1D90 b_area_iwa_cleft_takeTurn_8021A3EC = 0x8021A3EC; // rom:0x4D25DC b_area_iwa_monty_mole_DefenseTable_8021A450 = 0x8021A450; // rom:0x4D2640 b_area_iwa_monty_mole_StatusTable_8021A45C = 0x8021A45C; // rom:0x4D264C -b_area_iwa_monty_mole_ActorParts = 0x8021A508; // rom:0x4D26F8 b_area_iwa_monty_mole_1 = 0x8021A574; // rom:0x4D2764 b_area_iwa_monty_mole_IdleAnimations_8021A59C = 0x8021A59C; // rom:0x4D278C b_area_iwa_monty_mole_IdleAnimations_8021A5E8 = 0x8021A5E8; // rom:0x4D27D8 b_area_iwa_monty_mole_IdleAnimations_8021A5F4 = 0x8021A5F4; // rom:0x4D27E4 b_area_iwa_monty_mole_unk_missing_8021A600 = 0x8021A600; // rom:0x4D27F0 -b_area_iwa_monty_mole_ActorParts = 0x8021A60C; // rom:0x4D27FC b_area_iwa_monty_mole_init_8021A630 = 0x8021A630; // rom:0x4D2820 b_area_iwa_monty_mole_2 = 0x8021A690; // rom:0x4D2880 b_area_iwa_monty_mole_vector3D_8021A6B8 = 0x8021A6B8; // rom:0x4D28A8 @@ -10956,8 +10941,6 @@ b_area_sbk_bandit_IdleAnimations_8021D55C = 0x8021D55C; // rom:0x4DFB3C b_area_sbk_bandit_IdleAnimations_8021D5A8 = 0x8021D5A8; // rom:0x4DFB88 b_area_sbk_bandit_DefenseTable_8021D5B4 = 0x8021D5B4; // rom:0x4DFB94 b_area_sbk_bandit_StatusTable_8021D5C0 = 0x8021D5C0; // rom:0x4DFBA0 -b_area_sbk_bandit_ActorParts = 0x8021D66C; // rom:0x4DFC4C -b_area_sbk_bandit_ActorParts = 0x8021D6B4; // rom:0x4DFC94 b_area_sbk_bandit = 0x8021D6D8; // rom:0x4DFCB8 b_area_sbk_bandit_2 = 0x8021D700; // rom:0x4DFCE0 b_area_sbk_bandit_vector3D_8021D728 = 0x8021D728; // rom:0x4DFD08 @@ -13784,7 +13767,7 @@ func_802186E0_6DE4A0 = 0x802186E0; // type:func rom:0x6DE4A0 func_80218770_6DE530 = 0x80218770; // type:func rom:0x6DE530 func_802187F0_6DE5B0 = 0x802187F0; // type:func rom:0x6DE5B0 dup_b_area_dig_SetDemoBattleBeginDelay = 0x80218890; // type:func rom:0x6DE650 -battle_partner_goombario_IdleAnimations_80238000 = 0x80238000; // rom:0x6F0B30 +// battle_partner_goombario_IdleAnimations_80238000 = 0x80238000; // rom:0x6F0B30 battle_partner_goombario_DefenseTable_8023800C = 0x8023800C; // rom:0x6F0B3C battle_partner_goombario_StatusTable_80238018 = 0x80238018; // rom:0x6F0B48 battle_partner_goombario_ActorParts_802380C4 = 0x802380C4; // rom:0x6F0BF4 @@ -13797,7 +13780,7 @@ battle_partner_goombario_80238488 = 0x80238488; // rom:0x6F0FB8 battle_partner_goombario_802384D4 = 0x802384D4; // rom:0x6F1004 battle_partner_goombario_80238510 = 0x80238510; // rom:0x6F1040 battle_partner_goombario_8023859C = 0x8023859C; // rom:0x6F10CC -battle_partner_goombario_func_80238000_6F10E0 = 0x80238000; // type:func rom:0x6F10E0 +// battle_partner_goombario_func_80238000_6F10E0 = 0x80238000; // type:func rom:0x6F10E0 func_802380E4_6F11C4 = 0x802380E4; // type:func rom:0x6F11C4 battle_partner_goombario_JumpOnTarget = 0x8023817C; // type:func rom:0x6F125C battle_partner_goombario_OnMissHeadbonk = 0x80238A20; // type:func rom:0x6F1B00 @@ -13848,7 +13831,7 @@ D_8023CD78_6F5E58 = 0x8023CD78; // rom:0x6F5E58 D_8023CD80_6F5E60 = 0x8023CD80; // rom:0x6F5E60 D_8023CD88_6F5E68 = 0x8023CD88; // rom:0x6F5E68 D_8023CD90_6F5E70 = 0x8023CD90; // rom:0x6F5E70 -func_80238000_6F5E80 = 0x80238000; // type:func rom:0x6F5E80 +// func_80238000_6F5E80 = 0x80238000; // type:func rom:0x6F5E80 func_80238114_6F5F94 = 0x80238114; // type:func rom:0x6F5F94 battle_partner_kooper_AverageTargetDizzyChance = 0x80238298; // type:func rom:0x6F6118 func_802383C0_6F6240 = 0x802383C0; // type:func rom:0x6F6240 @@ -13875,7 +13858,7 @@ battle_partner_kooper_80239E7C = 0x80239E7C; // rom:0x6F7CFC battle_partner_kooper_8023AA38 = 0x8023AA38; // rom:0x6F88B8 battle_partner_kooper_8023B660 = 0x8023B660; // rom:0x6F94E0 battle_partner_kooper_8023C754 = 0x8023C754; // rom:0x6FA5D4 -func_80238000_6FAD10 = 0x80238000; // type:func rom:0x6FAD10 +// func_80238000_6FAD10 = 0x80238000; // type:func rom:0x6FAD10 func_80238244_6FAF54 = 0x80238244; // type:func rom:0x6FAF54 func_80238358_6FB068 = 0x80238358; // type:func rom:0x6FB068 func_8023849C_6FB1AC = 0x8023849C; // type:func rom:0x6FB1AC @@ -13903,13 +13886,13 @@ battle_partner_bombette_8023A584 = 0x8023A584; // rom:0x6FD294 battle_partner_bombette_8023A5F8 = 0x8023A5F8; // rom:0x6FD308 battle_partner_bombette_8023B228 = 0x8023B228; // rom:0x6FDF38 battle_partner_bombette_8023C990 = 0x8023C990; // rom:0x6FF6A0 -func_80238000_6FFD80 = 0x80238000; // type:func rom:0x6FFD80 +// func_80238000_6FFD80 = 0x80238000; // type:func rom:0x6FFD80 func_80238C88_700A08 = 0x80238C88; // type:func rom:0x700A08 func_80238CE0_700A60 = 0x80238CE0; // type:func rom:0x700A60 func_80238E24_700BA4 = 0x80238E24; // type:func rom:0x700BA4 func_802390B4_700E34 = 0x802390B4; // type:func rom:0x700E34 func_802397C8_701548 = 0x802397C8; // type:func rom:0x701548 -func_80238000_703AF0 = 0x80238000; // type:func rom:0x703AF0 +// func_80238000_703AF0 = 0x80238000; // type:func rom:0x703AF0 func_80238370_703E60 = 0x80238370; // type:func rom:0x703E60 func_802383C0_703EB0 = 0x802383C0; // type:func rom:0x703EB0 func_802383D4_703EC4 = 0x802383D4; // type:func rom:0x703EC4 @@ -13928,7 +13911,7 @@ func_80238B3C_70462C = 0x80238B3C; // type:func rom:0x70462C func_80238C08_7046F8 = 0x80238C08; // type:func rom:0x7046F8 func_80238C84_704774 = 0x80238C84; // type:func rom:0x704774 battle_partner_watt_AverageTargetParalyzeChance = 0x80238E5C; // type:func rom:0x70494C -func_80238000_707CA0 = 0x80238000; // type:func rom:0x707CA0 +// func_80238000_707CA0 = 0x80238000; // type:func rom:0x707CA0 func_80238114_707DB4 = 0x80238114; // type:func rom:0x707DB4 func_802381EC_707E8C = 0x802381EC; // type:func rom:0x707E8C func_802382A4_707F44 = 0x802382A4; // type:func rom:0x707F44 @@ -13937,7 +13920,7 @@ func_80238388_708028 = 0x80238388; // type:func rom:0x708028 func_80238480_708120 = 0x80238480; // type:func rom:0x708120 func_80238540_7081E0 = 0x80238540; // type:func rom:0x7081E0 func_80238E30_708AD0 = 0x80238E30; // type:func rom:0x708AD0 -func_80238000_70BD10 = 0x80238000; // type:func rom:0x70BD10 +// func_80238000_70BD10 = 0x80238000; // type:func rom:0x70BD10 func_8023803C_70BD4C = 0x8023803C; // type:func rom:0x70BD4C func_80238A6C_70C77C = 0x80238A6C; // type:func rom:0x70C77C func_80238B50_70C860 = 0x80238B50; // type:func rom:0x70C860 @@ -13950,14 +13933,14 @@ func_80239140_70CE50 = 0x80239140; // type:func rom:0x70CE50 func_80239F84_70DC94 = 0x80239F84; // type:func rom:0x70DC94 func_8023A19C_70DEAC = 0x8023A19C; // type:func rom:0x70DEAC func_8023A1B0_70DEC0 = 0x8023A1B0; // type:func rom:0x70DEC0 -func_80238000_710EF0 = 0x80238000; // type:func rom:0x710EF0 +// func_80238000_710EF0 = 0x80238000; // type:func rom:0x710EF0 func_80238014_710F04 = 0x80238014; // type:func rom:0x710F04 func_8023808C_710F7C = 0x8023808C; // type:func rom:0x710F7C func_802380E4_710FD4 = 0x802380E4; // type:func rom:0x710FD4 battle_partner_bow_IsPartnerImmobile = 0x80238198; // type:func rom:0x711088 func_802381C8_7110B8 = 0x802381C8; // type:func rom:0x7110B8 battle_partner_bow_AverageTargetStatusChance = 0x802381E8; // type:func rom:0x7110D8 -func_80238000_714CF0 = 0x80238000; // type:func rom:0x714CF0 +// func_80238000_714CF0 = 0x80238000; // type:func rom:0x714CF0 func_80238028_714D18 = 0x80238028; // type:func rom:0x714D18 battle_item_mushroom_GiveRefund = 0x802A1000; // type:func rom:0x715850 battle_item_mushroom_GiveRefundCleanup = 0x802A11D4; // type:func rom:0x715A24 @@ -15088,15 +15071,11 @@ dup_mac_00_LetterDelivery_RestoreNpcAnim = 0x80243B2C; // type:func rom:0x7EE83C mac_00_varStash = 0x80245DC0; // rom:0x7F0AD0 mac_00_Quizmo_Answers = 0x80245E24; // rom:0x7F0B34 D_80245E64_7F0B74 = 0x80245E64; // rom:0x7F0B74 -mac_00_ItemChoice_HasSelectedItem = 0x802483E8; // rom:0x7F30F8 -mac_00_ItemChoice_SelectedItemID = 0x802483EC; // rom:0x7F30FC D_80248F18_7F3C28 = 0x80248F18; // rom:0x7F3C28 D_80248F20_7F3C30 = 0x80248F20; // rom:0x7F3C30 D_80248F28_7F3C38 = 0x80248F28; // rom:0x7F3C38 mac_00_dojoBattleIDs = 0x8024A632; // rom:0x7F5340 dup_mac_00_varStash = 0x8024ECE8; // rom:0x7F99F8 -mac_00_ItemChoice_HasSelectedItem = 0x8024ED4C; // rom:0x7F9A5C -mac_00_ItemChoice_SelectedItemID = 0x8024ED50; // rom:0x7F9A60 D_802559C0_8006D0 = 0x802559C0; // rom:0x8006D0 D_802559C8_8006D8 = 0x802559C8; // rom:0x8006D8 mac_01_HideRowfBadge = 0x80240000; // type:func rom:0x800880 @@ -16067,16 +16046,6 @@ kmr_02_Quizmo_Answers = 0x80245634; // rom:0x8B56A4 D_80245674_8B56E4 = 0x80245674; // rom:0x8B56E4 kmr_02_ItemChoice_HasSelectedItem = 0x80247E30; // rom:0x8B7EA0 kmr_02_ItemChoice_SelectedItemID = 0x80247E34; // rom:0x8B7EA4 -D_802480AC_8B811C = 0x802480AC; // rom:0x8B811C -D_8024E538_8BE5A8 = 0x8024E538; // rom:0x8BE5A8 -D_8025578C_8C57FC = 0x8025578C; // rom:0x8C57FC -D_80257B00_8C7B70 = 0x80257B00; // rom:0x8C7B70 -D_80257D00_8C7D70 = 0x80257D00; // rom:0x8C7D70 -D_80257D40_8C7DB0 = 0x80257D40; // rom:0x8C7DB0 -D_80257D48_8C7DB8 = 0x80257D48; // rom:0x8C7DB8 -D_80257D50_8C7DC0 = 0x80257D50; // rom:0x8C7DC0 -D_80257F08_8C7F78 = 0x80257F08; // rom:0x8C7F78 -D_80257F10_8C7F80 = 0x80257F10; // rom:0x8C7F80 kmr_03_ChangeNpcToPartner = 0x80240000; // type:func rom:0x8C7F90 kmr_03_CheckPartnerFlags1000 = 0x80240184; // type:func rom:0x8C8114 kmr_03_func_802401B0_8C8140 = 0x802401B0; // type:func rom:0x8C8140 @@ -17720,7 +17689,6 @@ nok_02_TransformFoliage = 0x802443D0; // type:func rom:0x9DB3F0 dup_nok_02_varStash = 0x802453D0; // rom:0x9DC3F0 nok_02_ItemChoice_HasSelectedItem = 0x80245434; // rom:0x9DC454 nok_02_ItemChoice_SelectedItemID = 0x80245438; // rom:0x9DC458 -nok_02_varStash = 0x802470C8; // rom:0x9DE0E8 nok_02_Quizmo_Answers = 0x8024712C; // rom:0x9DE14C D_8024716C_9DE18C = 0x8024716C; // rom:0x9DE18C dup_nok_02_ItemChoice_HasSelectedItem = 0x802496F0; // rom:0x9E0710 @@ -17728,7 +17696,6 @@ dup_nok_02_ItemChoice_SelectedItemID = 0x802496F4; // rom:0x9E0714 D_802523B4_9E93D4 = 0x802523B4; // rom:0x9E93D4 dup2_nok_02_ItemChoice_HasSelectedItem = 0x80252400; // rom:0x9E9420 dup2_nok_02_ItemChoice_SelectedItemID = 0x80252404; // rom:0x9E9424 -nok_02_varStash = 0x80252720; // rom:0x9E9740 D_80252784_9E97A4 = 0x80252784; // rom:0x9E97A4 D_80252784_9E97A4 + 0x10 = 0x80252794; // rom:0x9E97B4 D_802529B4_9E99D4 = 0x802529B4; // rom:0x9E99D4 @@ -17795,7 +17762,6 @@ D_80245CF0_9FA730 = 0x80245CF0; // rom:0x9FA730 D_80245D50_9FA790 = 0x80245D50; // rom:0x9FA790 D_80245D58_9FA798 = 0x80245D58; // rom:0x9FA798 D_80245D60_9FA7A0 = 0x80245D60; // rom:0x9FA7A0 -UpdateEnounterStages = 0x80240000; // type:func rom:0x9FA7F0 func_80240180_9FA970 = 0x80240180; // type:func rom:0x9FA970 nok_12_SetEntityPosition = 0x80240224; // type:func rom:0x9FAA14 nok_12_DisableCameraLeadingPlayer = 0x802402F0; // type:func rom:0x9FAAE0 @@ -17840,7 +17806,6 @@ func_80241360_A01960 = 0x80241360; // type:func rom:0xA01960 nok_13_musical_hill_orbit_listener = 0x802413CC; // type:func rom:0xA019CC D_80242134_A02734 = 0x80242134; // rom:0xA02734 D_802421D0_A027D0 = 0x802421D0; // rom:0xA027D0 -UpdateEnounterStages = 0x80240000; // type:func rom:0xA02840 nok_14_DisableCameraLeadingPlayer = 0x80240180; // type:func rom:0xA029C0 nok_14_EnableCameraLeadingPlayer = 0x8024019C; // type:func rom:0xA029DC nok_14_set_script_owner_npc_anim = 0x802401C0; // type:func rom:0xA02A00 @@ -18288,22 +18253,6 @@ hos_06_IsItemBadge = 0x80242238; // type:func rom:0xA3B718 func_8024228C_A3B76C = 0x8024228C; // type:func rom:0xA3B76C func_802424CC_A3B9AC = 0x802424CC; // type:func rom:0xA3B9AC hos_06_GetItemEmptyCount = 0x80242534; // type:func rom:0xA3BA14 -hos_06_varStash = 0x80242C08; // rom:0xA3C0E8 -hos_06_ItemChoice_HasSelectedItem = 0x80242C6C; // rom:0xA3C14C -hos_06_ItemChoice_SelectedItemID = 0x80242C70; // rom:0xA3C150 -D_802435EC_A3CACC = 0x802435EC; // rom:0xA3CACC -hos_06_ItemChoice_HasSelectedItem = 0x802445D0; // rom:0xA3DAB0 -hos_06_ItemChoice_SelectedItemID = 0x802445D4; // rom:0xA3DAB4 -hos_06_varStash = 0x8024476C; // rom:0xA3DC4C -D_802447D0_A3DCB0 = 0x802447D0; // rom:0xA3DCB0 -D_802447D4_A3DCB4 = 0x802447D4; // rom:0xA3DCB4 -D_802447D8_A3DCB8 = 0x802447D8; // rom:0xA3DCB8 -D_80244B88_A3E068 = 0x80244B88; // rom:0xA3E068 -D_80244B8C_A3E06C = 0x80244B8C; // rom:0xA3E06C -D_80244C48_A3E128 = 0x80244C48; // rom:0xA3E128 -D_80244C4C_A3E12C = 0x80244C4C; // rom:0xA3E12C -hos_06_varStash = 0x80245E80; // rom:0xA3F360 -D_80245EEC_A3F3CC = 0x80245EEC; // rom:0xA3F3CC hos_10_SetPlayerSpriteSet2_MapInit = 0x80240000; // type:func rom:0xA3F740 hos_10_UpdateTexturePanSmooth = 0x80240020; // type:func rom:0xA3F760 hos_10_UpdateTexturePanStepped = 0x80240144; // type:func rom:0xA3F884 @@ -18432,13 +18381,11 @@ kpa_12_get_tattle = 0x80240000; // type:func rom:0xA54950 kpa_12_UpdateTexturePanSmooth = 0x80240040; // type:func rom:0xA54990 kpa_12_UpdateTexturePanStepped = 0x80240164; // type:func rom:0xA54AB4 kpa_12_GetCurrentFloor = 0x80240350; // type:func rom:0xA54CA0 -AddPlatformPushVelocity = 0x8024037C; // type:func rom:0xA54CCC func_80240444_A54D94 = 0x80240444; // type:func rom:0xA54D94 kpa_13_get_tattle = 0x80240000; // type:func rom:0xA55F20 kpa_13_UpdateTexturePanSmooth = 0x80240040; // type:func rom:0xA55F60 kpa_13_UpdateTexturePanStepped = 0x80240164; // type:func rom:0xA56084 kpa_13_GetFloorBelow = 0x80240350; // type:func rom:0xA56270 -AddPlatformPushVelocity = 0x8024037C; // type:func rom:0xA5629C func_80240444_A56364 = 0x80240444; // type:func rom:0xA56364 kpa_14_get_tattle = 0x80240000; // type:func rom:0xA574B0 kpa_14_UpdateTexturePanSmooth = 0x80240040; // type:func rom:0xA574F0 @@ -18451,7 +18398,6 @@ kpa_14_IsItemBadge = 0x802405E8; // type:func rom:0xA57A98 kpa_14_RemovePadlock = 0x8024063C; // type:func rom:0xA57AEC kpa_14_GetEntityPosition = 0x80240670; // type:func rom:0xA57B20 kpa_14_GetFloorBelow = 0x80240710; // type:func rom:0xA57BC0 -AddPlatformPushVelocity = 0x8024073C; // type:func rom:0xA57BEC func_80240840_A57CF0 = 0x80240840; // type:func rom:0xA57CF0 kpa_14_varStash = 0x80241900; // rom:0xA58DB0 kpa_15_UpdateTexturePanSmooth = 0x80240000; // type:func rom:0xA59390 @@ -21401,9 +21347,6 @@ dgb_04_SuperBlock_WhiteScreenFlash = 0x80242F08; // type:func rom:0xC39438 dgb_04_SuperBlock_PartnerSparkles2 = 0x80243048; // type:func rom:0xC39578 dgb_04_SuperBlock_PartnerSparkles4 = 0x80243090; // type:func rom:0xC395C0 dgb_04_SuperBlock_WaitForPlayerToLand = 0x802430D8; // type:func rom:0xC39608 -dgb_04_entryList = 0x80243110; // rom:0xC39640 -dgb_04_settings = 0x80243130; // rom:0xC39660 -dgb_04_80243170 = 0x80243170; // rom:0xC396A0 dgb_04_exitSingleDoor_80243210 = 0x80243210; // rom:0xC39740 dgb_04_exitDoubleDoor_802432C4 = 0x802432C4; // rom:0xC397F4 dgb_04_enterSingleDoor_80243378 = 0x80243378; // rom:0xC398A8 @@ -22306,9 +22249,6 @@ kzn_17_StashVars = 0x8024259C; // type:func rom:0xC8804C kzn_17_GetItemName = 0x80242650; // type:func rom:0xC88100 kzn_17_GetNpcCollisionHeight = 0x802426B4; // type:func rom:0xC88164 kzn_17_AddPlayerHandsOffset = 0x80242710; // type:func rom:0xC881C0 -kzn_20_AwaitLetterChoiceResult = 0x802428E0; // type:func rom:0xC88390 -kzn_20_SetLetterChoiceResult = 0x80242934; // type:func rom:0xC883E4 -kzn_20_BuildKeyItemChoiceList = 0x8024296C; // type:func rom:0xC8841C kzn_17_LetterDelivery_Init = 0x80242A08; // type:func rom:0xC884B8 kzn_17_LetterDelivery_CalcLetterPos = 0x80242AF8; // type:func rom:0xC885A8 kzn_17_LetterDelivery_SaveNpcAnim = 0x80242C84; // type:func rom:0xC88734 @@ -22384,9 +22324,6 @@ kzn_20_StashVars = 0x80240310; // type:func rom:0xC96240 kzn_20_GetItemName = 0x802403C4; // type:func rom:0xC962F4 kzn_20_GetNpcCollisionHeight = 0x80240428; // type:func rom:0xC96358 kzn_20_AddPlayerHandsOffset = 0x80240484; // type:func rom:0xC963B4 -kzn_20_AwaitLetterChoiceResult = 0x80240654; // type:func rom:0xC96584 -kzn_20_SetLetterChoiceResult = 0x802406A8; // type:func rom:0xC965D8 -kzn_20_BuildKeyItemChoiceList = 0x802406E0; // type:func rom:0xC96610 kzn_20_LetterDelivery_Init = 0x8024077C; // type:func rom:0xC966AC kzn_20_LetterDelivery_CalcLetterPos = 0x8024086C; // type:func rom:0xC9679C kzn_20_LetterDelivery_SaveNpcAnim = 0x802409F8; // type:func rom:0xC96928 @@ -25006,8 +24943,6 @@ end_01_SetSpotlightsAlpha = 0x80242C68; // type:func rom:0xE07FC8 end_01_gfx_build_set_spotlight_alpha = 0x80242C94; // type:func rom:0xE07FF4 end_01_UnkFunc27 = 0x80242CF0; // type:func rom:0xE08050 end_01_UnkFunc26 = 0x80242E14; // type:func rom:0xE08174 -end_01_Font3Patterns = 0x80243178; // -end_01_Font4Patterns = 0x80243110; // end_01_CreditsViewport = 0x80243200; // rom:0xE08560 end_01_CreditsBufferIndex = 0x80243210; // rom:0xE08570 end_01_ParadeNpcsTable = 0x802441F0; // rom:0xE09550 @@ -25843,20 +25778,13 @@ osResetType = 0x8000030C; // osMemSize = 0x80000318; // osAppNMIBuffer = 0x8000031C; // obfuscated_load_engine_data = 0x80026AC7; // -dead_atan2 = 0x8002AF70; // obfuscated_create_audio_system = 0x8004AA85; // ai = 0x8006AD64; // si = 0x8006AD90; // dp = 0x8006AE0C; // osDispatchThreadSave = 0x8006B1F4; // -dead_guMtxIdentF = 0x8006C660; // -dead_guMtxCatF = 0x8006C7C0; // -fx_sun_undeclared = 0x80072950; // type:func EnemyNpcHit = 0x80077F70; // EnemyNpcDefeat = 0x8007809C; // -dead_gGameStatusPtr = 0x80079430; // -dead_gCurrentCameraID = 0x8007C760; // -dead_gItemTable = 0x8008D2C0; // rdpstateinit_dl = 0x80093BB8; // D_80094664 = 0x80094664; // D_80097D60 = 0x80097D60; // @@ -25867,12 +25795,6 @@ D_80097D80 = 0x80097D80; // D_80097D88 = 0x80097D88; // pad = 0x80098474; // nuScPreNMIFlag = 0x8009A5B0; // -D_8009BB30 = 0x8009BB30; // -D_8009C4E0 = 0x8009C4E0; // -D_8009C4FC = 0x8009C4FC; // -dead_gCurrentCamID = 0x800A158C; // -D_800A15A4 = 0x800A15A4; // -dead_gOverrideFlags = 0x800A15A8; // piEventQueue = 0x800AF890; // __osFlashID = 0x800B0C30; // __osFlashMsg = 0x800B0C40; // @@ -25880,754 +25802,18 @@ __osFlashMessageQ = 0x800B0C58; // __osFlashHandler = 0x800B0C70; // __osFlashMsgBuf = 0x800B0CE4; // __osFlashVersion = 0x800B0CE8; // -dead_gCurrentEncounter = 0x800B7EF0; // -dead_gCameras = 0x800B8D80; // _use_partner_ability = 0x800EA6CC; // type:func -dead_gPlayerStatusPtr = 0x800FFC90; // -dead_wPartnerHudScripts = 0x80100060; // -D_801000A0 = 0x801000A0; // -dead_wDisabledPartnerHudScripts = 0x801000A0; // -HES_StoppedLoop = 0x801065B4; // -D_80109480 = 0x80109480; // -D_80109484 = 0x80109484; // -D_80109488 = 0x80109488; // -D_8010948C = 0x8010948C; // -D_80109490 = 0x80109490; // -D_80109492 = 0x80109492; // -D_80109494 = 0x80109494; // -D_80109498 = 0x80109498; // -D_8010949C = 0x8010949C; // -D_801094A0 = 0x801094A0; // -D_801094A4 = 0x801094A4; // -D_801094A8 = 0x801094A8; // -D_801094AC = 0x801094AC; // -D_801094AE = 0x801094AE; // -D_801096B0 = 0x801096B0; // -D_80109710 = 0x80109710; // -D_801097D8 = 0x801097D8; // -D_80109800 = 0x80109800; // -D_80109820 = 0x80109820; // -PulseStoneNotificationCallback = 0x8010C920; // -D_8010C924 = 0x8010C924; // -D_8010C928 = 0x8010C928; // -D_8010C92C = 0x8010C92C; // -wPartnerNpc = 0x8010C930; // -TweesterTouchingPlayer = 0x8010C934; // -PlayerNormalYaw = 0x8010C938; // -ISpyNotificationCallback = 0x8010C93C; // -TalkNotificationCallback = 0x8010C940; // -gSpinHistoryBufferPos = 0x8010C944; // -NpcHitQueryBehindRightY = 0x8010C94C; // -D_8010C950 = 0x8010C950; // -TweesterTouchingPartner = 0x8010C954; // -InteractNotificationCallback = 0x8010C958; // -PrevPlayerDirection = 0x8010C95C; // -JumpedOnSwitchX = 0x8010C960; // -D_8010C964 = 0x8010C964; // -NpcHitQueryBehindCollider = 0x8010C968; // -PeachDisguiseNpcIndex = 0x8010C96C; // -NpcHitQueryAheadY = 0x8010C970; // -NpcHitQueryBehindLeftY = 0x8010C974; // -NpcHitQueryColliderID = 0x8010C978; // -JumpedOnSwitchZ = 0x8010C97C; // -PlayerRunStateTime = 0x8010C980; // -D_8010C984 = 0x8010C984; // -NpcHitQueryAheadCollider = 0x8010C98C; // -PlayerNormalPitch = 0x8010C990; // -PlayerYInterpUpdateDelay = 0x8010C9A0; // -D_8010C9B0 = 0x8010C9B0; // -SwappedWorldMenus = 0x8010C9C0; // -WorldPopupMenu = 0x8010C9C8; // -WorldMenuType = 0x8010CCF8; // -WorldMenuDelay = 0x8010CCFA; // -WorldPopupResult = 0x8010CCFC; // -OpenMenuDisableCount = 0x8010CCFE; // -WorldMenuState = 0x8010CD00; // -D_8010CD10 = 0x8010CD10; // -D_8010CD12 = 0x8010CD12; // -D_8010CD20 = 0x8010CD20; // -PartnerCommand = 0x8010CD30; // -PartnerCommandState = 0x8010CD34; // -gPlayerMoveHistory = 0x8010CD38; // -gPlayerMoveHistoryIndex = 0x8010CFB8; // -D_8010CFBC = 0x8010CFBC; // -wPartnerTetherDistance = 0x8010CFC0; // -D_8010CFC4 = 0x8010CFC4; // -wPartnerFollowState = 0x8010CFC8; // -D_8010CFCA = 0x8010CFCA; // -D_8010CFCC = 0x8010CFCC; // -D_8010CFCE = 0x8010CFCE; // -wPartnerNpcIndex = 0x8010CFD0; // -wPartnerCurrentScript = 0x8010CFD4; // -wCurrentPartnerId = 0x8010CFD8; // -wPartnerCurrentScriptID = 0x8010CFDC; // -D_8010CFE0 = 0x8010CFE0; // -NextPartnerID = 0x8010CFE4; // -NextPartnerCommand = 0x8010CFE8; // -_render_transition_stencil = 0x80136A80; // type:func -get_default_variation_for_song = 0x8014A430; // -D_8014F120 = 0x8014F120; // -D_8014F128 = 0x8014F128; // -rodata_padding_2 = 0x80150BBC; // -gAuxSpriteShadingProfile = 0x801512B0; // -D_801512E8 = 0x801512E8; // -B_801512F0 = 0x801512F0; // -gBattleEntityList = 0x801513F8; // -mdl_treeIterPos = 0x80153224; // -mtg_IterIdx = 0x8015336C; // -gCurrentAnimMeshListPtr = 0x80153A40; // -gAnimRotMtx = 0x80153A68; // -gMessageDrawStatePtr = 0x80155D74; // -ItemPickupGotOutline = 0x801568F0; // -D_80156903 = 0x80156903; // -D_8015690B = 0x8015690B; // -D_8015C7A8 = 0x8015C7A8; // -D_80164000 = 0x80164000; // -dead_gCollisionStatus = 0x80169B10; // -D_80197000 = 0x80197000; // -D_801A6000 = 0x801A6000; // -BattleEntityHeapBottom = 0x801A7000; // -AuHeapBase = 0x801AA000; // -D_80200000 = 0x80200000; // -gBackgroundImage = 0x80200000; // -gMapShapeData = 0x80210000; // -b_area_trd_part_3_HoverOffset = 0x80219040; // -spiked_goomba = 0x8021B0AC; // -paragoomba = 0x8021CD00; // -b_area_pra2_crystal_king_paths = 0x80221630; // -D_80224D60 = 0x80224D60; // -D_80224D64 = 0x80224D64; // -D_80224D70 = 0x80224D70; // -D_80224D74 = 0x80224D74; // -D_80224D80 = 0x80224D80; // -D_80224D90 = 0x80224D90; // -D_80224DA0 = 0x80224DA0; // -D_80224DB0 = 0x80224DB0; // -b_area_kzn2_VineData = 0x8022ADD0; // -b_area_kzn2_VineRenderState = 0x8022B550; // -D_802310D0 = 0x802310D0; // -D_80232C4C = 0x80232C4C; // -D_80235E00 = 0x80235E00; // -D_80236040 = 0x80236040; // -D_802362D0 = 0x802362D0; // -D_80236560 = 0x80236560; // -D_802367F0 = 0x802367F0; // -D_8023BD70 = 0x8023BD70; // -D_8023BD78 = 0x8023BD78; // -D_8023BD98 = 0x8023BD98; // -D_8023BDB4 = 0x8023BDB4; // -D_8023BDB8 = 0x8023BDB8; // -D_8023BDBC = 0x8023BDBC; // -D_8023BDC0 = 0x8023BDC0; // -D_8023BDC4 = 0x8023BDC4; // -D_8023BDC8 = 0x8023BDC8; // -D_8023C070 = 0x8023C070; // -D_8023C1B0 = 0x8023C1B0; // -D_8023C1B4 = 0x8023C1B4; // -D_8023C1B8 = 0x8023C1B8; // -D_8023C1BC = 0x8023C1BC; // -D_8023C1C0 = 0x8023C1C0; // -D_8023C1C4 = 0x8023C1C4; // -D_8023C1C8 = 0x8023C1C8; // -D_8023C1CC = 0x8023C1CC; // -D_8023C1D0 = 0x8023C1D0; // goombarioTattleEffect = 0x8023CDA0; // goombarioIsCharged = 0x8023CDA4; // -D_8023D1E0 = 0x8023D1E0; // -D_8023D1E4 = 0x8023D1E4; // -D_8023D26C = 0x8023D26C; // -D_8023D270 = 0x8023D270; // -D_8023D274 = 0x8023D274; // -D_8023D278 = 0x8023D278; // -D_8023D27C = 0x8023D27C; // -D_8023D280 = 0x8023D280; // -D_8023D284 = 0x8023D284; // -D_8023D288 = 0x8023D288; // -D_8023D28C = 0x8023D28C; // -D_8023D290 = 0x8023D290; // -D_8023D294 = 0x8023D294; // -D_8023D298 = 0x8023D298; // -D_8023D29C = 0x8023D29C; // -D_8023D2A0 = 0x8023D2A0; // -D_8023D2A4 = 0x8023D2A4; // -D_8023D2A8 = 0x8023D2A8; // -D_8023D2AC = 0x8023D2AC; // -D_8023D2B0 = 0x8023D2B0; // -D_8023D2B4 = 0x8023D2B4; // -D_8023D2B8 = 0x8023D2B8; // -D_8023D2BC = 0x8023D2BC; // -D_8023D2C0 = 0x8023D2C0; // -D_8023D2C4 = 0x8023D2C4; // -D_8023D2C8 = 0x8023D2C8; // -D_8023D2D0 = 0x8023D2D0; // -D_8023D330 = 0x8023D330; // -D_8023D334 = 0x8023D334; // -D_8023D338 = 0x8023D338; // -dgb_13_pad_E8 = 0x802400E8; // -dgb_14_pad_F8 = 0x802400F8; // -dgb_17_pad_F8 = 0x802400F8; // -flo_15_pad_11C = 0x8024011C; // -dgb_11_pad_168 = 0x80240168; // -dgb_00_pad_1B8 = 0x802401B8; // -dgb_10_pad_2E8 = 0x802402E8; // -flo_15_pad_2FC = 0x802402FC; // -dgb_13_pad_37C = 0x8024037C; // -arn_09_pad_398 = 0x80240398; // -dgb_12_pad_3A8 = 0x802403A8; // -dgb_06_pad_3B8 = 0x802403B8; // -arn_12_pad_418 = 0x80240418; // -arn_10_pad_424 = 0x80240424; // -arn_13_pad_424 = 0x80240424; // -dgb_14_pad_47C = 0x8024047C; // -arn_09_pad_4CC = 0x802404CC; // -flo_22_pad_518 = 0x80240518; // -dgb_11_pad_56C = 0x8024056C; // -arn_09_pad_5A8 = 0x802405A8; // -dgb_06_Chest_VarStash = 0x80240620; // -dgb_10_pad_66C = 0x8024066C; // -arn_11_pad_674 = 0x80240674; // -sbk_00_pad_78C = 0x8024078C; // -dgb_06_pad_834 = 0x80240834; // -dgb_12_pad_868 = 0x80240868; // -flo_12_pad_86C = 0x8024086C; // -dgb_12_varStash = 0x80240870; // -flo_18_pad_8B8 = 0x802408B8; // -flo_07_pad_8CC = 0x802408CC; // -kmr_03_pad_948 = 0x80240948; // -arn_08_pad_A6C = 0x80240A6C; // -flo_19_pad_ABC = 0x80240ABC; // -flo_19_pad_AF4 = 0x80240AF4; // -arn_08_pad_B98 = 0x80240B98; // -arn_10_pad_BDC = 0x80240BDC; // -arn_08_pad_CB4 = 0x80240CB4; // -flo_24_pad_D38 = 0x80240D38; // -flo_22_pad_E08 = 0x80240E08; // -flo_12_pad_E28 = 0x80240E28; // -flo_18_pad_E88 = 0x80240E88; // -flo_03_pad_EA4 = 0x80240EA4; // -dgb_10_pad_EDC = 0x80240EDC; // -tst_04_B_80240FD0 = 0x80240FD0; // -flo_19_pad_1044 = 0x80241044; // -arn_08_pad_11FC = 0x802411FC; // -flo_07_pad_1214 = 0x80241214; // -arn_02_pad_12C4 = 0x802412C4; // -flo_15_pad_12D8 = 0x802412D8; // -flo_23_pad_12D8 = 0x802412D8; // -dgb_18_pad_1358 = 0x80241358; // -flo_15_pad_135C = 0x8024135C; // -kmr_03_pad_1468 = 0x80241468; // -dgb_16_pad_1518 = 0x80241518; // -dgb_07_pad_1528 = 0x80241528; // -dgb_02_pad_1548 = 0x80241548; // -dgb_05_pad_1578 = 0x80241578; // -dgb_18_pad_1578 = 0x80241578; // -flo_22_pad_1594 = 0x80241594; // -flo_10_pad_1624 = 0x80241624; // -flo_10_pad_167C = 0x8024167C; // -arn_05_pad_16A8 = 0x802416A8; // -flo_00_pad_16BC = 0x802416BC; // -dgb_16_pad_1774 = 0x80241774; // -dgb_16_pad_17B4 = 0x802417B4; // -flo_21_pad_17BC = 0x802417BC; // -dgb_07_pad_17E4 = 0x802417E4; // -dgb_05_pad_17E8 = 0x802417E8; // -arn_08_pad_184C = 0x8024184C; // -dgb_05_pad_1868 = 0x80241868; // -dgb_05_pad_18BC = 0x802418BC; // -dgb_15_pad_19B4 = 0x802419B4; // -flo_19_pad_1A68 = 0x80241A68; // -dgb_02_pad_1AA8 = 0x80241AA8; // -flo_11_pad_1AB8 = 0x80241AB8; // -arn_03_pad_1BB8 = 0x80241BB8; // -arn_03_varStash = 0x80241C68; // -flo_10_pad_1CA8 = 0x80241CA8; // -dgb_07_pad_1E74 = 0x80241E88; // -dgb_15_pad_1E94 = 0x80241E94; // -D_80241ECC = 0x80241ECC; // -flo_09_pad_2004 = 0x80242004; // -D_80242180 = 0x80242180; // -flo_24_pad_21A4 = 0x802421A4; // -D_80242208 = 0x80242208; // -D_80242330 = 0x80242330; // -D_80242344 = 0x80242344; // osr_01_LetterDelivery_SavedNpcAnim = 0x80242344; // -D_80242350 = 0x80242350; // -D_80242370 = 0x80242370; // -D_80242390 = 0x80242390; // -D_802423B0 = 0x802423B0; // -D_802423F0 = 0x802423F0; // -D_80242410 = 0x80242410; // -D_80242430 = 0x80242430; // -D_80242450 = 0x80242450; // -D_802424E0 = 0x802424E0; // flo_23_pad_2598 = 0x80242598; // -flo_23_ItemChoiceList = 0x802426E0; // segment:flo_23 flo_23_D_8024284C_pad = 0x8024284C; // -flo_23_FlowerGuard_ItemChoiceList = 0x80242850; // -flo_09_pad_2874 = 0x80242874; // -dgb_03_pad_2908 = 0x80242908; // -D_802429A4 = 0x802429A4; // -sbk_34_LetterDelivery_SavedNpcAnim = 0x802429A4; // -D_802429BC = 0x802429BC; // -flo_23_D_802429BC = 0x802429BC; // -dead_flo_12_D_802429E0 = 0x802429E0; // -flo_12_D_802429E0 = 0x802429E0; // -D_80242A00 = 0x80242A00; // -D_80242AC4 = 0x80242AC4; // -dgb_15_pad_2AC8 = 0x80242AC8; // -flo_14_pad_2BF4 = 0x80242BF4; // -flo_08_pad_2EA8 = 0x80242EA8; // -D_80242FB0 = 0x80242FB0; // -dgb_03_pad_30D8 = 0x802430D8; // -flo_11_pad_30EC = 0x802430EC; // -D_80243178 = 0x80243178; // -D_80243190 = 0x80243190; // -dgb_04_pad_3208 = 0x80243208; // -flo_10_pad_3218 = 0x80243218; // -D_80243374 = 0x80243374; // -dgb_01_pad_3548 = 0x80243548; // -dgb_04_pad_3558 = 0x80243558; // -arn_04_pad_3654 = 0x80243654; // -dgb_18_pad_36D8 = 0x802436D8; // -flo_16_pad_36FC = 0x802436FC; // -D_80243720 = 0x80243720; // -dgb_03_pad_3738 = 0x80243738; // -dgb_00_pad_3758 = 0x80243758; // -D_80243770 = 0x80243770; // -broken_kmr_04_function_addr = 0x80243770; // -D_802437C0 = 0x802437C0; // -pra_13_802438E8 = 0x802438E8; // -dgb_09_pad_3918 = 0x80243918; // -flo_13_pad_3944 = 0x80243944; // -dgb_03_pad_3964 = 0x80243964; // -flo_13_pad_3A3C = 0x80243A3C; // -dro_02_pad_3BC8 = 0x80243BC8; // -D_80243BE0 = 0x80243BE0; // -dro_02_pad_3C3C = 0x80243C3C; // -flo_25_pad_3C8C = 0x80243C8C; // -flo_25_pad_3CD8 = 0x80243CD8; // -dgb_08_pad_3D88 = 0x80243D88; // -D_80243DA4 = 0x80243DA4; // -obk_03_LetterDelivery_SavedNpcAnim = 0x80243DA4; // -dgb_09_pad_3E4C = 0x80243E4C; // -dgb_01_pad_3EE4 = 0x80243EE4; // -flo_17_pad_3FCC = 0x80243FCC; // -dgb_09_pad_3FF8 = 0x80243FF8; // -arn_04_pad_403C = 0x8024403C; // -flo_10_pad_406C = 0x8024406C; // -flo_10_pad_4084 = 0x80244084; // -D_802440E0 = 0x802440E0; // -D_802440E1 = 0x802440E1; // -D_802440E2 = 0x802440E2; // -D_802440E3 = 0x802440E3; // -D_802440E4 = 0x802440E4; // -D_802440E5 = 0x802440E5; // -D_802440EB = 0x802440EB; // -D_802440EC = 0x802440EC; // -D_802440EF = 0x802440EF; // -D_802440F0 = 0x802440F0; // -D_802440F3 = 0x802440F3; // -D_802440F4 = 0x802440F4; // -D_802440F7 = 0x802440F7; // -D_802440F8 = 0x802440F8; // -D_802440FB = 0x802440FB; // -D_802440FC = 0x802440FC; // -dgb_08_pad_40FC = 0x802440FC; // -D_802440FF = 0x802440FF; // -D_80244100 = 0x80244100; // -D_80244104 = 0x80244104; // -dro_02_pad_41B4 = 0x802441B4; // -dead_03_D_802442D0 = 0x802442D0; // -code_eb1170_bss = 0x802442D0; // -kzn_20_bss = 0x802442D0; // -flo_17_pad_XXX = 0x802443D8; // -dead_03_LetterDelivery_SavedNpcAnim = 0x80244494; // -kzn_20_LetterDelivery_SavedNpcAnim = 0x80244494; // -flo_16_pad_44F8 = 0x802444F8; // -flo_25_pad_4734 = 0x80244734; // -D_802447C0 = 0x802447C0; // -arn_03_pad_47DC = 0x802447DC; // -D_80244A20 = 0x80244A20; // -arn_03_KeyItemChoiceList = 0x80244A20; // -sbk_30_D_80244C18 = 0x80244C18; // -D_80244D88 = 0x80244D88; // -sbk_30_LetterDelivery_SavedNpcAnim = 0x80244D88; // -dro_02_pad_4DD4 = 0x80244DD4; // -kkj_18_D_80244E78 = 0x80244E78; // -flo_03_pad_4ECC = 0x80244ECC; // -flo_14_pad_4F24 = 0x80244F24; // -flo_08_pad_4F3C = 0x80244F3C; // -flo_14_pad_4F64 = 0x80244F64; // -flo_25_ItemChoiceList = 0x80244FA0; // -arn_05_pad_4FF8 = 0x80244FF8; // -flo_25_D_8024510C_pad = 0x8024510C; // -flo_25_FlowerGuard_ItemChoiceList = 0x80245110; // -D_802451F0 = 0x802451F0; // -D_80245210 = 0x80245210; // -D_80245230 = 0x80245230; // -D_8024527C = 0x8024527C; // -flo_17_pad_527C = 0x8024527C; // -flo_25_D_8024527C = 0x8024527C; // -D_802453B0 = 0x802453B0; // -D_802453D8 = 0x802453D8; // -D_80245430 = 0x80245430; // -D_80245600 = 0x80245600; // -D_80245601 = 0x80245601; // -D_80245602 = 0x80245602; // -D_80245603 = 0x80245603; // -D_80245604 = 0x80245604; // -D_80245605 = 0x80245605; // -D_80245608 = 0x80245608; // -D_8024560B = 0x8024560B; // -D_8024560C = 0x8024560C; // -D_8024560F = 0x8024560F; // -D_80245610 = 0x80245610; // -D_80245613 = 0x80245613; // -D_80245614 = 0x80245614; // -D_80245617 = 0x80245617; // -D_80245618 = 0x80245618; // -D_8024561B = 0x8024561B; // -D_8024561C = 0x8024561C; // -D_8024561F = 0x8024561F; // -D_80245620 = 0x80245620; // -D_80245624 = 0x80245624; // -sbk_02_D_80245630 = 0x80245630; // -D_80245650 = 0x80245650; // -D_802458F0 = 0x802458F0; // -D_80245928 = 0x80245928; // -D_8024592C = 0x8024592C; // -flo_08_pad_598C = 0x8024598C; // -D_802459C0 = 0x802459C0; // -D_80245AB4 = 0x80245AB4; // -obk_01_LetterDelivery_SavedNpcAnim = 0x80245AB4; // -flo_00_pad_5E2C = 0x80245E2C; // -kkj_19_D_802461F0 = 0x802461F0; // -hos_06_D_80246260 = 0x80246260; // -flo_08_ItemChoiceList = 0x802462C0; // -dead_flo_08_ItemChoiceList = 0x802462F0; // -D_80246300 = 0x80246300; // -D_802463B8_kkj_19 = 0x802463B8; // -D_80246424 = 0x80246424; // -hos_06_LetterDelivery_SavedNpcAnim = 0x80246424; // -flo_08_D_802462C4_pad = 0x8024642C; // -flo_08_FlowerGuard_ItemChoiceList = 0x80246430; // -dead_flo_08_FlowerGuard_ItemChoiceList = 0x80246460; // -D_80246528 = 0x80246528; // -D_8024652C = 0x8024652C; // -D_80246530 = 0x80246530; // -D_80246534 = 0x80246534; // -D_80246538 = 0x80246538; // -D_80246550 = 0x80246550; // -D_80246554 = 0x80246554; // -D_80246558 = 0x80246558; // -D_80246558_kkj_19 = 0x80246558; // -D_8024655C = 0x8024655C; // -D_80246560 = 0x80246560; // -D_80246568 = 0x80246568; // -D_80246578 = 0x80246578; // -D_80246598 = 0x80246598; // -D_8024659C = 0x8024659C; // -flo_08_D_8024659C = 0x8024659C; // -D_802465A0 = 0x802465A0; // -D_802465CC = 0x802465CC; // -D_802465F0 = 0x802465F0; // -flo_18_pad_66B4 = 0x802466B4; // -dead_kzn_17_D_802466D0 = 0x802466D0; // -D_80246794 = 0x80246794; // -kzn_02_LetterDelivery_SavedNpcAnim = 0x80246794; // -kzn_17_LetterDelivery_SavedNpcAnim = 0x802467B4; // -flo_00_pad_684C = 0x8024684C; // -dead_kzn_17_LetterDelivery_SavedNpcAnim = 0x80246894; // -dgb_08_pad_69DC = 0x802469DC; // -D_80246A20 = 0x80246A20; // -D_80246BE8 = 0x80246BE8; // -D_80246E50 = 0x80246E50; // -D_80247050 = 0x80247050; // -D_80247120 = 0x80247120; // -D_80243390 = 0x80243390; // -D_80247420 = 0x80247420; // -D_80247548 = 0x80247548; // -D_802475E4 = 0x802475E4; // -kzn_03_LetterDelivery_SavedNpcAnim = 0x802475E4; // -D_80247664 = 0x80247664; // -kzn_09_LetterDelivery_SavedNpcAnim = 0x80247664; // -D_80247750 = 0x80247750; // -rodata_alignment = 0x80247938; // -D_802479F0 = 0x802479F0; // -D_80247AF0 = 0x80247AF0; // -D_80247B00 = 0x80247B00; // -flo_13_D_80247B00 = 0x80247B00; // -D_80247BB8 = 0x80247BB8; // -D_80247CA0 = 0x80247CA0; // -D_80247CB4 = 0x80247CB4; // -jan_00_LetterDelivery_SavedNpcAnim = 0x80247CB4; // -D_80247D00 = 0x80247D00; // -flo_13_D_80247D00 = 0x80247D00; // -D_80247DF0 = 0x80247DF0; // -D_80247E68 = 0x80247E68; // -kzn_19_VineRenderState = 0x80248380; // -dead_kzn_19_D_80248388 = 0x80248388; // -kmr_22_ChapterEffect = 0x802483C0; // -kmr_22_ChapterEffectTime = 0x802483C4; // -kmr_22_VineRenderState = 0x802483D0; // -iwa_10_D_80248480 = 0x80248480; // -dead_kzn_19_LetterDelivery_SavedNpcAnim = 0x8024854C; // -kzn_19_LetterDelivery_SavedNpcAnim = 0x8024854C; // -D_80248600 = 0x80248600; // -D_80248624 = 0x80248624; // -D_80248650 = 0x80248650; // -D_80248760 = 0x80248760; // -D_80248850 = 0x80248850; // -jan_02_Quizmo_Worker = 0x80248924; // -jan_02_Quizmo_AnswerResult = 0x80248938; // -jan_02_Quizmo_StageEffect = 0x80248940; // -jan_02_Quizmo_AudienceEffect = 0x80248944; // -jan_02_Quizmo_VannaTEffect = 0x80248948; // -D_80248F90 = 0x80248F90; // -flo_00_pad_9128 = 0x80249128; // -D_80249158 = 0x80249158; // -D_802491C0 = 0x802491C0; // -trd_06_fake_sym = 0x802491C0; // -end_01_CreditsData = 0x80249440; // -D_8024A290 = 0x8024A290; // -D_8024A2A0 = 0x8024A2A0; // -end_01_CreditsMessageBuffers = 0x8024A2D0; // -sam_02_Quizmo_Worker = 0x8024B990; // -sam_02_Quizmo_StageEffect = 0x8024B9B0; // -sam_02_Quizmo_AudienceEffect = 0x8024B9B4; // -sam_02_Quizmo_VannaTEffect = 0x8024B9B8; // -D_8024BA90 = 0x8024BA90; // -flo_13_D_8024BA90 = 0x8024BA90; // -D_8024BB80 = 0x8024BB80; // -hos_03_Quizmo_Worker = 0x8024BDD0; // -hos_03_Quizmo_AnswerResult = 0x8024BDE8; // -hos_03_Quizmo_StageEffect = 0x8024BDF0; // -hos_03_Quizmo_AudienceEffect = 0x8024BDF4; // -hos_03_Quizmo_VannaTEffect = 0x8024BDF8; // -D_8024BEA0 = 0x8024BEA0; // -D_8024C068 = 0x8024C068; // -filemenu_iterFileIdx = 0x8024C080; // -D_8024C088 = 0x8024C088; // -D_8024C100 = 0x8024C100; // -D_8024C110 = 0x8024C110; // -D_8024C1D8 = 0x8024C1D8; // -sam_06_LetterDelivery_SavedNpcAnim = 0x8024C1D8; // -D_8024C5E0 = 0x8024C5E0; // -D_8024DBC0 = 0x8024DBC0; // -D_8024DD88 = 0x8024DD88; // -D_8024DEF8 = 0x8024DEF8; // -sam_01_Quizmo_AnswerResult = 0x8024DF10; // -sam_01_Quizmo_StageEffect = 0x8024DF18; // -sam_01_Quizmo_AudienceEffect = 0x8024DF1C; // -sam_01_Quizmo_VannaTEffect = 0x8024DF20; // -D_8024DF24 = 0x8024DF24; // -sam_01_LetterDelivery_SavedNpcAnim = 0x8024DF24; // -D_8024DFC0 = 0x8024DFC0; // -dro_01_Quizmo_Worker = 0x8024DFC0; // -dro_01_pad_D_8024DFC4 = 0x8024DFC4; // -dro_01_Quizmo_ScriptArray = 0x8024DFC8; // -D_8024DFD8 = 0x8024DFD8; // -dro_01_Quizmo_AnswerResult = 0x8024DFD8; // -dro_01_pad_D_8024DFDC = 0x8024DFDC; // -D_8024DFE0 = 0x8024DFE0; // -dro_01_Quizmo_StageEffect = 0x8024DFE0; // -D_8024DFE4 = 0x8024DFE4; // -dro_01_Quizmo_AudienceEffect = 0x8024DFE4; // -D_8024DFE8 = 0x8024DFE8; // -dro_01_Quizmo_VannaTEffect = 0x8024DFE8; // -dro_01_pad_D_8024DFEC = 0x8024DFEC; // -dro_01_KeyItemChoiceList = 0x8024DFF0; // -dro_01_pad_D_8024E1B0 = 0x8024E1B0; // -D_8024E1B4 = 0x8024E1B4; // -dro_01_LetterDelivery_SavedNpcAnim = 0x8024E1B4; // -mac_02_Quizmo_Worker = 0x8024E540; // -mac_02_Quizmo_AnswerResult = 0x8024E558; // -mac_02_Quizmo_StageEffect = 0x8024E560; // -mac_02_Quizmo_AudienceEffect = 0x8024E564; // -mac_02_Quizmo_VannaTEffect = 0x8024E568; // -mac_02_D_8024E570 = 0x8024E570; // -mac_02_D_8024E738 = 0x8024E738; // -end_00_CreditsData = 0x8024E960; // -D_8024EA10 = 0x8024EA10; // -D_8024EA14 = 0x8024EA14; // -mac_02_LetterDelivery_SavedNpcAnim = 0x8024EA18; // -dro_02_D_8024EF80 = 0x8024EF80; // -gPausePanels = 0x8024EF80; // -D_8024EF84 = 0x8024EF84; // -dro_02_D_8024EF84 = 0x8024EF84; // -dro_02_RitualStateTime = 0x8024EF88; // -dro_02_pad_D_8024EF8C = 0x8024EF8C; // -D_8024EF90 = 0x8024EF90; // -dro_02_D_8024EF90 = 0x8024EF90; // -dro_02_Quizmo_Worker = 0x8024EFA0; // -dro_02_pad_D_8024EF94 = 0x8024EFA0; // -gPauseCursorPosY = 0x8024EFA0; // -dro_02_pad_D_8024EFA4 = 0x8024EFA4; // -dro_02_8024EFA8 = 0x8024EFA8; // -dro_02_Quizmo_ScriptArray = 0x8024EFA8; // -dro_02_pad_D_8024EFAC = 0x8024EFAC; // -D_8024EFB8 = 0x8024EFB8; // -dro_02_Quizmo_AnswerResult = 0x8024EFB8; // -dro_02_pad_D_8024EFBC = 0x8024EFBC; // -D_8024EFC0 = 0x8024EFC0; // -dro_02_Quizmo_StageEffect = 0x8024EFC0; // -dro_02_Quizmo_AudienceEffect = 0x8024EFC4; // -D_8024EFC8 = 0x8024EFC8; // -dro_02_Quizmo_VannaTEffect = 0x8024EFC8; // -D_8024EFCC = 0x8024EFCC; // -dro_02_D_8024EFCC = 0x8024EFCC; // -dro_02_D_8024EFD0 = 0x8024EFD0; // -D_8024F010 = 0x8024F010; // -dro_02_D_8024F010 = 0x8024F010; // -dro_02_pad_D_8024F07C = 0x8024F07C; // -dro_02_D_8024F080 = 0x8024F080; // -dro_02_KeyItemChoiceList = 0x8024F080; // -dro_02_pad_D_8024F240 = 0x8024F240; // -D_8024F248 = 0x8024F248; // -ItemChoiceList = 0x8024F248; // -dro_02_D_8024F248 = 0x8024F248; // -dro_02_ItemChoiceList = 0x8024F248; // -mac_04_Quizmo_Worker = 0x8024F5A0; // -mac_04_Quizmo_AnswerResult = 0x8024F5B8; // -mac_04_Quizmo_StageEffect = 0x8024F5C0; // -mac_04_Quizmo_AudienceEffect = 0x8024F5C4; // -mac_04_Quizmo_VannaTEffect = 0x8024F5C8; // -mac_04_D_8024F5D0 = 0x8024F5D0; // -end_00_CreditsDataPtr = 0x8024F7E4; // -end_00_CreditsMessageBuffers = 0x8024F7F0; // -D_8024FBA0 = 0x8024FBA0; // -D_8024FD68 = 0x8024FD68; // -jan_03_Quizmo_Worker = 0x8024FED8; // -jan_03_Quizmo_AnswerResult = 0x8024FEF0; // -jan_03_Quizmo_StageEffect = 0x8024FEF8; // -jan_03_Quizmo_AudienceEffect = 0x8024FEFC; // -jan_03_Quizmo_VannaTEffect = 0x8024FF00; // -D_8024FF04 = 0x8024FF04; // -jan_03_LetterDelivery_SavedNpcAnim = 0x8024FF04; // -end_00_CreditsProjMatrices = 0x80250EF0; // -D_802510B0 = 0x802510B0; // -mac_03_Quizmo_Worker = 0x802513D0; // -mac_03_Quizmo_AnswerResult = 0x802513E8; // -mac_03_Quizmo_StageEffect = 0x802513F0; // -mac_03_Quizmo_AudienceEffect = 0x802513F4; // -mac_03_Quizmo_VannaTEffect = 0x802513F8; // -mac_03_D_80251400 = 0x80251400; // -sam_11_Quizmo_Worker = 0x80251450; // -sam_11_Quizmo_AnswerResult = 0x80251468; // -sam_11_Quizmo_StageEffect = 0x80251470; // -sam_11_Quizmo_AudienceEffect = 0x80251474; // -sam_11_Quizmo_VannaTEffect = 0x80251478; // -mac_03_LetterDelivery_SavedNpcAnim = 0x802515C4; // -dgb_01_pad_1 = 0x80251A78; // -dgb_01_pad_111111 = 0x80251A78; // -nok_01_Quizmo_Worker = 0x80251C40; // -nok_01_Quizmo_AnswerResult = 0x80251C58; // -nok_01_Quizmo_StageEffect = 0x80251C60; // -nok_01_Quizmo_AudienceEffect = 0x80251C64; // -nok_01_Quizmo_VannaTEffect = 0x80251C68; // -nok_01_D_80251C70 = 0x80251C70; // -D_80251E34 = 0x80251E34; // -nok_01_LetterDelivery_SavedNpcAnim = 0x80251E34; // -mac_05_Quizmo_Worker = 0x802529D0; // -mac_05_Quizmo_AnswerResult = 0x802529E8; // -mac_05_Quizmo_StageEffect = 0x802529F0; // -mac_05_Quizmo_AudienceEffect = 0x802529F4; // -D_802529F8 = 0x802529F8; // -mac_05_Quizmo_VannaTEffect = 0x802529F8; // -mac_05_D_80252A00 = 0x80252A00; // -mac_05_D_80252BC8 = 0x80252BC8; // -mac_05_LetterDelivery_SavedNpcAnim = 0x80252D38; // -D_80253060 = 0x80253060; // -dgb_01_pad_2 = 0x80253158; // -D_80253378 = 0x80253378; // -D_80253384 = 0x80253384; // -D_8025338C = 0x8025338C; // -D_80253390 = 0x80253390; // -nok_02_D_802547D0 = 0x802547D0; // -nok_02_Quizmo_Worker = 0x802549A0; // -nok_02_Quizmo_AnswerResult = 0x802549B8; // -nok_02_Quizmo_StageEffect = 0x802549C0; // -nok_02_Quizmo_AudienceEffect = 0x802549C4; // -nok_02_Quizmo_VannaTEffect = 0x802549C8; // -nok_02_D_802549D0 = 0x802549D0; // -D_80254B94 = 0x80254B94; // -nok_02_LetterDelivery_SavedNpcAnim = 0x80254B94; // -nok_02_D_80254BA0 = 0x80254BA0; // -D_80254C50 = 0x80254C50; // -nok_02_D_80254D68 = 0x80254D68; // -D_8025595C = 0x8025595C; // -D_8025599C = 0x8025599C; // -mac_00_Quizmo_Worker = 0x80255B70; // -mac_00_Quizmo_AnswerResult = 0x80255B88; // -mac_00_Quizmo_StageEffect = 0x80255B90; // -mac_00_Quizmo_AudienceEffect = 0x80255B94; // -mac_00_Quizmo_VannaTEffect = 0x80255B98; // -mac_00_D_80255BA0 = 0x80255BA0; // -mac_00_D_80255D68 = 0x80255D68; // -mac_00_LetterDelivery_SavedNpcAnim = 0x80255ED8; // -D_80255EE0 = 0x80255EE0; // -dup_mac_00_LetterDelivery_SavedNpcAnim = 0x802560A4; // -D_80257118 = 0x80257118; // -D_80257320 = 0x80257320; // -D_80257B28 = 0x80257B28; // -D_80257B48 = 0x80257B48; // -D_80257B68 = 0x80257B68; // -D_80257B88 = 0x80257B88; // -D_80257DA4 = 0x80257DA4; // -kmr_02_savedColR = 0x80257F20; // -kmr_02_savedColG = 0x80257F21; // -kmr_02_savedColB = 0x80257F22; // -kmr_02_savedColA = 0x80257F23; // -D_80257F24 = 0x80257F24; // -D_80257F25 = 0x80257F25; // -D_80257F26 = 0x80257F26; // -D_80257F27 = 0x80257F27; // -D_80257F28 = 0x80257F28; // -D_80257F29 = 0x80257F29; // -kmr_02_Quizmo_Worker = 0x80257F2C; // -kmr_02_Quizmo_AnswerResult = 0x80257F40; // -kmr_02_Quizmo_StageEffect = 0x80257F48; // -kmr_02_Quizmo_AudienceEffect = 0x80257F4C; // -kmr_02_Quizmo_VannaTEffect = 0x80257F50; // -kmr_02_D_80257F58 = 0x80257F58; // -D_8025811C = 0x8025811C; // -kmr_02_LetterDelivery_SavedNpcAnim = 0x8025811C; // -D_80258120 = 0x80258120; // -D_80258140 = 0x80258140; // -D_80258340 = 0x80258340; // -D_80258E14 = 0x80258E14; // -D_8025B0A8 = 0x8025B0A8; // -D_8025B2A8 = 0x8025B2A8; // -D_8025B2AC = 0x8025B2AC; // -D_8025B2B0 = 0x8025B2B0; // -D_8025C0D0 = 0x8025C0D0; // -mac_01_Quizmo_Worker = 0x80262A40; // -mac_01_Quizmo_AnswerResult = 0x80262A58; // -mac_01_Quizmo_StageEffect = 0x80262A60; // -mac_01_Quizmo_AudienceEffect = 0x80262A64; // -mac_01_Quizmo_VannaTEffect = 0x80262A68; // -mac_01_D_80262A70 = 0x80262A70; // -mac_01_LetterDelivery_SavedNpcAnim = 0x80262C34; // D_80262C38 = 0x80262C38; // D_80262F68 = 0x80262F68; // StartRumbleWithParams = 0x80267D9C; // heap_collisionHead = 0x80268000; // -D_8026A2B0 = 0x8026A2B0; // -D_8026F778 = 0x8026F778; // -D_8026FB30 = 0x8026FB30; // -D_8026FBD8 = 0x8026FBD8; // -D_8026FC10 = 0x8026FC10; // -D_8026FC48 = 0x8026FC48; // -D_8026FCB8 = 0x8026FCB8; // -D_8026FCF0 = 0x8026FCF0; // -D_8026FD98 = 0x8026FD98; // -D_8026FE78 = 0x8026FE78; // -D_8026FEE8 = 0x8026FEE8; // -D_8026FF60 = 0x8026FF60; // rodata_padding = 0x8026FF74; // gPauseHeldButtons = 0x802700C0; // -D_802700E4 = 0x802700E4; // -bss = 0x802700E4; // gPauseCommonIconIDs = 0x802700E8; // gPauseShownDescMsg = 0x80270108; // gPauseDescTextMaxPos = 0x8027010C; // @@ -26655,8 +25841,6 @@ gPauseBadgesTargetScrollPos = 0x80270390; // gPauseBadgesTargetScrollIndex = 0x80270394; // gPauseBadgesLevel = 0x80270398; // gPauseBadgesCurrentTab = 0x8027039C; // -gPauseBadgesBShowNotEnoughBP = 0x802703A0; // -gPauseBadgesShowNotEnoughBP = 0x802703A0; // D_802703A4 = 0x802703A4; // gPauseBadgesIconIDs = 0x802703A8; // gPauseItemsItemIDs = 0x80270400; // @@ -26696,10 +25880,7 @@ PauseMapTargetY = 0x80270718; // PauseMapCursorCurrentOption = 0x8027071C; // PauseMapCursorCurrentOptionCopy = 0x80270720; // PauseMapSpacesInSnapRange = 0x80270724; // -D_80280000 = 0x80280000; // -D_80281104 = 0x80281104; // bMarioHideAnims = 0x80283370; // -D_80283770 = 0x80283770; // EVS_ExecuteMarioAction = 0x8028505C; // EVS_ExecutePeachAction = 0x80285174; // EVS_PlayerFirstStrike = 0x802851FC; // @@ -26855,76 +26036,6 @@ D_8029FBC0 = 0x8029FBC0; // D_8029FBD0 = 0x8029FBD0; // ApplyingBuff = 0x8029FBD4; // gActionCommandStatus = 0x8029FBE0; // -D_802A19B0 = 0x802A19B0; // -D_802A1A60 = 0x802A1A60; // -battle_item_coconut_coconutDL = 0x802A1A60; // -itemIcon = 0x802A2410; // -func_802A91F8 = 0x802A91F8; // -func_802A9208 = 0x802A9208; // -func_802A9228 = 0x802A9228; // -func_802A9234 = 0x802A9234; // -func_802A9254 = 0x802A9254; // -func_802A9278 = 0x802A9278; // -func_802A928C = 0x802A928C; // -func_802A9294 = 0x802A9294; // -func_802A9298 = 0x802A9298; // -func_802A92A0 = 0x802A92A0; // -func_802A92D4 = 0x802A92D4; // -func_802A92DC = 0x802A92DC; // -func_802A92F0 = 0x802A92F0; // -func_802A9310 = 0x802A9310; // -func_802A936C = 0x802A936C; // -func_802A9378 = 0x802A9378; // -func_802A948C = 0x802A948C; // -func_802A94A4 = 0x802A94A4; // -func_802A94D8 = 0x802A94D8; // -func_802A9544 = 0x802A9544; // -func_802A955C = 0x802A955C; // -func_802A9590 = 0x802A9590; // -func_802A959C = 0x802A959C; // -D_802A9620 = 0x802A9620; // -func_802A9634 = 0x802A9634; // -func_802A963C = 0x802A963C; // -func_802A9664 = 0x802A9664; // -func_802A96B8 = 0x802A96B8; // -func_802A96DC = 0x802A96DC; // -func_802A96EC = 0x802A96EC; // -func_802A96F4 = 0x802A96F4; // -func_802A9708 = 0x802A9708; // -func_802A9718 = 0x802A9718; // -func_802A9720 = 0x802A9720; // -func_802A973C = 0x802A973C; // -func_802A9744 = 0x802A9744; // -func_802A9764 = 0x802A9764; // -func_802A97AC = 0x802A97AC; // -func_802A97BC = 0x802A97BC; // -func_802A97CC = 0x802A97CC; // -func_802A97F8 = 0x802A97F8; // -func_802A97FC = 0x802A97FC; // -func_802A9810 = 0x802A9810; // -func_802A981C = 0x802A981C; // -func_802A9834 = 0x802A9834; // -func_802A984C = 0x802A984C; // -func_802A9894 = 0x802A9894; // -func_802A9898 = 0x802A9898; // -D_802A98C0 = 0x802A98C0; // -func_802A98D0 = 0x802A98D0; // -func_802A98DC = 0x802A98DC; // -func_802A98E0 = 0x802A98E0; // -func_802A9914 = 0x802A9914; // -D_802A9920 = 0x802A9920; // -func_802A992C = 0x802A992C; // -func_802A9990 = 0x802A9990; // -func_802A99D4 = 0x802A99D4; // -func_802A9A30 = 0x802A9A30; // -func_802A9A54 = 0x802A9A54; // -D_802A9B00 = 0x802A9B00; // -func_802AA014 = 0x802AA014; // -func_802AA0D8 = 0x802AA0D8; // -D_802AB513 = 0x802AB513; // -padding2 = 0x802ACC04; // -D_802ACC38 = 0x802ACC38; // -D_802ACC60 = 0x802ACC60; // BattleMenu_TargetPointerAlpha = 0x802ACC64; // BattleMenu_TargetNameOffsetX = 0x802ACC68; // BattleMenu_SwapDelay = 0x802ACC6C; // @@ -27044,43 +26155,17 @@ Munchlesia_LaunchVelocity = 0x802B62D0; // Munchlesia_LateralVelocity = 0x802B62D4; // Munchlesia_LaunchAccel = 0x802B62D8; // Munchlesia_LaunchYaw = 0x802B62DC; // -D_802B62E0 = 0x802B62E0; // -D_802B6790 = 0x802B6790; // -D_802B6794 = 0x802B6794; // -D_802B6798 = 0x802B6798; // -D_802B679C = 0x802B679C; // ParasolTransformation = 0x802B6E80; // SpinningFlower_EntityIndex = 0x802B6ED0; // -D_802B6ED4 = 0x802B6ED4; // -D_802B6ED8 = 0x802B6ED8; // -D_802B6EDC = 0x802B6EDC; // -D_802B6EE0 = 0x802B6EE0; // -D_802B6EE4 = 0x802B6EE4; // -D_802B6EE8 = 0x802B6EE8; // SpinningFlower_AngleToCenter = 0x802B6EEC; // -D_802B6EF0 = 0x802B6EF0; // -D_802B6EF4 = 0x802B6EF4; // -D_802B7140 = 0x802B7140; // -func_802B71E8 = 0x802B71E8; // mdl_clearRenderTasks = 0x802B7E00; // -D_802BCE20 = 0x802BCE20; // -D_802BCE30 = 0x802BCE30; // -D_802BCE32 = 0x802BCE32; // -D_802BCE34 = 0x802BCE34; // GoompaTweesterPhysics = 0x802BD600; // -goompa_802BD600 = 0x802BD600; // world_goombario_HadSpeechPrompt = 0x802BDF30; // -func_802BE070 = 0x802BE070; // world_bow_IsHiding = 0x802BE0C0; // world_watt_D_802BE300 = 0x802BE300; // world_parakarry_UsingAbility = 0x802BEBB0; // -D_802BEBC0 = 0x802BEBC0; // world_kooper_ShellTossHoldTime = 0x802BEC50; // world_sushie_WaterSurfaceY = 0x802BFEE0; // -D_802BFEF0 = 0x802BFEF0; // -D_802BFEFC = 0x802BFEFC; // -D_802BFF30 = 0x802BFF30; // -D_802D9D80 = 0x802D9D80; // gMapFlags = 0x802DA480; // gMapVars = 0x802DA484; // gNumScripts = 0x802DA488; // @@ -27098,11 +26183,7 @@ gWorldMeshAnimationList = 0x802DADF0; // size:0x40 gCurrentMeshAnimationListPtr = 0x802DAE30; // wExtraPartnerID = 0x802DAE40; // wExtraPartnerNpcID = 0x802DAE44; // -D_802DAE50 = 0x802DAE50; // -D_802DAE54 = 0x802DAE54; // gCurrentPrintContext = 0x802DB260; // -D_802DB264 = 0x802DB264; // -D_802DB268 = 0x802DB268; // PlayerImgFXFlags = 0x802DB5B0; // bBattleVirtualEntityList = 0x802DB5C0; // wWorldVirtualEntityList = 0x802DB6C0; // @@ -27202,80 +26283,14 @@ heap_spriteHead = 0x8034F800; // gFrameBuf0 = 0x8038F800; // gFrameBuf1 = 0x803B5000; // gFrameBuf2 = 0x803DA800; // -heap_battleHead = 0x803DA800; // -D_A0000000 = 0xA0000000; // -D_A4000000 = 0xA4000000; // -D_A4000768 = 0xA4000768; // -D_A4001000 = 0xA4001000; // -D_A4040010 = 0xA4040010; // -D_A4300000 = 0xA4300000; // -D_A4300004 = 0xA4300004; // -D_A4300008 = 0xA4300008; // -D_A430000C = 0xA430000C; // -D_A4400010 = 0xA4400010; // -D_A4500004 = 0xA4500004; // -D_A450000C = 0xA450000C; // -D_A4600004 = 0xA4600004; // -D_A460000C = 0xA460000C; // -D_A4600010 = 0xA4600010; // -D_A4700000 = 0xA4700000; // -D_A4700010 = 0xA4700010; // -D_A4800018 = 0xA4800018; // -D_A6000000 = 0xA6000000; // -D_B0000000 = 0xB0000000; // -D_B0000008 = 0xB0000008; // -D_B0000010 = 0xB0000010; // -D_E0002760 = 0xE0002760; // -D_E0002788 = 0xE0002788; // -D_E00027B0 = 0xE00027B0; // sPartScales = 0xE00027B0; // -D_E00027D8 = 0xE00027D8; // sPartYaws = 0xE00027D8; // -D_E0002800 = 0xE0002800; // sDlists = 0xE0002800; // -D_E000CC10 = 0xE000CC10; // sDlists2 = 0xE000CC24; // -D_E000CC38 = 0xE000CC38; // -D_E000CC48 = 0xE000CC48; // -D_E000CC5C = 0xE000CC5C; // -D_E000CCE0 = 0xE000CCE0; // -D_E000CD24 = 0xE000CD24; // -jtbl_E000CD70 = 0xE000CD70; // -dead_atan2 = 0x8002AF70; // type:func dead:yes -dead_cos_rad = 0x8002B4C0; // type:func dead:yes -dead_heap_free = 0x8002C01C; // dead:yes -dead_guMtxIdentF = 0x8006C660; // dead:yes -dead_guMtxCatF = 0x8006C7C0; // dead:yes -dead_playFX_11 = 0x80075170; // type:func dead:yes -dead_gGameStatusPtr = 0x80079430; // dead:yes -dead_gCurrentCameraID = 0x8007C760; // dead:yes -dead_gItemTable = 0x8008D2C0; // dead:true -dead_gItemTable = 0x8008D2C0; // dead:yes -dead_gPartnerPopupProperties = 0x80094900; // dead:yes -dead_gCurrentCamID = 0x800A158C; // dead:yes -dead_gOverrideFlags = 0x800A15A8; // dead:yes -dead_gCurrentEncounter = 0x800B7EF0; // dead:yes -dead_gCameras = 0x800B8D80; // dead:yes -dead_gPlayerStatusPtr = 0x800FFC90; // dead:yes -dead_wPartnerHudScripts = 0x80100060; // dead:yes -dead_wDisabledPartnerHudScripts = 0x801000A0; // dead:yes -dead_80117163 = 0x80117160; // dead:yes -dead_gPartnerStatus = 0x80117160; // dead:yes -dead_gPlayerStatus = 0x80117578; // dead:yes -dead_gPlayerData = 0x80117840; // dead:yes -dead_gCollisionStatus = 0x80169B10; // dead:yes -dead_evt_get_variable = 0x802D4E8C; // type:func dead:yes -dead_evt_set_variable = 0x802D5468; // type:func dead:yes -dead_evt_get_float_variable = 0x802D57FC; // type:func dead:yes -dead_evt_set_float_variable = 0x802D5A10; // type:func dead:yes -battle_partner_vram_start = 0x80238000; // appears_after_overlays_addr:0x80218000 -battle_code_vram_start = 0x8023E000; // appears_after_overlays_addr:0x80238000 -world_model_data_vram_end = 0x80240000; // appears_after_overlays_addr:0x80234000 -map_vram_end = 0x80267FF0; // appears_after_overlays_addr:0x80240000 -//world_action_vram_end = 0x802B7000; // appears_after_overlays_addr:0x802B6000 -world_misc_vram_end = 0x802B7E00; // appears_after_overlays_addr:0x802B7000 -//entity_data_vram_end = 0x802BD100; // appears_after_overlays_addr:0x802BAE00 -world_partner_vram_end = 0x802C3000; // appears_after_overlays_addr:0x802BD100 + +////world_action_vram_end = 0x802B7000; // appears_after_overlays_addr:0x802B6000 +////entity_data_vram_end = 0x802BD100; // appears_after_overlays_addr:0x802BAE00 + battle_move_hammer_throw_dusty_hammer_png = 0x802A3048; // rom:0x754498 battle_move_hammer_throw_dusty_hammer_pal = 0x802A3248; // rom:0x754698 battle_move_hammer_throw_basic_hammer_png = 0x802A3268; // rom:0x7546B8 diff --git a/ver/us/undefined_syms.txt b/ver/us/undefined_syms.txt index c6567f052e..f3dc2d1364 100644 --- a/ver/us/undefined_syms.txt +++ b/ver/us/undefined_syms.txt @@ -10,86 +10,6 @@ fx_sun_undeclared = fx_sun; sprite_shading_profiles_data_ROM_START = sprite_shading_profiles_ROM_START + 0x1D0; -battle_move_end = mushroom_VRAM_END; -battle_move_end = MAX(battle_move_end, fire_flower_VRAM_END); -battle_move_end = MAX(battle_move_end, dusty_hammer_VRAM_END); -battle_move_end = MAX(battle_move_end, pow_block_VRAM_END); -battle_move_end = MAX(battle_move_end, pebble_VRAM_END); -battle_move_end = MAX(battle_move_end, volt_shroom_VRAM_END); -battle_move_end = MAX(battle_move_end, thunder_rage_VRAM_END); -battle_move_end = MAX(battle_move_end, snowman_doll_VRAM_END); -battle_move_end = MAX(battle_move_end, dried_shroom_VRAM_END); -battle_move_end = MAX(battle_move_end, shooting_star_VRAM_END); -battle_move_end = MAX(battle_move_end, sleepy_sheep_VRAM_END); -battle_move_end = MAX(battle_move_end, stone_cap_VRAM_END); -battle_move_end = MAX(battle_move_end, tasty_tonic_VRAM_END); -battle_move_end = MAX(battle_move_end, thunder_bolt_VRAM_END); -battle_move_end = MAX(battle_move_end, ultra_shroom_VRAM_END); -battle_move_end = MAX(battle_move_end, unknown_item_VRAM_END); -battle_move_end = MAX(battle_move_end, super_soda_VRAM_END); -battle_move_end = MAX(battle_move_end, hustle_drink_VRAM_END); -battle_move_end = MAX(battle_move_end, stop_watch_VRAM_END); -battle_move_end = MAX(battle_move_end, dizzy_dial_VRAM_END); -battle_move_end = MAX(battle_move_end, please_come_back_VRAM_END); -battle_move_end = MAX(battle_move_end, egg_missile_VRAM_END); -battle_move_end = MAX(battle_move_end, insecticide_herb_VRAM_END); -battle_move_end = MAX(battle_move_end, fright_jar_VRAM_END); -battle_move_end = MAX(battle_move_end, mystery_VRAM_END); -battle_move_end = MAX(battle_move_end, repel_gel_VRAM_END); -battle_move_end = MAX(battle_move_end, life_shroom_VRAM_END); -battle_move_end = MAX(battle_move_end, coconut_VRAM_END); -battle_move_end = MAX(battle_move_end, electro_pop_VRAM_END); -battle_move_end = MAX(battle_move_end, strange_cake_VRAM_END); -battle_move_end = MAX(battle_move_end, food_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_hammer_attack_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_spin_smash_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_quake_hammer_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_jump_attack_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_multibounce_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_power_bounce_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_sleep_stomp_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_dizzy_stomp_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_d_down_pound_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_jump_charge_0_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_hammer_charge_0_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_hammer_throw_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_mega_quake_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_hammer_charge_1_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_jump_charge_1_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_hammer_charge_2_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_jump_charge_2_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_auto_smash_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_auto_jump_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_power_quake_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_auto_multibounce_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_power_jump_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_super_jump_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_mega_jump_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_power_smash_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_super_smash_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_mega_smash_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_demo_power_bounce_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_shrink_smash_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_shell_crack_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_d_down_jump_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_shrink_stomp_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_earthquake_jump_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_focus_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_refresh_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_lullaby_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_star_storm_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_chill_out_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_smooch_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_time_out_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_up_and_away_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_star_beam_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_peach_beam_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_peach_focus_VRAM_END); -battle_move_end = MAX(battle_move_end, battle_move_peach_focus_alt_VRAM_END); - -world_battle_vram_end = battle_code_VRAM_END; -world_battle_vram_end = MAX(world_battle_vram_end, world_script_api_VRAM_END); - // boot D_A0000000 = 0xA0000000; D_A4000000 = 0xA4000000;