diff --git a/Jenkinsfile b/Jenkinsfile
index d20794aab0..c4fa0d4a5a 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -13,6 +13,7 @@ pipeline {
                 sh 'curl -L "https://github.com/ethteck/ido-static-recomp/releases/download/per-function/ido-5.3-recomp-ubuntu-latest.tar.gz" | tar zx -C tools/build/cc/ido5.3'
                 sh 'curl -L "https://github.com/decompals/mips-gcc-2.7.2/releases/download/main/gcc-2.7.2-linux.tar.gz" | tar zx -C tools/build/cc/gcc2.7.2'
                 sh 'curl -L "https://github.com/decompals/mips-binutils-2.6/releases/download/main/binutils-2.6-linux.tar.gz" | tar zx -C tools/build/cc/gcc2.7.2'
+                sh 'pip install -r requirements.txt'
                 sh './configure'
             }
         }
diff --git a/include/common_structs.h b/include/common_structs.h
index ed080a1795..536d79cfd6 100644
--- a/include/common_structs.h
+++ b/include/common_structs.h
@@ -2439,4 +2439,20 @@ typedef struct FoldImageRecPart {
     /* 0x11 */ char unk_11[0x7];
 } FoldImageRecPart; // size = 0x18
 
+typedef struct FoldImageRec {
+    /* 0x00 */ s8* raster;
+    /* 0x04 */ s8* palette;
+    /* 0x08 */ u16 width;
+    /* 0x0A */ u16 height;
+    /* 0x0C */ s16 xOffset;
+    /* 0x0E */ s16 yOffset;
+    /* 0x10 */ u8 unk_10;
+    /* 0x11 */ char unk_11[0x7];
+    /* 0x18 */ s16 unk_18;
+    /* 0x1A */ char unk_1A[0x4];
+    /* 0x1E */ s16 unk_1E;
+    /* 0x20 */ char unk_20[0x4];
+    /* 0x24 */ u8 alphaMultiplier;
+} FoldImageRec; // size = 0x25
+
 #endif
diff --git a/include/effects.h b/include/effects.h
index 235c63d0fe..b46e57a8b6 100644
--- a/include/effects.h
+++ b/include/effects.h
@@ -434,6 +434,11 @@ typedef struct AttackResultTextFXData {
     /* 0x34 */ f32 unk_34;
 } AttackResultTextFXData; // size = 0x38
 
+typedef struct GotItemOutlineFXData {
+    /* 0x00 */ char unk_00[0x14];
+    /* 0x14 */ s32 unk_14;
+} GotItemOutlineFXData; // size = ???
+
 typedef struct SmallGoldSparkleFXData {
     /* 0x00 */ s32 unk_00;
     /* 0x04 */ s32 unk_04;
diff --git a/include/functions.h b/include/functions.h
index bd433f1b91..d95337f00c 100644
--- a/include/functions.h
+++ b/include/functions.h
@@ -786,6 +786,7 @@ void entity_base_block_init(Entity* entity);
 s32 entity_start_script(Entity* entity);
 void remove_item_entity_by_index(s32 index);
 void set_entity_commandlist(Entity* entity, s32* entityScript);
+s32 func_800DFCF4(void);
 void func_800EF3E4(void);
 void func_80268858(void);
 void func_80269118(void);
diff --git a/requirements.txt b/requirements.txt
index b9513eb927..a9f8f934af 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,3 +7,7 @@ ninja_syntax
 msgpack
 pylibyaml
 tqdm
+spimdisasm
+pygfxd
+intervaltree
+rabbitizer
diff --git a/src/3169f0.c b/src/3169f0.c
index 6724b87043..223980b159 100644
--- a/src/3169f0.c
+++ b/src/3169f0.c
@@ -1,15 +1,15 @@
 #include "common.h"
 
-extern void(*D_8004AA85)(void);
+extern void(*obfuscated_create_audio_system)(void);
 
 void func_80200000(void) {
     u32 t0 = 0xAC29007B;
     u32 t1 = 0xB00006A8;
-    void(*create_audio_subsystem)(void) = &D_8004AA85;
+    void(*create_audio_system)(void) = &obfuscated_create_audio_system;
 
     while (IO_READ(PI_STATUS_REG) & 3);
 
     t0 -= IO_READ(t1 - 0x1C8);
-    create_audio_subsystem += t0;
-    create_audio_subsystem();
+    create_audio_system += t0;
+    create_audio_system();
 }
diff --git a/src/316C00.c b/src/316C00.c
index c3a9a9a11f..6aa1eb3b58 100644
--- a/src/316C00.c
+++ b/src/316C00.c
@@ -3,12 +3,12 @@
 #include "ld_addrs.h"
 #include "mips.h"
 
-extern s32 D_7012BC11[];
+extern s32 obfuscated_general_heap_create[];
 
 void func_802AE000_316C00(void) {
     s32(*readFunc)(OSPiHandle*, u32, u32*) = osEPiReadIo;
     s32 seed = 0x3C016C07 + 0xFEFEFEF;
-    HeapNode*(*generalHeapCreate)(void) = D_7012BC11; // general_heap_create - 0xFEFEFEF
+    HeapNode*(*generalHeapCreate)(void) = obfuscated_general_heap_create; // general_heap_create - 0xFEFEFEF
     u32 hash = 0;
     u32 thisInsn;
     u32* it;
diff --git a/src/316a70.c b/src/316a70.c
index d6e847d533..f030fafd66 100644
--- a/src/316a70.c
+++ b/src/316a70.c
@@ -2,12 +2,12 @@
 #include "ld_addrs.h"
 #include "mips.h"
 
-extern s32 D_80026AC7[];
+extern s32 obfuscated_load_engine_data[];
 
 void func_80200080(void) {
     s32 seed = 0x3C01A775;
     u32 thisInsn = 0xB0018FFC;
-    HeapNode*(*load_engine_data)(s32) = D_80026AC7; // load_engine_data - ????????
+    HeapNode*(*load_engine_data)(s32) = obfuscated_load_engine_data; // load_engine_data - ????????
     s32 hash = 0;
     u32 prevInsn;
     u32* it;
diff --git a/src/316d90.c b/src/316d90.c
index 8f818de954..7ba7cf69a5 100644
--- a/src/316d90.c
+++ b/src/316d90.c
@@ -3,12 +3,12 @@
 #include "ld_addrs.h"
 #include "mips.h"
 
-extern s32 D_7012ACA1[];
+extern s32 obfuscated_battle_heap_create[];
 
 void func_802AE000(void) {
     s32(*readFunc)(OSPiHandle*, u32, u32*) = osEPiReadIo;
     s32 seed = 0x33F50000;
-    UNK_FUN_PTR(battle_heap_create) = D_7012ACA1;
+    UNK_FUN_PTR(battle_heap_create) = obfuscated_battle_heap_create;
     u32 hash = 0;
     u32 thisInsn;
     u32* it;
diff --git a/src/8560.c b/src/8560.c
index 755771a436..d65d71c974 100644
--- a/src/8560.c
+++ b/src/8560.c
@@ -1,3 +1,75 @@
 #include "common.h"
+#include "nu/nusys.h"
+#include "ld_addrs.h"
+#include "mips.h"
 
-INCLUDE_ASM(s32, "8560", func_8002D160);
+extern s8 D_F79DDD0F[];
+extern s8 D_7599F6D8[];
+
+void func_8002D160(void) {
+    s32 (*readFunc)(OSPiHandle*, u32, u32*);
+    s32 (*readFunc2)(OSPiHandle*, u32, u32*);
+    s8* vramDest = D_7599F6D8;
+    s8* romStart = D_F79DDD0F;
+    s32 seed;
+    u32 hash;
+    u32 thisInsn;
+    u32 thisInsn2;
+    u32 prevInsn;
+    u8* it;
+
+    // vramDest
+    readFunc = osEPiReadIo;
+    seed = 0x0B112D28;
+    hash = 0;
+    readFunc(nuPiCartHandle, 0xB0000D10, &thisInsn);
+    seed -= thisInsn;
+    prevInsn = 0;
+
+    for (it = _316D90_ROM_START; it < _316D90_ROM_END; it += 4) {
+        readFunc(nuPiCartHandle, (u32)it, &thisInsn);
+        hash += LOWER(thisInsn) + UPPER(thisInsn);
+
+        if (OPCODE(prevInsn) == LUI && (OPCODE(thisInsn) == ADDIU || OPCODE(thisInsn) == LW)) {
+            if (GET_RS(thisInsn) == GET_RT(prevInsn) && GET_RS(thisInsn) == GET_RT(thisInsn)) {
+                hash -= LOWER(thisInsn);
+                hash -= LOWER(prevInsn);
+            }
+        }
+
+        if (OPCODE(thisInsn) == JAL) {
+            hash -= LOWER(thisInsn) + (UPPER(thisInsn) & 0xFC00);
+        }
+
+        prevInsn = thisInsn;
+    }
+    vramDest += seed + 0x2A4EB6 - hash;
+
+    // romStart
+    readFunc2 = osEPiReadIo;
+    seed = 0x18F414AB;
+    hash = 0;
+    readFunc2(nuPiCartHandle, 0xB0000E38, &thisInsn2);
+    seed -= thisInsn2;
+    prevInsn = 0;
+
+    for (it = _316F30_ROM_START; it < _316F30_ROM_END; it += 4) {
+        readFunc2(nuPiCartHandle, (u32)it, &thisInsn2);
+        hash += LOWER(thisInsn2) + UPPER(thisInsn2);
+
+        if (OPCODE(prevInsn) == LUI && (OPCODE(thisInsn2) == ADDIU || OPCODE(thisInsn2) == LW)) {
+            if (GET_RS(thisInsn2) == GET_RT(prevInsn) && GET_RS(thisInsn2) == GET_RT(thisInsn2)) {
+                hash -= LOWER(thisInsn2);
+                hash -= LOWER(prevInsn);
+            }
+        }
+
+        if (OPCODE(thisInsn2) == JAL) {
+            hash -= LOWER(thisInsn2) + (UPPER(thisInsn2) & 0xFC00);
+        }
+        prevInsn = thisInsn2;
+    }
+    romStart += seed + 0xED41C - hash;
+
+    dma_copy(romStart, _316F30_ROM_END, vramDest);
+}
diff --git a/src/C50A0.c b/src/C50A0.c
index a10ea8cd63..224f6788c6 100644
--- a/src/C50A0.c
+++ b/src/C50A0.c
@@ -1,27 +1,37 @@
 #include "common.h"
 #include "effects.h"
 #include "hud_element.h"
+#include "pause/pause_common.h"
+#include "world/partners.h"
 #include "sparkle_script.h"
 
 #define MAX_ITEM_ENTITIES 256
 
+extern SparkleScript SparkleScript_Coin;
+
+extern Lights1 D_8014C6C8;
+
 extern s32 ItemEntitiesCreated;
+extern s32 D_80155D80;
 extern s32 ItemEntityAlternatingSpawn;
 extern s32 ItemEntityRenderGroup;
+extern s16 D_80155D8C;
+extern s16 D_80155D8E;
+extern s16 D_80155D90;
 extern ItemEntity* WorldItemEntities[MAX_ITEM_ENTITIES];
 extern ItemEntity* BattleItemEntities[MAX_ITEM_ENTITIES];
 extern ItemEntity** gCurrentItemEntities;
 extern s16 isPickingUpItem;
-extern s32 D_80155D80;
-extern s16 D_80155D8C;
-extern s16 D_80155D8E;
-extern s16 D_80155D90;
 extern s16 D_801565A6;
 extern s16 D_801565A8;
+extern PopupMenu D_801565B0;
 extern s32 D_801568E0;
+extern s32 D_801568E4;
+extern s32 D_801568E8;
 extern s32 D_801568EC;
-
-extern SparkleScript SparkleScript_Coin;
+extern EffectInstance* D_801568F0;
+extern MessagePrintState* D_801568F4;
+extern s32 D_801568F8;
 
 void item_entity_load(ItemEntity*);
 void item_entity_update(ItemEntity*);
@@ -239,7 +249,6 @@ void draw_coin_sparkles(ItemEntity* itemEntity) {
 
     gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
     gDPPipeSync(gMasterGfxPos++);
-
 }
 
 ItemEntity* get_item_entity(s32 itemEntityIndex) {
@@ -884,7 +893,151 @@ void func_80133A94(s32 idx, s32 itemID) {
     item_entity_load(item);
 }
 
+// float/stack crap
+#ifdef NON_EQUIVALENT
+s32 test_item_player_collision(ItemEntity* item) {
+    PlayerStatus* playerStatus = &gPlayerStatus;
+    PartnerActionStatus* partnerActionStatus = &gPartnerActionStatus;
+    EncounterStatus* encounterStatus = &gCurrentEncounter;
+    Camera* camera = &gCameras[gCurrentCameraID];
+    s32 actionState;
+    f32 t;
+    f32 itemX;
+    f32 itemY;
+    f32 itemZ;
+    f32 playerX;
+    f32 playerY;
+    f32 playerZ;
+
+    f32 sp10;
+    f32 sp14;
+    f32 sp1C;
+    f32 sp20;
+    f32 sp24;
+    f32 zDiff;
+    f32 temp_f14;
+    f32 xDiff;
+    f32 angle;
+    s32 cond;
+    f32 f1;
+
+
+    actionState = playerStatus->actionState;
+
+    if (item->flags & 0x100) {
+        item->flags &= ~0x100;
+        return TRUE;
+    }
+
+    if (gGameState != 2 && gGameState != 0) {
+        return FALSE;
+    }
+
+    if (encounterStatus->hitType == 5) {
+        return FALSE;
+    }
+
+    if (item->flags & 0x200000) {
+        return FALSE;
+    }
+
+    if (isPickingUpItem) {
+        return FALSE;
+    }
+
+    if (item->flags & 0x40) {
+        return FALSE;
+    }
+
+    if (get_time_freeze_mode() != 0) {
+        return FALSE;
+    }
+
+    if (partnerActionStatus->partnerActionState != 0 && partnerActionStatus->actingPartner == 9) {
+        return FALSE;
+    }
+
+    if ((actionState == 0x1D || actionState == 0x1E || actionState == 0x1F) && item->itemID != ITEM_COIN) {
+        return FALSE;
+    }
+
+    if (gOverrideFlags & 0x200000) {
+        return FALSE;
+    }
+
+    cond = FALSE;
+    sp1C = playerStatus->colliderHeight / 2;
+    playerX = playerStatus->position.x;
+    playerY = playerStatus->position.y;
+    playerZ = playerStatus->position.z;
+
+    sp20 = playerStatus->colliderDiameter / 4;
+    if (playerStatus->spriteFacingAngle < 180.0f) {
+        temp_f14 = clamp_angle(camera->currentYaw - 90.0f);
+    } else {
+        temp_f14 = clamp_angle(camera->currentYaw + 90.0f);
+    }
+    sp10 = playerX;
+    sp24 = playerY;
+    sp14 = playerZ;
+    if (get_clamped_angle_diff(camera->currentYaw, temp_f14) < 0.0f) {
+        angle = clamp_angle(camera->currentYaw - 90.0f);
+        if (playerStatus->trueAnimation & 0x01000000) {
+            angle = clamp_angle(angle + 30.0f);
+        }
+    } else {
+        angle = clamp_angle(camera->currentYaw + 90.0f);
+        if (playerStatus->trueAnimation & 0x01000000) {
+            angle = clamp_angle(angle - 30.0f);
+        }
+    }
+    add_vec2D_polar(&sp10, &sp14, 24.0f, angle);
+    itemX = item->position.x;
+    itemY = item->position.y;
+    itemZ = item->position.z;
+    t = 13.5f;
+    xDiff = itemX - playerX;
+    zDiff = itemZ - playerZ;
+    f1 = sqrtf(SQ(xDiff) + SQ(zDiff));
+    if (!(sp20 + t <= f1) &&
+        !(itemY + 27.0f < playerY) &&
+        !(playerY + sp1C < itemY))
+    {
+        cond = TRUE;
+    }
+
+    if (playerStatus->actionState == 0x12 && (playerStatus->flags & 0x01000000)) {
+        xDiff = itemX - sp10;
+        zDiff = itemZ - sp14;
+        f1 = sqrtf(SQ(xDiff) + SQ(zDiff));
+        if (!(14.0f + t <= f1) &&
+            !(itemY + 27.0f < sp24) &&
+            !(sp24 + 18.0f < itemY))
+        {
+            cond = TRUE;
+        }
+    }
+
+    if (cond) {
+        if (item->flags & 0x80) {
+            if (D_801565A6 != 0) {
+                D_801565A6--;
+                return FALSE;
+            } else {
+                item->flags &= ~0x80;
+            }
+        }
+        return TRUE;
+    }
+
+    if (item->flags & 0x80) {
+        item->flags &= ~0x80;
+    }
+    return FALSE;
+}
+#else
 INCLUDE_ASM(s32, "C50A0", test_item_player_collision);
+#endif
 
 s32 test_item_entity_position(f32 x, f32 y, f32 z, f32 dist) {
     ItemEntity* item;
diff --git a/src/battle/area_omo2_2/actor/stilt_guy.c b/src/battle/area_omo2_2/actor/stilt_guy.c
index 73adc28e82..736e1db36f 100644
--- a/src/battle/area_omo2_2/actor/stilt_guy.c
+++ b/src/battle/area_omo2_2/actor/stilt_guy.c
@@ -10,7 +10,7 @@
 
 #include "common/GetSelectedMoveID.inc.c"
 
-ApiStatus SetActorLevelToZero(Evt* script, s32 isInitialCall) {
+ApiStatus N(SetActorLevelToZero)(Evt* script, s32 isInitialCall) {
     get_actor(script->owner1.actorID)->actorBlueprint->level = 0;
     return ApiStatus_DONE2;
 }
@@ -798,7 +798,7 @@ EvtScript N(fallOff) = {
     EVT_CALL(ResetAllActorSounds, ACTOR_SELF)
     EVT_CALL(GetActorSize, ACTOR_SELF, LW(0), LW(1))
     EVT_CALL(SetActorSize, ACTOR_SELF, 24, LW(1))
-    EVT_CALL(SetActorLevelToZero)
+    EVT_CALL(N(SetActorLevelToZero))
     EVT_RETURN
     EVT_END
 };
diff --git a/src/d0a70_len_4fe0.c b/src/d0a70_len_4fe0.c
index 5bf0917399..360bae3ec8 100644
--- a/src/d0a70_len_4fe0.c
+++ b/src/d0a70_len_4fe0.c
@@ -36,22 +36,6 @@ typedef struct FoldDataCache {
     /* 0x06 */ char unk_06[0x2];
 } FoldDataCache; // size = 0x8
 
-typedef struct FoldImageRec {
-    /* 0x00 */ s8* raster;
-    /* 0x04 */ s8* palette;
-    /* 0x08 */ u16 width;
-    /* 0x0A */ u16 height;
-    /* 0x0C */ s16 xOffset;
-    /* 0x0E */ s16 yOffset;
-    /* 0x10 */ u8 unk_10;
-    /* 0x11 */ char unk_11[0x7];
-    /* 0x18 */ s16 unk_18;
-    /* 0x1A */ char unk_1A[0x4];
-    /* 0x1E */ s16 unk_1E;
-    /* 0x20 */ char unk_20[0x4];
-    /* 0x24 */ u8 alphaMultiplier;
-} FoldImageRec; // size = 0x25
-
 typedef struct FoldGfxDescriptor {
     /* 0x00 */ Vtx* vtx;
     /* 0x04 */ Gfx* gfx;
diff --git a/src/effects.c b/src/effects.c
index e488bb84e1..b3912e693d 100644
--- a/src/effects.c
+++ b/src/effects.c
@@ -28,20 +28,20 @@ extern s32 D_801A6000;
 
 EffectTableEntry gEffectTable[] = {
     /* 0x00 */ {},
-    /* 0x01 */ FX_ENTRY(big_smoke_puff, _326410),
+    /* 0x01 */ FX_ENTRY(big_smoke_puff, effect_gfx_big_smoke_puff),
     /* 0x02 */ {},
     /* 0x03 */ {},
     /* 0x04 */ {},
     /* 0x05 */ {},
     /* 0x06 */ FX_ENTRY(landing_dust, _328EA0),
     /* 0x07 */ FX_ENTRY(walking_dust, _328EA0),
-    /* 0x08 */ FX_ENTRY(flower_splash, _32CEC0),
-    /* 0x09 */ FX_ENTRY(flower_trail, _32CEC0),
-    /* 0x0A */ FX_ENTRY(cloud_puff, _32EC50),
-    /* 0x0B */ FX_ENTRY(cloud_trail, _32EC50),
-    /* 0x0C */ FX_ENTRY(footprint, _32FB50),
-    /* 0x0D */ FX_ENTRY(floating_flower, _330460),
-    /* 0x0E */ FX_ENTRY(snowflake, _330F00),
+    /* 0x08 */ FX_ENTRY(flower_splash, effect_gfx_flower_splash_trail),
+    /* 0x09 */ FX_ENTRY(flower_trail, effect_gfx_flower_splash_trail),
+    /* 0x0A */ FX_ENTRY(cloud_puff, effect_gfx_cloud_puff_trail),
+    /* 0x0B */ FX_ENTRY(cloud_trail, effect_gfx_cloud_puff_trail),
+    /* 0x0C */ FX_ENTRY(footprint, effect_gfx_footprint),
+    /* 0x0D */ FX_ENTRY(floating_flower, effect_gfx_floating_flower),
+    /* 0x0E */ FX_ENTRY(snowflake, effect_gfx_snowflake),
     /* 0x0F */ FX_ENTRY(star, _3326A0),
     /* 0x10 */ FX_ENTRY(emote, _334C70),
     /* 0x11 */ FX_ENTRY(sparkles, _337FC0),
@@ -57,7 +57,7 @@ EffectTableEntry gEffectTable[] = {
     /* 0x1B */ FX_ENTRY(got_item_outline, _345B40),
     /* 0x1C */ FX_ENTRY(spiky_white_aura, _34E770),
     /* 0x1D */ FX_ENTRY(smoke_impact, _328EA0),
-    /* 0x1E */ FX_ENTRY(damage_indicator, _350220),
+    /* 0x1E */ FX_ENTRY(damage_indicator, effect_gfx_damage_indicator),
     /* 0x1F */ FX_ENTRY(purple_ring, _352CE0),
     /* 0x20 */ FX_ENTRY(flame, _353BB0),
     /* 0x21 */ FX_ENTRY(stars_burst, _343040),
@@ -75,8 +75,8 @@ EffectTableEntry gEffectTable[] = {
     /* 0x2D */ FX_ENTRY(stars_spread, _360A30),
     /* 0x2E */ FX_ENTRY(steam_burst, _361670),
     /* 0x2F */ FX_ENTRY(stars_orbiting, _362C50),
-    /* 0x30 */ FX_ENTRY(big_snowflakes, _3638C0),
-    /* 0x31 */ FX_ENTRY(debuff, _364C00),
+    /* 0x30 */ FX_ENTRY(big_snowflakes, effect_gfx_big_snowflakes),
+    /* 0x31 */ FX_ENTRY(debuff, effect_gfx_debuff),
     /* 0x32 */ FX_ENTRY(green_impact, _3659B0),
     /* 0x33 */ FX_ENTRY(radial_shimmer, _366D60),
     /* 0x34 */ FX_ENTRY(ending_decals, _36AEE0),
@@ -92,7 +92,7 @@ EffectTableEntry gEffectTable[] = {
     /* 0x3E */ FX_ENTRY(blast, _37D9D0),
     /* 0x3F */ FX_ENTRY(fire_flower, _3803A0),
     /* 0x40 */ FX_ENTRY(recover, _381E00),
-    /* 0x41 */ FX_ENTRY(disable_x, _3863B0),
+    /* 0x41 */ FX_ENTRY(disable_x, effect_gfx_disable_x),
     /* 0x42 */ FX_ENTRY(bombette_breaking, _37D9D0),
     /* 0x43 */ FX_ENTRY(firework, _38A350),
     /* 0x44 */ FX_ENTRY(confetti, _38BBA0),
@@ -100,7 +100,7 @@ EffectTableEntry gEffectTable[] = {
     /* 0x46 */ FX_ENTRY_NUMBERED(46, _38E990),
     /* 0x47 */ FX_ENTRY(gather_magic, _38F710),
     /* 0x48 */ FX_ENTRY(attack_result_text, _3903D0),
-    /* 0x49 */ FX_ENTRY(small_gold_sparkle, _392440),
+    /* 0x49 */ FX_ENTRY(small_gold_sparkle, effect_gfx_small_gold_sparkle),
     /* 0x4A */ FX_ENTRY(flashing_box_shockwave, _3930A0),
     /* 0x4B */ FX_ENTRY(balloon, _394670),
     /* 0x4C */ FX_ENTRY(floating_rock, _3960F0),
@@ -112,7 +112,7 @@ EffectTableEntry gEffectTable[] = {
     /* 0x52 */ FX_ENTRY(energy_orb_wave, _3A4320),
     /* 0x53 */ FX_ENTRY(merlin_house_stars, _3A5BE0),
     /* 0x54 */ FX_ENTRY(quizmo_audience, _3A77A0),
-    /* 0x55 */ FX_ENTRY(butterflies, _3AB030),
+    /* 0x55 */ FX_ENTRY(butterflies, effect_gfx_butterflies),
     /* 0x56 */ FX_ENTRY(stat_change, _3AF700),
     /* 0x57 */ FX_ENTRY(snaking_static, _3B2D90),
     /* 0x58 */ FX_ENTRY(thunderbolt_ring, _3B46A0),
@@ -127,7 +127,7 @@ EffectTableEntry gEffectTable[] = {
     /* 0x61 */ FX_ENTRY(fright_jar, _3C1BA0),
     /* 0x62 */ FX_ENTRY(stop_watch, _3CB890),
     /* 0x63 */ FX_ENTRY_NUMBERED(63, _3CD6E0),
-    /* 0x64 */ FX_ENTRY(throw_spiny, _3CFAF0),
+    /* 0x64 */ FX_ENTRY(throw_spiny, effect_gfx_throw_spiny),
     /* 0x65 */ FX_ENTRY_NUMBERED(65, _3D11E0),
     /* 0x66 */ FX_ENTRY(tubba_heart_attack, _3D2580),
     /* 0x67 */ FX_ENTRY(whirlwind, _3D3930),
diff --git a/src/effects/big_smoke_puff.c b/src/effects/big_smoke_puff.c
index a71df002fe..048f946839 100644
--- a/src/effects/big_smoke_puff.c
+++ b/src/effects/big_smoke_puff.c
@@ -6,16 +6,17 @@ static f32 D_E0002788[10] = { 2.2f, 2.7f, 3.0f, 2.2f, 2.7f, 3.0f, 1.9f, 1.9f, 1.
 static f32 sPartScales[10] = { 1.4f, 1.3f, 1.2f, 1.3f, 1.4f, 1.3f, 1.6f, 1.6f, 1.6f, 1.6f };
 static f32 sPartYaws[10] = { 0.0f, 234.0f, 468.0f, 702.0f, 936.0f, 1260.0f, 1404.0f, 1638.0f, 1902.0f, 1976.0f };
 
-extern Gfx D_09000FA0[];
-extern Gfx D_09001060[];
-extern Gfx D_09001120[];
-extern Gfx D_090011E0[];
-extern Gfx D_090012A0[];
-extern Gfx D_09001360[];
-extern Gfx D_09001420[];
+extern Gfx D_09000FA0_3273B0[];
+extern Gfx D_09001060_327470[];
+extern Gfx D_09001120_327530[];
+extern Gfx D_090011E0_3275F0[];
+extern Gfx D_090012A0_3276B0[];
+extern Gfx D_09001360_327770[];
+extern Gfx D_09001420_327830[];
 
 static Gfx* sDlists[7] = {
-    D_09000FA0, D_09001060, D_09001120, D_090011E0, D_090012A0, D_09001360, D_09001420
+    D_09000FA0_3273B0, D_09001060_327470, D_09001120_327530, D_090011E0_3275F0, D_090012A0_3276B0, D_09001360_327770,
+    D_09001420_327830
 };
 
 void big_smoke_puff_init(EffectInstance* effect);
diff --git a/src/effects/big_snowflakes.c b/src/effects/big_snowflakes.c
index a4f35e0c9a..169619706a 100644
--- a/src/effects/big_snowflakes.c
+++ b/src/effects/big_snowflakes.c
@@ -1,12 +1,12 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Gfx D_09000900[];
-extern Gfx D_090009E8[];
-extern Gfx D_09000A10[];
+extern Gfx D_09000900_3641C0[];
+extern Gfx D_090009E8_3642A8[];
+extern Gfx D_09000A10_3642D0[];
 
-Gfx* D_E0060730[] = { D_090009E8, D_09000A10 };
-Gfx* D_E0060738[] = { D_09000900, D_09000900 };
+Gfx* D_E0060730[] = { D_090009E8_3642A8, D_09000A10_3642D0 };
+Gfx* D_E0060738[] = { D_09000900_3641C0, D_09000900_3641C0 };
 
 void big_snowflakes_init(EffectInstance* effect);
 void big_snowflakes_update(EffectInstance* effect);
diff --git a/src/effects/butterflies.c b/src/effects/butterflies.c
index 0c4ee78798..1306172438 100644
--- a/src/effects/butterflies.c
+++ b/src/effects/butterflies.c
@@ -1,27 +1,28 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Vtx D_09002D40[][6]; // TODO confirm this type is correct
-extern Gfx D_09003880[];
-extern Gfx D_090038F8[];
-extern Gfx D_09003968[];
-extern Gfx D_090039D8[];
-extern Gfx D_09003A48[];
-extern Gfx D_09003AB8[];
-extern Gfx D_09003B28[];
-extern Gfx D_09003B98[];
-extern Gfx D_09003C08[];
-extern Gfx D_09003C78[];
-extern Gfx D_09003CE8[];
-extern Gfx D_09003D58[];
-extern Gfx D_09003DC8[];
+extern Vtx D_09002D40_3ADD70[][6]; // TODO confirm this type is correct
+extern Gfx D_09003880_3AE8B0[];
+extern Gfx D_090038F8_3AE928[];
+extern Gfx D_09003968_3AE998[];
+extern Gfx D_090039D8_3AEA08[];
+extern Gfx D_09003A48_3AEA78[];
+extern Gfx D_09003AB8_3AEAE8[];
+extern Gfx D_09003B28_3AEB58[];
+extern Gfx D_09003B98_3AEBC8[];
+extern Gfx D_09003C08_3AEC38[];
+extern Gfx D_09003C78_3AECA8[];
+extern Gfx D_09003CE8_3AED18[];
+extern Gfx D_09003D58_3AED88[];
+extern Gfx D_09003DC8_3AEDF8[];
 
 Gfx* D_E00AA6C0[11] = {
-    D_090038F8, D_09003968, D_090039D8, D_09003A48, D_09003AB8, D_09003B28, D_09003B98, D_09003C08, D_09003C78, D_09003CE8, D_09003D58
+    D_090038F8_3AE928, D_09003968_3AE998, D_090039D8_3AEA08, D_09003A48_3AEA78, D_09003AB8_3AEAE8, D_09003B28_3AEB58, D_09003B98_3AEBC8, D_09003C08_3AEC38, D_09003C78_3AECA8, D_09003CE8_3AED18, D_09003D58_3AED88
 };
 
 s8 D_E00AA6EC[] = {
-    -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -17, -15, -13, -11, -9, -7, -5, -3, -1, 0, 0, 0, 0, 0, 0, 0, 0 };
+    -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -17, -15, -13, -11, -9, -7, -5, -3, -1, 0, 0, 0, 0, 0, 0, 0, 0
+};
 
 void butterflies_init(EffectInstance* effect);
 void butterflies_update(EffectInstance* effect);
@@ -181,10 +182,10 @@ void butterflies_appendGfx(void* effect) {
 
     gSPMatrix(gMasterGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gDPSetPrimColor(gMasterGfxPos++, 0, 0, primColor, primColor, primColor, 255);
-    gSPDisplayList(gMasterGfxPos++, D_09003880);
+    gSPDisplayList(gMasterGfxPos++, D_09003880_3AE8B0);
     gSPDisplayList(gMasterGfxPos++, D_E00AA6C0[type]);
-    gSPVertex(gMasterGfxPos++, &D_09002D40[data->unk_2C], 6, 0);
-    gSPDisplayList(gMasterGfxPos++, D_09003DC8);
+    gSPVertex(gMasterGfxPos++, &D_09002D40_3ADD70[data->unk_2C], 6, 0);
+    gSPDisplayList(gMasterGfxPos++, D_09003DC8_3AEDF8);
     gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
     gDPPipeSync(gMasterGfxPos++);
 }
diff --git a/src/effects/cloud_puff.c b/src/effects/cloud_puff.c
index 7c9bc7ece0..4aa750fd5d 100644
--- a/src/effects/cloud_puff.c
+++ b/src/effects/cloud_puff.c
@@ -1,8 +1,8 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Gfx D_090000E0[];
-extern Gfx D_090001B8[];
+extern Gfx D_090000E0_32ED30[];
+extern Gfx D_090001B8_32EE08[];
 
 void cloud_puff_init(EffectInstance* effect);
 void cloud_puff_update(EffectInstance* effect);
@@ -121,7 +121,7 @@ void cloud_puff_appendGfx(void* effect) {
 
     gDPPipeSync(gMasterGfxPos++);
     gSPSegment(gMasterGfxPos++, 0x09, VIRTUAL_TO_PHYSICAL(effectTemp->graphics->data));
-    gSPDisplayList(gMasterGfxPos++, D_090000E0);
+    gSPDisplayList(gMasterGfxPos++, D_090000E0_32ED30);
 
     for (i = 0; i < effectTemp->numParts; i++, part++) {
         if (part->alive) {
@@ -134,7 +134,7 @@ void cloud_puff_appendGfx(void* effect) {
             gDPSetPrimColor(gMasterGfxPos++, 0, 0, 112, 96, 24, part->alpha);
             gSPMatrix(gMasterGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++],
                         G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
-            gSPDisplayList(gMasterGfxPos++, D_090001B8);
+            gSPDisplayList(gMasterGfxPos++, D_090001B8_32EE08);
             gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
         }
     }
diff --git a/src/effects/cloud_trail.c b/src/effects/cloud_trail.c
index f478dc20ae..2aa6e4a98d 100644
--- a/src/effects/cloud_trail.c
+++ b/src/effects/cloud_trail.c
@@ -1,8 +1,8 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Gfx D_090000E0[];
-extern Gfx D_090001B8[];
+extern Gfx D_090000E0_32ED30[];
+extern Gfx D_090001B8_32EE08[];
 
 void cloud_trail_init(EffectInstance* effect);
 void cloud_trail_update(EffectInstance* effect);
@@ -122,7 +122,7 @@ void cloud_trail_appendGfx(void* effect) {
 
     gDPPipeSync(gMasterGfxPos++);
     gSPSegment(gMasterGfxPos++, 0x09, VIRTUAL_TO_PHYSICAL(effectTemp->graphics->data));
-    gSPDisplayList(gMasterGfxPos++, D_090000E0);
+    gSPDisplayList(gMasterGfxPos++, D_090000E0_32ED30);
 
     for (i = 0; i < effectTemp->numParts; i++, part++) {
         if (part->alive) {
@@ -137,7 +137,7 @@ void cloud_trail_appendGfx(void* effect) {
             gDPSetPrimColor(gMasterGfxPos++, 0, 0, 112, 96, 24, part->alpha);
             gSPMatrix(gMasterGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++],
                         G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
-            gSPDisplayList(gMasterGfxPos++, D_090001B8);
+            gSPDisplayList(gMasterGfxPos++, D_090001B8_32EE08);
             gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
         }
     }
diff --git a/src/effects/damage_indicator.c b/src/effects/damage_indicator.c
index b2ac476eec..bc7a206e17 100644
--- a/src/effects/damage_indicator.c
+++ b/src/effects/damage_indicator.c
@@ -1,34 +1,34 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Gfx D_09001D40[];
-extern Gfx D_09001DE0[];
-extern Gfx D_09001E50[];
-extern Gfx D_09001E90[];
-extern Gfx D_09001ED0[];
-extern Gfx D_09001F10[];
-extern Gfx D_09001F50[];
-extern Gfx D_09001F90[];
-extern Gfx D_09001FD0[];
-extern Gfx D_09002010[];
-extern Gfx D_09002050[];
-extern Gfx D_09002090[];
-extern Gfx D_090020D0[];
-extern Gfx D_09002110[];
-extern Gfx D_09002150[];
-extern Gfx D_09002160[];
-extern Gfx D_09002170[];
-extern Gfx D_09002180[];
-extern Gfx D_090021A8[];
-extern Gfx D_09002190[];
-extern Gfx D_090021C0[];
-extern Gfx D_090021E0[];
-extern Gfx D_09002200[];
+extern Gfx D_09001D40_351F60[];
+extern Gfx D_09001DE0_352000[];
+extern Gfx D_09001E50_352070[];
+extern Gfx D_09001E90_3520B0[];
+extern Gfx D_09001ED0_3520F0[];
+extern Gfx D_09001F10_352130[];
+extern Gfx D_09001F50_352170[];
+extern Gfx D_09001F90_3521B0[];
+extern Gfx D_09001FD0_3521F0[];
+extern Gfx D_09002010_352230[];
+extern Gfx D_09002050_352270[];
+extern Gfx D_09002090_3522B0[];
+extern Gfx D_090020D0_3522F0[];
+extern Gfx D_09002110_352330[];
+extern Gfx D_09002150_352370[];
+extern Gfx D_09002160_352380[];
+extern Gfx D_09002170_352390[];
+extern Gfx D_09002180_3523A0[];
+extern Gfx D_09002190_3523B0[];
+extern Gfx D_090021A8_3523C8[];
+extern Gfx D_090021C0_3523E0[];
+extern Gfx D_090021E0_352400[];
+extern Gfx D_09002200_352420[];
 
 Gfx* D_E003CCA0[] = {
-    D_09001E50, D_09001E90, D_09001ED0, D_09001F10,
-    D_09001F50, D_09001F90, D_09001FD0, D_09002010,
-    D_09002050, D_09002090, D_090020D0, D_09002110
+    D_09001E50_352070, D_09001E90_3520B0, D_09001ED0_3520F0, D_09001F10_352130,
+    D_09001F50_352170, D_09001F90_3521B0, D_09001FD0_3521F0, D_09002010_352230,
+    D_09002050_352270, D_09002090_3522B0, D_090020D0_3522F0, D_09002110_352330
 };
 
 u8 D_E003CCD0[] = {
@@ -224,20 +224,20 @@ void func_E003C498(EffectInstance* effect) {
     for (i = 1; i < effect->numParts; i++, part--) {
         s32 index = (i + spA0);
         gDPSetPrimColor(gMasterGfxPos++, 0, 0, D_E003CCF8[index % 12].r, D_E003CCF8[index % 12].g, D_E003CCF8[index % 12].b, part->alpha);
-        gSPDisplayList(gMasterGfxPos++, D_09001D40);
+        gSPDisplayList(gMasterGfxPos++, D_09001D40_351F60);
         if (i == spA4) {
             shim_guPositionF(sp20, 0.0f, 0.0f, 0.0f, part->unk_38, part->unk_10.x, part->unk_10.y, part->unk_10.z);
             shim_guMtxF2L(sp20, &gDisplayContext->matrixStack[gMatrixListPos]);
             gSPMatrix(gMasterGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
-            gSPDisplayList(gMasterGfxPos++, D_09002150);
+            gSPDisplayList(gMasterGfxPos++, D_09002150_352370);
             gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
             shim_guPositionF(sp20, 0.0f, 0.0f, 0.0f, part->unk_38, (part->unk_10.x + part->unk_04.x) * 0.5, (part->unk_10.y + part->unk_04.y) * 0.5, (part->unk_10.z + part->unk_04.z) * 0.5);
             shim_guMtxF2L(sp20, &gDisplayContext->matrixStack[gMatrixListPos]);
             gSPMatrix(gMasterGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
-            gSPDisplayList(gMasterGfxPos++, D_09002160);
+            gSPDisplayList(gMasterGfxPos++, D_09002160_352380);
             gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
         }
-        gSPDisplayList(gMasterGfxPos++, D_09001D40);
+        gSPDisplayList(gMasterGfxPos++, D_09001D40_351F60);
         shim_guTranslateF(sp20, part->unk_04.x, part->unk_04.y, part->unk_04.z);
         shim_guMtxF2L(sp20, &gDisplayContext->matrixStack[gMatrixListPos]);
         gSPMatrix(gMasterGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
@@ -246,27 +246,27 @@ void func_E003C498(EffectInstance* effect) {
         gSPMatrix(gMasterGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
 
         if (i == spA4) {
-            gSPDisplayList(gMasterGfxPos++, &D_09002170);
+            gSPDisplayList(gMasterGfxPos++, &D_09002170_352390);
         } else {
-            gSPDisplayList(gMasterGfxPos++, &D_09002180);
+            gSPDisplayList(gMasterGfxPos++, &D_09002180_3523A0);
         }
         if (i == spA4) {
-            gSPDisplayList(gMasterGfxPos++, D_090021A8);
+            gSPDisplayList(gMasterGfxPos++, D_090021A8_3523C8);
             gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
-            gSPDisplayList(gMasterGfxPos++, D_09001DE0);
+            gSPDisplayList(gMasterGfxPos++, D_090021E0_352400);
             if (spA8 < 10) {
                 gSPDisplayList(gMasterGfxPos++, D_E003CCA0[i]);
-                gSPDisplayList(gMasterGfxPos++, D_090021C0);
+                gSPDisplayList(gMasterGfxPos++, D_090021C0_3523E0);
             } else {
                 s32 temp = spA8 % 10;
                 s32 temp2 = spA8 / 10;
                 gSPDisplayList(gMasterGfxPos++, D_E003CCA0[temp]);
-                gSPDisplayList(gMasterGfxPos++, D_09002200);
+                gSPDisplayList(gMasterGfxPos++, D_09002200_352420);
                 gSPDisplayList(gMasterGfxPos++, D_E003CCA0[temp2]);
-                gSPDisplayList(gMasterGfxPos++, D_090021E0);
+                gSPDisplayList(gMasterGfxPos++, D_090021E0_352400);
             }
         } else {
-            gSPDisplayList(gMasterGfxPos++, D_09002190);
+            gSPDisplayList(gMasterGfxPos++, D_09002190_3523B0);
             gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
         }
         gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
diff --git a/src/effects/debuff.c b/src/effects/debuff.c
index 52e875c243..78217fa665 100644
--- a/src/effects/debuff.c
+++ b/src/effects/debuff.c
@@ -1,11 +1,11 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Gfx D_09000240[];
-extern Gfx D_090002E8[];
+extern Gfx D_09000240_364E40[];
+extern Gfx D_090002E8_364EE8[];
 
-Gfx* D_E00628C0[] = { D_090002E8 };
-Gfx* D_E00628C4[] = { D_09000240 };
+Gfx* D_E00628C0[] = { D_090002E8_364EE8 };
+Gfx* D_E00628C4[] = { D_09000240_364E40 };
 
 void debuff_init(EffectInstance* effect);
 void debuff_update(EffectInstance* effect);
diff --git a/src/effects/disable_x.c b/src/effects/disable_x.c
index 94bd44d1ff..225aef2478 100644
--- a/src/effects/disable_x.c
+++ b/src/effects/disable_x.c
@@ -1,29 +1,29 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Gfx D_09002100[];
-extern Gfx D_09002198[];
-extern Gfx D_09002230[];
-extern Gfx D_09002250[];
-extern Gfx D_09002270[];
-extern Gfx D_09002290[];
-extern Gfx D_090022B0[];
-extern Gfx D_09002320[];
-extern Gfx D_09002360[];
-extern Gfx D_090023A0[];
-extern Gfx D_090023E0[];
-extern Gfx D_09002420[];
-extern Gfx D_09002460[];
-extern Gfx D_090024A0[];
-extern Gfx D_090024E0[];
-extern Gfx D_09002520[];
-extern Gfx D_09002560[];
-extern Gfx D_090025A0[];
-extern Gfx D_090025E0[];
+extern Gfx D_09002100_3884B0[];
+extern Gfx D_09002198_388548[];
+extern Gfx D_09002230_3885E0[];
+extern Gfx D_09002250_388600[];
+extern Gfx D_09002270_388620[];
+extern Gfx D_09002290_388640[];
+extern Gfx D_090022B0_388660[];
+extern Gfx D_09002320_3886D0[];
+extern Gfx D_09002360_388710[];
+extern Gfx D_090023A0_388750[];
+extern Gfx D_090023E0_388790[];
+extern Gfx D_09002420_3887D0[];
+extern Gfx D_09002460_388810[];
+extern Gfx D_090024A0_388850[];
+extern Gfx D_090024E0_388890[];
+extern Gfx D_09002520_3888D0[];
+extern Gfx D_09002560_388910[];
+extern Gfx D_090025A0_388950[];
+extern Gfx D_090025E0_388990[];
 
 Gfx* D_E0082D00[] = {
-    D_09002320, D_09002360, D_090023A0, D_090023E0, D_09002420, D_09002460, D_090024A0, D_090024E0, D_09002520,
-    D_09002560, D_090025A0, D_090025E0
+    D_09002320_3886D0, D_09002360_388710, D_090023A0_388750, D_090023E0_388790, D_09002420_3887D0, D_09002460_388810,
+    D_090024A0_388850, D_090024E0_388890, D_09002520_3888D0, D_09002560_388910, D_090025A0_388950, D_090025E0_388990
 };
 
 void disable_x_init(EffectInstance* effect);
@@ -269,12 +269,12 @@ void func_E00828B4(EffectInstance* effect) {
     for (i = 1; i < effect->numParts; i++, data++) {
         if (unk_38 > 0 || type == 10) {
             if (type == 1) {
-                gSPDisplayList(gMasterGfxPos++, D_09002198);
+                gSPDisplayList(gMasterGfxPos++, D_09002198_388548);
             } else {
-                gSPDisplayList(gMasterGfxPos++, D_09002100);
+                gSPDisplayList(gMasterGfxPos++, D_09002100_3884B0);
             }
             func_E00826C4(data);
-            gSPDisplayList(gMasterGfxPos++, D_09002230);
+            gSPDisplayList(gMasterGfxPos++, D_09002230_3885E0);
             gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
         }
     }
@@ -296,19 +296,19 @@ void func_E0082A84(EffectInstance* effect) {
     for (i = 1; i < effect->numParts; i++, data++) {
         func_E00826C4(data);
         if (unk_38 > 0) {
-            gSPDisplayList(gMasterGfxPos++, D_090022B0);
+            gSPDisplayList(gMasterGfxPos++, D_090022B0_388660);
             if (unk_38 < 10) {
                 gSPDisplayList(gMasterGfxPos++, D_E0082D00[unk_38]);
-                gSPDisplayList(gMasterGfxPos++, D_09002250);
+                gSPDisplayList(gMasterGfxPos++, D_09002250_388600);
             } else {
                 s32 ones = unk_38 % 10;
                 s32 tens = unk_38 / 10;
 
                 gSPDisplayList(gMasterGfxPos++, D_E0082D00[ones]);
                 gSPDisplayList(gMasterGfxPos++, D_E0082D00[tens]);
-                gSPDisplayList(gMasterGfxPos++, D_09002290);
+                gSPDisplayList(gMasterGfxPos++, D_09002290_388640);
                 gSPDisplayList(gMasterGfxPos++, D_E0082D00[tens]);
-                gSPDisplayList(gMasterGfxPos++, D_09002270);
+                gSPDisplayList(gMasterGfxPos++, D_09002270_388620);
             }
         }
         gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
diff --git a/src/effects/floating_flower.c b/src/effects/floating_flower.c
index 7571677426..165f4e5f4d 100644
--- a/src/effects/floating_flower.c
+++ b/src/effects/floating_flower.c
@@ -3,7 +3,7 @@
 
 s32 D_E001A610 = 0;
 
-extern Gfx D_090002F0[];
+extern Gfx D_090002F0_330750[];
 
 void floating_flower_init(EffectInstance* effect);
 void floating_flower_update(EffectInstance* effect);
@@ -164,7 +164,7 @@ void floating_flower_appendGfx(void* effect) {
 
     if (alpha != 0) {
         gDPSetPrimColor(gMasterGfxPos++, 0, 0, 0, 0, 0, alpha);
-        gSPDisplayList(gMasterGfxPos++, D_090002F0);
+        gSPDisplayList(gMasterGfxPos++, D_090002F0_330750);
         gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
     }
 }
diff --git a/src/effects/flower_splash.c b/src/effects/flower_splash.c
index b76dca3605..45c4a3a013 100644
--- a/src/effects/flower_splash.c
+++ b/src/effects/flower_splash.c
@@ -1,7 +1,7 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Gfx D_09000E08[];
+extern Gfx D_09000E08_32DCC8[];
 
 void flower_splash_init(EffectInstance* effect);
 void flower_splash_update(EffectInstance* effect);
@@ -147,7 +147,7 @@ void flower_splash_appendGfx(void* effect) {
 
     for (i = 0; i < effectTemp->numParts; i++, data++) {
         if (data->unk_00 != 0) {
-            Gfx* dlist = D_09000E08;
+            Gfx* dlist = D_09000E08_32DCC8;
 
             gDisplayContext->matrixStack[gMatrixListPos] = data->unk_30;
 
diff --git a/src/effects/flower_trail.c b/src/effects/flower_trail.c
index ecb26546fc..125b4132bd 100644
--- a/src/effects/flower_trail.c
+++ b/src/effects/flower_trail.c
@@ -1,8 +1,8 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Gfx D_09000E20[];
-extern Gfx D_09000E38[];
+extern Gfx D_09000E20_32DCE0[];
+extern Gfx D_09000E38_32DCF8[];
 
 void flower_trail_init(EffectInstance* effect);
 void flower_trail_update(EffectInstance* effect);
@@ -167,9 +167,9 @@ void flower_trail_appendGfx(void* effect) {
     for (i = 0; i < effectTemp->numParts; i++, part++) {
         if (part->unk_00 != 0) {
             if (part->unk_09 != 0) {
-                dlist = D_09000E20;
+                dlist = D_09000E20_32DCE0;
             } else {
-                dlist = D_09000E38;
+                dlist = D_09000E38_32DCF8;
             }
 
             gDisplayContext->matrixStack[gMatrixListPos] = part->unk_30;
diff --git a/src/effects/footprint.c b/src/effects/footprint.c
index 17d65e2791..5180664427 100644
--- a/src/effects/footprint.c
+++ b/src/effects/footprint.c
@@ -1,7 +1,7 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Gfx D_09000240[];
+extern Gfx D_09000240_32FD90[];
 
 void func_E0018000(FootprintFXData* part);
 void footprint_init(EffectInstance* effect);
@@ -124,7 +124,7 @@ void footprint_appendGfx(void* effect) {
 
     for (i = 0; i < effectTemp->numParts; i++, part++) {
         if (part->alive) {
-            Gfx* dlist = D_09000240;
+            Gfx* dlist = D_09000240_32FD90;
 
             gDisplayContext->matrixStack[gMatrixListPos] = part->mtx;
 
diff --git a/src/effects/gfx/big_smoke_puff.c b/src/effects/gfx/big_smoke_puff.c
new file mode 100644
index 0000000000..a63f5de177
--- /dev/null
+++ b/src/effects/gfx/big_smoke_puff.c
@@ -0,0 +1,28 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_326410.png.inc.c"
+#include "effects/gfx/D_09000000_326410.pal.inc.c"
+#include "effects/gfx/D_09000220_326630.png.inc.c"
+#include "effects/gfx/D_09000220_326630.pal.inc.c"
+#include "effects/gfx/D_09000440_326850.png.inc.c"
+#include "effects/gfx/D_09000440_326850.pal.inc.c"
+#include "effects/gfx/D_09000660_326A70.png.inc.c"
+#include "effects/gfx/D_09000660_326A70.pal.inc.c"
+#include "effects/gfx/D_09000880_326C90.png.inc.c"
+#include "effects/gfx/D_09000880_326C90.pal.inc.c"
+#include "effects/gfx/D_09000AA0_326EB0.png.inc.c"
+#include "effects/gfx/D_09000AA0_326EB0.pal.inc.c"
+#include "effects/gfx/D_09000CC0_3270D0.png.inc.c"
+#include "effects/gfx/D_09000CC0_3270D0.pal.inc.c"
+
+#include "effects/gfx/D_09000EE0_3272F0.vtx.inc.c"
+
+#include "effects/gfx/D_09000F20_327330.gfx.inc.c"
+#include "effects/gfx/D_09000F88_327398.gfx.inc.c"
+#include "effects/gfx/D_09000FA0_3273B0.gfx.inc.c"
+#include "effects/gfx/D_09001060_327470.gfx.inc.c"
+#include "effects/gfx/D_09001120_327530.gfx.inc.c"
+#include "effects/gfx/D_090011E0_3275F0.gfx.inc.c"
+#include "effects/gfx/D_090012A0_3276B0.gfx.inc.c"
+#include "effects/gfx/D_09001360_327770.gfx.inc.c"
+#include "effects/gfx/D_09001420_327830.gfx.inc.c"
diff --git a/src/effects/gfx/big_snowflakes.c b/src/effects/gfx/big_snowflakes.c
new file mode 100644
index 0000000000..960e2dd0df
--- /dev/null
+++ b/src/effects/gfx/big_snowflakes.c
@@ -0,0 +1,11 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_3638C0.png.inc.c"
+#include "effects/gfx/D_09000080_363940.png.inc.c"
+
+#include "effects/gfx/D_09000880_364140.vtx.inc.c"
+#include "effects/gfx/D_090008C0_364180.vtx.inc.c"
+
+#include "effects/gfx/D_09000900_3641C0.gfx.inc.c"
+#include "effects/gfx/D_090009E8_3642A8.gfx.inc.c"
+#include "effects/gfx/D_09000A10_3642D0.gfx.inc.c"
diff --git a/src/effects/gfx/butterflies.c b/src/effects/gfx/butterflies.c
new file mode 100644
index 0000000000..6cecc4efdc
--- /dev/null
+++ b/src/effects/gfx/butterflies.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_3AB030.png.inc.c"
+#include "effects/gfx/D_09000000_3AB030.pal.inc.c"
+#include "effects/gfx/D_09000420_3AB450.png.inc.c"
+#include "effects/gfx/D_09000420_3AB450.pal.inc.c"
+#include "effects/gfx/D_09000840_3AB870.png.inc.c"
+#include "effects/gfx/D_09000840_3AB870.pal.inc.c"
+#include "effects/gfx/D_09000C50_3ABC80.png.inc.c"
+#include "effects/gfx/D_09000C50_3ABC80.pal.inc.c"
+#include "effects/gfx/D_09001070_3AC0A0.png.inc.c"
+#include "effects/gfx/D_09001070_3AC0A0.pal.inc.c"
+#include "effects/gfx/D_09001480_3AC4B0.png.inc.c"
+#include "effects/gfx/D_09001480_3AC4B0.pal.inc.c"
+#include "effects/gfx/D_090018A0_3AC8D0.png.inc.c"
+#include "effects/gfx/D_090018A0_3AC8D0.pal.inc.c"
+#include "effects/gfx/D_09001CC0_3ACCF0.png.inc.c"
+#include "effects/gfx/D_09001CC0_3ACCF0.pal.inc.c"
+#include "effects/gfx/D_090020E0_3AD110.png.inc.c"
+#include "effects/gfx/D_090020E0_3AD110.pal.inc.c"
+#include "effects/gfx/D_09002500_3AD530.png.inc.c"
+#include "effects/gfx/D_09002500_3AD530.pal.inc.c"
+#include "effects/gfx/D_09002920_3AD950.png.inc.c"
+#include "effects/gfx/D_09002920_3AD950.pal.inc.c"
+
+#include "effects/gfx/D_09002D40_3ADD70.vtx.inc.c"
+
+#include "effects/gfx/D_09003880_3AE8B0.gfx.inc.c"
+#include "effects/gfx/D_090038F8_3AE928.gfx.inc.c"
+#include "effects/gfx/D_09003968_3AE998.gfx.inc.c"
+#include "effects/gfx/D_090039D8_3AEA08.gfx.inc.c"
+#include "effects/gfx/D_09003A48_3AEA78.gfx.inc.c"
+#include "effects/gfx/D_09003AB8_3AEAE8.gfx.inc.c"
+#include "effects/gfx/D_09003B28_3AEB58.gfx.inc.c"
+#include "effects/gfx/D_09003B98_3AEBC8.gfx.inc.c"
+#include "effects/gfx/D_09003C08_3AEC38.gfx.inc.c"
+#include "effects/gfx/D_09003C78_3AECA8.gfx.inc.c"
+#include "effects/gfx/D_09003CE8_3AED18.gfx.inc.c"
+#include "effects/gfx/D_09003D58_3AED88.gfx.inc.c"
+#include "effects/gfx/D_09003DC8_3AEDF8.gfx.inc.c"
diff --git a/src/effects/gfx/cloud_puff_trail.c b/src/effects/gfx/cloud_puff_trail.c
new file mode 100644
index 0000000000..c7eb5b62df
--- /dev/null
+++ b/src/effects/gfx/cloud_puff_trail.c
@@ -0,0 +1,9 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_32EC50.png.inc.c"
+#include "effects/gfx/D_09000000_32EC50.pal.inc.c"
+
+#include "effects/gfx/D_090000A0_32ECF0.vtx.inc.c"
+
+#include "effects/gfx/D_090000E0_32ED30.gfx.inc.c"
+#include "effects/gfx/D_090001B8_32EE08.gfx.inc.c"
diff --git a/src/effects/gfx/damage_indicator.c b/src/effects/gfx/damage_indicator.c
new file mode 100644
index 0000000000..192121bc62
--- /dev/null
+++ b/src/effects/gfx/damage_indicator.c
@@ -0,0 +1,48 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_350220.png.inc.c"
+#include "effects/gfx/D_09000200_350420.png.inc.c"
+#include "effects/gfx/D_09000400_350620.png.inc.c"
+#include "effects/gfx/D_09000600_350820.png.inc.c"
+#include "effects/gfx/D_09000800_350A20.png.inc.c"
+#include "effects/gfx/D_09000A00_350C20.png.inc.c"
+#include "effects/gfx/D_09000C00_350E20.png.inc.c"
+#include "effects/gfx/D_09000E00_351020.png.inc.c"
+#include "effects/gfx/D_09001000_351220.png.inc.c"
+#include "effects/gfx/D_09001200_351420.png.inc.c"
+#include "effects/gfx/D_09001400_351620.png.inc.c"
+#include "effects/gfx/D_09001600_351820.png.inc.c"
+#include "effects/gfx/D_09001800_351A20.png.inc.c"
+#include "effects/gfx/D_09001A00_351C20.png.inc.c"
+
+#include "effects/gfx/D_09001C00_351E20.vtx.inc.c"
+#include "effects/gfx/D_09001C10_351E30.vtx.inc.c"
+#include "effects/gfx/D_09001C30_351E50.vtx.inc.c"
+#include "effects/gfx/D_09001C40_351E60.vtx.inc.c"
+#include "effects/gfx/D_09001C80_351EA0.vtx.inc.c"
+#include "effects/gfx/D_09001CC0_351EE0.vtx.inc.c"
+#include "effects/gfx/D_09001D00_351F20.vtx.inc.c"
+
+#include "effects/gfx/D_09001D40_351F60.gfx.inc.c"
+#include "effects/gfx/D_09001DE0_352000.gfx.inc.c"
+#include "effects/gfx/D_09001E50_352070.gfx.inc.c"
+#include "effects/gfx/D_09001E90_3520B0.gfx.inc.c"
+#include "effects/gfx/D_09001ED0_3520F0.gfx.inc.c"
+#include "effects/gfx/D_09001F10_352130.gfx.inc.c"
+#include "effects/gfx/D_09001F50_352170.gfx.inc.c"
+#include "effects/gfx/D_09001F90_3521B0.gfx.inc.c"
+#include "effects/gfx/D_09001FD0_3521F0.gfx.inc.c"
+#include "effects/gfx/D_09002010_352230.gfx.inc.c"
+#include "effects/gfx/D_09002050_352270.gfx.inc.c"
+#include "effects/gfx/D_09002090_3522B0.gfx.inc.c"
+#include "effects/gfx/D_090020D0_3522F0.gfx.inc.c"
+#include "effects/gfx/D_09002110_352330.gfx.inc.c"
+#include "effects/gfx/D_09002150_352370.gfx.inc.c"
+#include "effects/gfx/D_09002160_352380.gfx.inc.c"
+#include "effects/gfx/D_09002170_352390.gfx.inc.c"
+#include "effects/gfx/D_09002180_3523A0.gfx.inc.c"
+#include "effects/gfx/D_09002190_3523B0.gfx.inc.c"
+#include "effects/gfx/D_090021A8_3523C8.gfx.inc.c"
+#include "effects/gfx/D_090021C0_3523E0.gfx.inc.c"
+#include "effects/gfx/D_090021E0_352400.gfx.inc.c"
+#include "effects/gfx/D_09002200_352420.gfx.inc.c"
diff --git a/src/effects/gfx/debuff.c b/src/effects/gfx/debuff.c
new file mode 100644
index 0000000000..47395e6b43
--- /dev/null
+++ b/src/effects/gfx/debuff.c
@@ -0,0 +1,8 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_364C00.png.inc.c"
+
+#include "effects/gfx/D_09000200_364E00.vtx.inc.c"
+
+#include "effects/gfx/D_09000240_364E40.gfx.inc.c"
+#include "effects/gfx/D_090002E8_364EE8.gfx.inc.c"
diff --git a/src/effects/gfx/disable_x.c b/src/effects/gfx/disable_x.c
new file mode 100644
index 0000000000..d62237debe
--- /dev/null
+++ b/src/effects/gfx/disable_x.c
@@ -0,0 +1,40 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_3863B0.png.inc.c"
+#include "effects/gfx/D_09000200_3865B0.png.inc.c"
+#include "effects/gfx/D_09000400_3867B0.png.inc.c"
+#include "effects/gfx/D_09000600_3869B0.png.inc.c"
+#include "effects/gfx/D_09000800_386BB0.png.inc.c"
+#include "effects/gfx/D_09000A00_386DB0.png.inc.c"
+#include "effects/gfx/D_09000C00_386FB0.png.inc.c"
+#include "effects/gfx/D_09000E00_3871B0.png.inc.c"
+#include "effects/gfx/D_09001000_3873B0.png.inc.c"
+#include "effects/gfx/D_09001200_3875B0.png.inc.c"
+#include "effects/gfx/D_09001400_3877B0.png.inc.c"
+#include "effects/gfx/D_09001600_3879B0.png.inc.c"
+#include "effects/gfx/D_09001800_387BB0.png.inc.c"
+
+#include "effects/gfx/D_09002000_3883B0.vtx.inc.c"
+#include "effects/gfx/D_09002040_3883F0.vtx.inc.c"
+#include "effects/gfx/D_09002080_388430.vtx.inc.c"
+#include "effects/gfx/D_090020C0_388470.vtx.inc.c"
+
+#include "effects/gfx/D_09002100_3884B0.gfx.inc.c"
+#include "effects/gfx/D_09002198_388548.gfx.inc.c"
+#include "effects/gfx/D_09002230_3885E0.gfx.inc.c"
+#include "effects/gfx/D_09002250_388600.gfx.inc.c"
+#include "effects/gfx/D_09002270_388620.gfx.inc.c"
+#include "effects/gfx/D_09002290_388640.gfx.inc.c"
+#include "effects/gfx/D_090022B0_388660.gfx.inc.c"
+#include "effects/gfx/D_09002320_3886D0.gfx.inc.c"
+#include "effects/gfx/D_09002360_388710.gfx.inc.c"
+#include "effects/gfx/D_090023A0_388750.gfx.inc.c"
+#include "effects/gfx/D_090023E0_388790.gfx.inc.c"
+#include "effects/gfx/D_09002420_3887D0.gfx.inc.c"
+#include "effects/gfx/D_09002460_388810.gfx.inc.c"
+#include "effects/gfx/D_090024A0_388850.gfx.inc.c"
+#include "effects/gfx/D_090024E0_388890.gfx.inc.c"
+#include "effects/gfx/D_09002520_3888D0.gfx.inc.c"
+#include "effects/gfx/D_09002560_388910.gfx.inc.c"
+#include "effects/gfx/D_090025A0_388950.gfx.inc.c"
+#include "effects/gfx/D_090025E0_388990.gfx.inc.c"
diff --git a/src/effects/gfx/floating_flower.c b/src/effects/gfx/floating_flower.c
new file mode 100644
index 0000000000..b9e693bfd0
--- /dev/null
+++ b/src/effects/gfx/floating_flower.c
@@ -0,0 +1,11 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_330460.png.inc.c"
+#include "effects/gfx/D_09000000_330460.pal.inc.c"
+
+#include "effects/gfx/D_090000A0_330500.vtx.inc.c"
+#include "effects/gfx/D_09000170_3305D0.vtx.inc.c"
+#include "effects/gfx/D_09000230_330690.vtx.inc.c"
+
+#include "effects/gfx/D_090002F0_330750.gfx.inc.c"
+#include "effects/gfx/D_09000450_3308B0.gfx.inc.c"
diff --git a/src/effects/gfx/flower_splash_trail.c b/src/effects/gfx/flower_splash_trail.c
new file mode 100644
index 0000000000..2528351a99
--- /dev/null
+++ b/src/effects/gfx/flower_splash_trail.c
@@ -0,0 +1,23 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_32CEC0.png.inc.c"
+#include "effects/gfx/D_09000000_32CEC0.pal.inc.c"
+#include "effects/gfx/D_09000000_32CEC0.yellow.pal.inc.c"
+#include "effects/gfx/D_090000C0_32CF80.png.inc.c"
+
+#include "effects/gfx/D_090008C0_32D780.vtx.inc.c"
+#include "effects/gfx/D_09000A30_32D8F0.vtx.inc.c"
+#include "effects/gfx/D_09000A40_32D900.vtx.inc.c"
+#include "effects/gfx/D_09000A50_32D910.vtx.inc.c"
+#include "effects/gfx/D_09000A90_32D950.vtx.inc.c"
+#include "effects/gfx/D_09000AB0_32D970.vtx.inc.c"
+#include "effects/gfx/D_09000AF0_32D9B0.vtx.inc.c"
+
+#include "effects/gfx/D_09000B50_32DA10.gfx.inc.c"
+#include "effects/gfx/D_09000C10_32DAD0.gfx.inc.c"
+#include "effects/gfx/D_09000CD0_32DB90.gfx.inc.c"
+#include "effects/gfx/D_09000D58_32DC18.gfx.inc.c"
+#include "effects/gfx/D_09000D90_32DC50.gfx.inc.c"
+#include "effects/gfx/D_09000E08_32DCC8.gfx.inc.c"
+#include "effects/gfx/D_09000E20_32DCE0.gfx.inc.c"
+#include "effects/gfx/D_09000E38_32DCF8.gfx.inc.c"
diff --git a/src/effects/gfx/footprint.c b/src/effects/gfx/footprint.c
new file mode 100644
index 0000000000..94f60ffb63
--- /dev/null
+++ b/src/effects/gfx/footprint.c
@@ -0,0 +1,7 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_32FB50.png.inc.c"
+
+#include "effects/gfx/D_09000200_32FD50.vtx.inc.c"
+
+#include "effects/gfx/D_09000240_32FD90.gfx.inc.c"
diff --git a/src/effects/gfx/small_gold_sparkle.c b/src/effects/gfx/small_gold_sparkle.c
new file mode 100644
index 0000000000..7bffcbe10a
--- /dev/null
+++ b/src/effects/gfx/small_gold_sparkle.c
@@ -0,0 +1,17 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_392440.png.inc.c"
+#include "effects/gfx/D_09000080_3924C0.png.inc.c"
+#include "effects/gfx/D_09000100_392540.png.inc.c"
+#include "effects/gfx/D_09000180_3925C0.png.inc.c"
+#include "effects/gfx/D_09000200_392640.png.inc.c"
+
+#include "effects/gfx/D_09000280_3926C0.vtx.inc.c"
+
+#include "effects/gfx/D_090002C0_392700.gfx.inc.c"
+#include "effects/gfx/D_09000330_392770.gfx.inc.c"
+#include "effects/gfx/D_09000370_3927B0.gfx.inc.c"
+#include "effects/gfx/D_090003B0_3927F0.gfx.inc.c"
+#include "effects/gfx/D_090003F0_392830.gfx.inc.c"
+#include "effects/gfx/D_09000430_392870.gfx.inc.c"
+#include "effects/gfx/D_09000470_3928B0.gfx.inc.c"
diff --git a/src/effects/gfx/snowflake.c b/src/effects/gfx/snowflake.c
new file mode 100644
index 0000000000..b577fc366e
--- /dev/null
+++ b/src/effects/gfx/snowflake.c
@@ -0,0 +1,11 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_330F00.png.inc.c"
+#include "effects/gfx/D_09000080_330F80.png.inc.c"
+
+#include "effects/gfx/D_09000880_331780.vtx.inc.c"
+#include "effects/gfx/D_090008C0_3317C0.vtx.inc.c"
+
+#include "effects/gfx/D_09000900_331800.gfx.inc.c"
+#include "effects/gfx/D_090009E8_3318E8.gfx.inc.c"
+#include "effects/gfx/D_09000A10_331910.gfx.inc.c"
diff --git a/src/effects/gfx/throw_spiny.c b/src/effects/gfx/throw_spiny.c
new file mode 100644
index 0000000000..13a59463fc
--- /dev/null
+++ b/src/effects/gfx/throw_spiny.c
@@ -0,0 +1,20 @@
+#include "common.h"
+
+#include "effects/gfx/D_09000000_3CFAF0.png.inc.c"
+#include "effects/gfx/D_09000000_3CFAF0.pal.inc.c"
+
+u8 D_09000220_3CFD10[] = {
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0
+};
+
+#include "effects/gfx/D_09000400_3CFEF0.png.inc.c"
+#include "effects/gfx/D_09000400_3CFEF0.pal.inc.c"
+
+u8 D_09000620_3D0110[] = {
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0
+};
+
+#include "effects/gfx/D_09000800_3D02F0.gfx.inc.c"
+#include "effects/gfx/D_090008D8_3D03C8.gfx.inc.c"
+#include "effects/gfx/D_090009B0_3D04A0.vtx.inc.c"
+#include "effects/gfx/D_090009F0_3D04E0.gfx.inc.c"
diff --git a/src/effects/small_gold_sparkle.c b/src/effects/small_gold_sparkle.c
index e9fb2142ae..869d7d3d5b 100644
--- a/src/effects/small_gold_sparkle.c
+++ b/src/effects/small_gold_sparkle.c
@@ -1,15 +1,15 @@
 #include "common.h"
 #include "effects_internal.h"
 
-extern Gfx D_090002C0[];
-extern Gfx D_09000330[];
-extern Gfx D_09000370[];
-extern Gfx D_090003B0[];
-extern Gfx D_090003F0[];
-extern Gfx D_09000430[];
-extern Gfx D_09000470[];
+extern Gfx D_090002C0_392700[];
+extern Gfx D_09000330_392770[];
+extern Gfx D_09000370_3927B0[];
+extern Gfx D_090003B0_3927F0[];
+extern Gfx D_090003F0_392830[];
+extern Gfx D_09000430_392870[];
+extern Gfx D_09000470_3928B0[];
 
-static Gfx* sDlists[] = { D_09000430, D_090003F0, D_090003B0, D_09000370, D_09000330 };
+static Gfx* sDlists[] = { D_09000430_392870, D_090003F0_392830, D_090003B0_3927F0, D_09000370_3927B0, D_09000330_392770 };
 
 static s32 sPartParams[4 * 5] = {
     1, 0, 0, 0, 100,
@@ -126,7 +126,7 @@ void small_gold_sparkle_appendGfx(void* effect) {
     shim_guMtxF2L(sp18, &gDisplayContext->matrixStack[gMatrixListPos]);
 
     gSPMatrix(gMasterGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
-    gSPDisplayList(gMasterGfxPos++, D_090002C0);
+    gSPDisplayList(gMasterGfxPos++, D_090002C0_392700);
     gDPSetPrimColor(gMasterGfxPos++, 0, 0, 255, 255, 15, 255);
 
     part++;
@@ -144,7 +144,7 @@ void small_gold_sparkle_appendGfx(void* effect) {
                       G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
             gSPMatrix(gMasterGfxPos++, spD8, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
             gSPDisplayList(gMasterGfxPos++, sDlists[part->unk_04 >> 1]);
-            gSPDisplayList(gMasterGfxPos++, D_09000470);
+            gSPDisplayList(gMasterGfxPos++, D_09000470_3928B0);
             gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
         }
     }
diff --git a/src/effects/snowflake.c b/src/effects/snowflake.c
index cde2ea8f45..a0c3a813e1 100644
--- a/src/effects/snowflake.c
+++ b/src/effects/snowflake.c
@@ -3,8 +3,8 @@
 
 s32 D_E001C5E0 = 0;
 
-extern Gfx D_09000900[];
-extern Gfx D_090009E8[];
+extern Gfx D_09000900_331800[];
+extern Gfx D_090009E8_3318E8[];
 
 void snowflake_init(EffectInstance* effect);
 void snowflake_update(EffectInstance* effect);
@@ -124,7 +124,7 @@ void snowflake_appendGfx(void* effect) {
 
     gDPPipeSync(gMasterGfxPos++);
     gSPSegment(gMasterGfxPos++, 0x09, VIRTUAL_TO_PHYSICAL(effectTemp->graphics->data));
-    gSPDisplayList(gMasterGfxPos++, D_09000900);
+    gSPDisplayList(gMasterGfxPos++, D_09000900_331800);
 
     shim_guTranslateF(sp18, part->xPos, part->yPos, part->zPos);
     shim_guRotateF(spD8, -gCameras[gCurrentCameraID].currentYaw, 0.0f, 1.0f, 0.0f);
@@ -140,7 +140,7 @@ void snowflake_appendGfx(void* effect) {
     shim_guMtxF2L(sp118, &gDisplayContext->matrixStack[gMatrixListPos]);
 
     gSPMatrix(gMasterGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
-    gSPDisplayList(gMasterGfxPos++, D_090009E8);
+    gSPDisplayList(gMasterGfxPos++, D_090009E8_3318E8);
     gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
     gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
 }
diff --git a/src/effects/throw_spiny.c b/src/effects/throw_spiny.c
index 30e950cb3a..153278068a 100644
--- a/src/effects/throw_spiny.c
+++ b/src/effects/throw_spiny.c
@@ -8,11 +8,11 @@ void throw_spiny_init(EffectInstance* effect);
 void throw_spiny_update(EffectInstance* effect);
 void throw_spiny_render(EffectInstance* effect);
 
-extern Gfx D_09000800[];
-extern Gfx D_090008D8[];
-extern Gfx D_090009F0[];
+extern Gfx D_09000800_3D02F0[];
+extern Gfx D_090008D8_3D03C8[];
+extern Gfx D_090009F0_3D04E0[];
 
-Gfx* D_E00C8710[2] = { D_09000800, D_090008D8 };
+Gfx* D_E00C8710[2] = { D_09000800_3D02F0, D_090008D8_3D03C8 };
 
 u8 D_E00C8718[8] = { 110, 150, 130, 110, 100, 95, 100, 0 };
 u8 D_E00C8720[8] = { 80, 60, 80, 100, 120, 110, 100, 0 };
@@ -207,6 +207,6 @@ void throw_spiny_appendGfx(void* effect) {
     gSPMatrix(gMasterGfxPos++, camera->unkMatrix, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
     gDPSetPrimColor(gMasterGfxPos++, 0, 0, data->unk_30, data->unk_34, data->unk_38, temp_s5);
     gSPDisplayList(gMasterGfxPos++, D_E00C8710[temp_s6]);
-    gSPDisplayList(gMasterGfxPos++, D_090009F0);
+    gSPDisplayList(gMasterGfxPos++, D_090009F0_3D04E0);
     gSPPopMatrix(gMasterGfxPos++, G_MTX_MODELVIEW);
 }
diff --git a/src/pause/pause_gfx.c b/src/pause/pause_gfx.c
index 831b2fe7ea..e6bdfc1cc5 100644
--- a/src/pause/pause_gfx.c
+++ b/src/pause/pause_gfx.c
@@ -230,7 +230,7 @@ Gfx gPauseDLArrows[] = {
     gsDPSetTextureFilter(G_TF_POINT),
     gsDPSetTextureConvert(G_TC_FILT),
     gsDPSetTextureLUT(G_TT_NONE),
-    gsDPLoadTextureTile_4b(pause_map_arrows_png, G_IM_FMT_IA, pause_map_arrows_png_width, pause_map_arrows_png_height, 0, 0, pause_map_arrows_png_width - 1, pause_map_arrows_png_height - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, 4, 6, G_TX_NOLOD, G_TX_NOLOD),
+    gsDPLoadTextureTile_4b(pause_arrows_png, G_IM_FMT_IA, pause_arrows_png_width, pause_arrows_png_height, 0, 0, pause_arrows_png_width - 1, pause_arrows_png_height - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, 4, 6, G_TX_NOLOD, G_TX_NOLOD),
     gsDPSetRenderMode(AA_EN | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM), AA_EN | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM)),
     gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA),
     gsSPClearGeometryMode(G_LIGHTING),
diff --git a/src/state_file_select.c b/src/state_file_select.c
index 263a2fb0ac..cf313341fb 100644
--- a/src/state_file_select.c
+++ b/src/state_file_select.c
@@ -8,15 +8,15 @@
 s32 D_80077980[] = { &D_8038F800, &D_803B5000, &heap_battleHead, };
 
 NUPiOverlaySegment D_8007798C = {
-    .romStart = _163400_ROM_START,
-    .romEnd = _163400_ROM_END,
-    .ramStart = _163400_VRAM,
-    .textStart = _163400_TEXT_START,
-    .textEnd = _163400_TEXT_END,
-    .dataStart = _163400_DATA_START,
-    .dataEnd = _163400_DATA_END,
-    .bssStart = _163400_BSS_START,
-    .bssEnd = _163400_BSS_END,
+    .romStart = filemenu_ROM_START,
+    .romEnd = filemenu_ROM_END,
+    .ramStart = filemenu_VRAM,
+    .textStart = filemenu_TEXT_START,
+    .textEnd = filemenu_TEXT_END,
+    .dataStart = filemenu_DATA_START,
+    .dataEnd = filemenu_DATA_END,
+    .bssStart = filemenu_BSS_START,
+    .bssEnd = filemenu_BSS_END,
 };
 
 u8 D_800779B0 = 0;
diff --git a/tools/build/bin_inc_c.py b/tools/build/bin_inc_c.py
index 1fb59ca5a3..42401d2dec 100644
--- a/tools/build/bin_inc_c.py
+++ b/tools/build/bin_inc_c.py
@@ -1,19 +1,11 @@
 #! /usr/bin/python3
 
+from pathlib import Path
 from sys import argv
 import re
-import png
 
 if __name__ == "__main__":
-    infile, outfile = argv[1:]
-
-    cname = re.sub(r"[^0-9a-zA-Z_]", "_", outfile)
-
-    if cname.startswith("ver_"):
-        cname = "_".join(cname.split("_")[2:])
-
-    cname = re.sub(r"^build_include_", "", cname)
-    cname = re.sub(r"_inc_c$", "", cname)
+    infile, outfile, cname = argv[1:]
 
     with open(outfile, "w") as f:
         f.write(f"unsigned char {cname}[] = {{")
diff --git a/tools/build/configure.py b/tools/build/configure.py
index c12ba578c1..154e121373 100755
--- a/tools/build/configure.py
+++ b/tools/build/configure.py
@@ -140,12 +140,12 @@ def write_ninja_rules(ninja: ninja_syntax.Writer, cpp: str, cppflags: str, extra
 
     ninja.rule("img_header",
         description="img_header $in",
-        command=f"$python {BUILD_TOOLS}/img/header.py $in $out",
+        command=f"$python {BUILD_TOOLS}/img/header.py $in $out $c_name",
     )
 
     ninja.rule("bin_inc_c",
         description="bin_inc_c $out",
-        command=f"$python {BUILD_TOOLS}/bin_inc_c.py $in $out",
+        command=f"$python {BUILD_TOOLS}/bin_inc_c.py $in $out $c_name",
     )
 
     ninja.rule("yay0",
@@ -231,7 +231,7 @@ class Configure:
 
         modes = ["ld"]
         if assets:
-            modes.extend(["bin", "Yay0", "img", "vtx", "pm_map_data", "pm_msg", "pm_npc_sprites", "pm_charset",
+            modes.extend(["bin", "Yay0", "img", "vtx", "gfx", "pm_map_data", "pm_msg", "pm_npc_sprites", "pm_charset",
                           "pm_charset_palettes", "pm_effect_loads", "pm_effect_shims"])
         if code:
             modes.extend(["code", "c", "data", "rodata"])
@@ -409,8 +409,12 @@ class Configure:
                                 "img_flags": flags,
                             })
 
-                            build(inc_dir / (seg.name + ".png.h"), src_paths, "img_header")
-                            build(inc_dir / (seg.name + ".png.inc.c"), [bin_path], "bin_inc_c")
+                            c_sym = seg.create_symbol(
+                                addr=seg.vram_start, in_segment=True, type="data", define=True
+                            )
+                            vars = {"c_name": c_sym.name}
+                            build(inc_dir / (seg.name + ".png.h"), src_paths, "img_header", vars)
+                            build(inc_dir / (seg.name + ".png.inc.c"), [bin_path], "bin_inc_c", vars)
                         elif isinstance(seg, segtypes.n64.palette.N64SegPalette):
                             src_paths = [seg.out_path().relative_to(ROOT)]
                             inc_dir = self.build_path() / "include" / seg.dir
@@ -420,7 +424,12 @@ class Configure:
                                 "img_type": seg.type,
                                 "img_flags": "",
                             })
-                            build(inc_dir / (seg.name + ".pal.inc.c"), [bin_path], "bin_inc_c")
+
+                            c_sym = seg.create_symbol(
+                                addr=seg.vram_start, in_segment=True, type="data", define=True
+                            )
+                            vars = {"c_name": c_sym.name}
+                            build(inc_dir / (seg.name + ".pal.inc.c"), [bin_path], "bin_inc_c", vars)
             elif isinstance(seg, segtypes.common.bin.CommonSegBin):
                 build(entry.object_path, entry.src_paths, "bin")
             elif isinstance(seg, segtypes.n64.Yay0.N64SegYay0):
@@ -443,6 +452,10 @@ class Configure:
                 })
                 build(entry.object_path, [bin_path], "bin")
 
+                # c_sym = seg.create_symbol(
+                #     addr=seg.vram_start, in_segment=True, type="data", define=True
+                # )
+                # vars = {"c_name": c_sym.name}
                 build(inc_dir / (seg.name + ".png.h"), entry.src_paths, "img_header")
             elif isinstance(seg, segtypes.n64.palette.N64SegPalette):
                 bin_path = entry.object_path.with_suffix(".bin")
diff --git a/tools/build/img/header.py b/tools/build/img/header.py
index 452e0758aa..7e9fc0e8a4 100755
--- a/tools/build/img/header.py
+++ b/tools/build/img/header.py
@@ -5,21 +5,24 @@ import re
 import png
 
 if __name__ == "__main__":
-    infile, outfile = argv[1:]
+    infile, outfile = argv[1:3]
+
+    if len(argv) > 3:
+        cname = argv[3]
+    else:
+        cname = re.sub(r"[^0-9a-zA-Z_]", "_", infile)
+
+        if cname.startswith("ver_"):
+            cname = "_".join(cname.split("_")[2:])
+
+        if cname.startswith("src_"):
+            cname = cname[4:]
+        elif cname.startswith("assets_"):
+            cname = "_".join(cname.split("_")[2:])
 
     img = png.Reader(infile)
     width, height, rows, info = img.read()
 
-    cname = re.sub(r"[^0-9a-zA-Z_]", "_", infile)
-
-    if cname.startswith("ver_"):
-        cname = "_".join(cname.split("_")[2:])
-
-    if cname.startswith("src_"):
-        cname = cname[4:]
-    elif cname.startswith("assets_"):
-        cname = "_".join(cname.split("_")[2:])
-
     with open(outfile, "w") as f:
         f.write("// Generated file, do not edit.\n")
         f.write(f"#ifndef _{cname.upper()}_\n")
diff --git a/tools/splat/.github/workflows/mypy.yml b/tools/splat/.github/workflows/mypy.yml
index 7c786dd0b7..1896b3b7f2 100644
--- a/tools/splat/.github/workflows/mypy.yml
+++ b/tools/splat/.github/workflows/mypy.yml
@@ -10,10 +10,10 @@ jobs:
     name: mypy
     steps:
     - uses: actions/checkout@v1
-    - name: Set up Python 3.9
+    - name: Set up Python 3.8
       uses: actions/setup-python@v1
       with:
-        python-version: 3.9
+        python-version: 3.8
     - name: Install Dependencies
       run: |
         pip install mypy
diff --git a/tools/splat/.gitrepo b/tools/splat/.gitrepo
index 3231d7a49f..3a429c982b 100644
--- a/tools/splat/.gitrepo
+++ b/tools/splat/.gitrepo
@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/ethteck/splat.git
 	branch = master
-	commit = a847090eac32ef0d9cf183cd8f04e2452a0e250b
-	parent = 3e71bb8cea31e9e5a87f2f251e99d55daa0f902e
+	commit = aa71299594b8f864f9af9c22823c64a9c9189706
+	parent = d0b02e98a6bf6773e3c4f4ca7f1e203c86aaf6df
 	method = merge
 	cmdver = 0.4.3
diff --git a/tools/splat/CHANGELOG.md b/tools/splat/CHANGELOG.md
index e2531cd5e3..859d462374 100644
--- a/tools/splat/CHANGELOG.md
+++ b/tools/splat/CHANGELOG.md
@@ -1,5 +1,65 @@
 # splat Release Notes
 
+## 0.9.0: The Big Update
+### Introducing [spimdisasm](https://github.com/Decompollaborate/spimdisasm)!
+* Thanks to [AngheloAlf](https://github.com/AngheloAlf), we now have a much better MIPS disassembler in splat! spimdisasm has much better hi/lo matching, much lower ram usage, and plenty of other goodies.
+
+We plan to roll this out in phases. Currently, it only handles actual code disassembly. Later on, we will probably migrate our current data assembly code to use spimdisasm as well.
+
+**NOTICE**: This integration has been tested on a variety of games and configurations. However, with any giant change to the platform like this, there are bound to be things we didn't catch. Please be patient with us as we handle these remaining issues. Though from what we've seen already, the slight bugs one may come across are totally worth the much improved disassembly.
+
+### gfx segment type
+* A new `gfx` segment type is available, which creates a c file containing a disassembled display list according to the segment's start and end offsets. Thanks to [Glank](https://github.com/glankk) and [Tharo](https://github.com/thar0/) for their work on [libgfxd](https://github.com/glankk/libgfxd) and [pygfxd](https://github.com/thar0/pygfxd/), respectively, for helping make this a possibility in splat.
+
+### API breaking changes
+* Some `Segment()` arguments have changed, which may cause extensions to break. Please see the `__init__` function for `Segment` for more details.
+
+### symbol_addrs.txt changes
+* symbol_addrs now supports the `segment:` attribute, which allows specifying the symbol's top-level segment. This can be helpful for symbol resolution when overlays use overlapping vram ranges. See `exclusive_ram_id` below for more information.
+
+### Global options changes
+
+The new `symbol_name_format` option allows specification of how symbols will be named. This can be set as a global option and also changed per-segment. `symbol_norom_name_format` is used when the symbol does not have a rom address (BSS).
+
+ The following substitutions are allowed:
+
+`$ROM` - the rom address of the symbol, hex-formatted and padded to 6 characters (ABCF10, 000030, 123456) (note: only for `symbol_name_format`, usage in `symbol_norom_name_format` will cause an error)
+
+`$VRAM` - the vram address of the symbol, hex-formatted and padded to 8 characters (00030010, 00020015, ABCDEF10)
+
+`$SEG` - the name of the top-level segment in which the symbol resides
+
+The default values for these options are as follows
+
+`symbol_name_format` : `$VRAM_$ROM`
+
+`symbol_noram_name_format` : `$VRAM_$SEG`
+
+The appropriate prefix string will still automatically be applied depending on the type of the symbol: `D_` for data, `jtbl_` for jump tables, and `func_` for functions. This functionality may be customizable in the future.
+
+----
+The `auto_all_section` option now should be a list of section names (`[".data", ".rodata", ".bss"]` by default) indicating the sections that should be linked from .o files built from source files (.c or asm/hasm .s files), when no subsegment explicitly indicates linking this type of section.
+
+For example, if any subsegment of a code segment is of segment type `data` or `.data`, the `.data` section from all `c`/`asm`/`hasm` subsegments will not be linked unless explicitly indicated with a relevant `.data` subsegment.
+
+Previously, this option was a bool, and it enabled this feature for all sections specified in `section_order`. Now, the desired sections must be specified manually. The default value for this option retains previous behavior.
+
+----
+The new `mips_abi_float_regs` option allows for changing the format of float registers for MIPS disassembly. The default value does not change any prior behavior, but `o32` is heavily encouraged and may become the default option in the future. For more information, see this [great writeup](https://gist.github.com/EllipticEllipsis/27eef11205c7a59d8ea85632bc49224d).
+
+----
+The new `gfx_ucode` option allows for specifying the target for the graphics macro format, which is used in the gfx segment type. The default is `f3dex2`.
+
+
+### Segment options changes
+
+The new `exclusive_ram_id` segment option allows specifying an identifer that will prevent the segment from seeing any symbols from other segments with the same identifer. This is useful when multiple segments are mapped to the same vram address at runtime and should never be able to refer to each other's symbols. Setting all of these segments to have the same value for this option will prevent their symbols from clashing / meshing unexpectedly.
+
+----
+
+The `overlay` setting on segments has been removed. Please see `symbol_name_format` above for info on how to influence the names of symbols, which can be applied at the segment level as well as the global level.
+
+----
 ## 0.8.0: Arbitrary Section Order
 * You can now use the option `section_order` to define the binary section order for your target binary. By default, this is `[".text", ".data", ".rodata", ".bss"]`. See options.py for more details
 * Documented all options in options.py
@@ -30,7 +90,7 @@
 
 * Fixed a bug involving detection of defined functions in c files for GLOBAL_ASM-using projects
 * Added options to disable the creation of undefined_funcs/syms_auto.txt files
-* Add a Vtx segment type for creating c files containg model vertex data in the n64 libultra Vtx format
+* Added a Vtx segment type for creating c files containg model vertex data in the n64 libultra Vtx format
 * Added a `cpp` segment type which is identical to `c` but looks for a file with the extension ".cpp" instead of ".c".
 
 ### 0.7.5: all_ types and auto_all_sections
diff --git a/tools/splat/README.md b/tools/splat/README.md
index 0afbefdbe4..0dbd7b0fa8 100644
--- a/tools/splat/README.md
+++ b/tools/splat/README.md
@@ -3,9 +3,7 @@ A binary splitting tool to assist with decompilation and modding projects
 
 Currently, only N64 and PSX binaries are supported.
 
-The Makefile `setup` target calls splat with a config file that you can use for reference.
-
 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.
 
 ### Requirements
-Python package requirements can be installed via `pip3 install -r requirements.txt`
+splat requires Python 3.8+. Package requirements can be installed via `pip3 install -r requirements.txt`
diff --git a/tools/splat/create_config.py b/tools/splat/create_config.py
index f11a9b0e92..fb16441d0d 100755
--- a/tools/splat/create_config.py
+++ b/tools/splat/create_config.py
@@ -1,5 +1,6 @@
 #! /usr/bin/env python3
 
+import sys
 import argparse
 from pathlib import Path
 
@@ -9,11 +10,17 @@ parser = argparse.ArgumentParser(description="Create a splat config from an N64
 parser.add_argument("rom", help="Path to a .z64/.n64 ROM")
 
 
-def main(rom_path):
-    rom = rominfo.get_info(rom_path)
+def main(rom_path: Path):
+    if not rom_path.exists():
+        sys.exit(f"ROM file {rom_path} does not exist ({rom_path.absolute()})")
+    if rom_path.is_dir():
+        sys.exit(f"Path {rom_path} is a directory ({rom_path.absolute()})")
+    rom_bytes = rominfo.read_rom(rom_path)
+
+    rom = rominfo.get_info(rom_path, rom_bytes)
     basename = rom.name.replace(" ", "").lower()
 
-    header = f"""
+    header = f"""\
 name: {rom.name.title()} ({rom.get_country_name()})
 sha1: {rom.sha1}
 options:
@@ -24,7 +31,9 @@ options:
   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
   # undefined_syms_path: undefined_syms.txt
@@ -32,15 +41,14 @@ options:
   # src_path: src
   # build_path: build
   # extensions_path: tools/splat_ext
-  # auto_all_sections: True
-""".lstrip()
+  # mips_abi_float_regs: o32
+  # section_order: [".text", ".data", ".rodata", ".bss"]
+  # auto_all_sections: [".data", ".rodata", ".bss"]
+"""
 
-    with open(rom_path, "rb") as f:
-        fbytes = f.read()
+    first_section_end = find_code_length.run(rom_bytes, 0x1000, rom.entry_point)
 
-    first_section_end = find_code_length.run(fbytes, 0x1000, rom.entry_point)
-
-    segments = f"""
+    segments = f"""\
 segments:
   - name: header
     type: header
@@ -57,12 +65,13 @@ segments:
   - type: bin
     start: 0x{first_section_end:X}
   - [0x{rom.size:X}]
-""".lstrip()
+"""
 
     out_file = f"{basename}.yaml"
     with open(out_file, "w", newline="\n") as f:
         print(f"Writing config to {out_file}")
-        f.write(header + segments)
+        f.write(header)
+        f.write(segments)
 
 
 if __name__ == "__main__":
diff --git a/tools/splat/mypy.ini b/tools/splat/mypy.ini
index fdf05957c3..156b2a90b3 100644
--- a/tools/splat/mypy.ini
+++ b/tools/splat/mypy.ini
@@ -1,3 +1,3 @@
 [mypy]
 ignore_missing_imports = True
-mypy_path = stubs
\ No newline at end of file
+mypy_path = stubs
diff --git a/tools/splat/requirements.txt b/tools/splat/requirements.txt
index 58180b1fc0..f23d08d46f 100644
--- a/tools/splat/requirements.txt
+++ b/tools/splat/requirements.txt
@@ -2,4 +2,8 @@ PyYAML
 pylibyaml
 pypng
 colorama
-capstone
+spimdisasm>=1.2.1
+rabbitizer
+pygfxd
+tqdm
+intervaltree
diff --git a/tools/splat/segtypes/common/asm.py b/tools/splat/segtypes/common/asm.py
index 0490e61294..b8aa69462e 100644
--- a/tools/splat/segtypes/common/asm.py
+++ b/tools/splat/segtypes/common/asm.py
@@ -15,7 +15,7 @@ class CommonSegAsm(CommonSegCodeSubsegment):
             and self.rom_end != "auto"
             and self.rom_start != self.rom_end
         ):
-            self.funcs_text = self.scan_code(rom_bytes, is_asm=True)
+            self.scan_code(rom_bytes, is_asm=True)
 
     def get_file_header(self):
         return []
@@ -26,16 +26,9 @@ class CommonSegAsm(CommonSegCodeSubsegment):
             if out_path:
                 out_path.parent.mkdir(parents=True, exist_ok=True)
 
-                out_lines = self.get_file_header()
+                self.print_file_boundaries()
 
-                self.funcs_text = self.split_code(rom_bytes)
-
-                for func in self.funcs_text:
-                    out_lines.extend(self.funcs_text[func][0])
-                    out_lines.append("")
-
-                self.split_write(out_path, out_lines)
-
-    def split_write(self, out_path, out_lines):
-        with open(out_path, "w", newline="\n") as f:
-            f.write("\n".join(out_lines))
+                with open(out_path, "w", newline="\n") as f:
+                    for line in self.get_file_header():
+                        f.write(line + "\n")
+                    f.write(self.text_section.disassemble())
diff --git a/tools/splat/segtypes/common/bss.py b/tools/splat/segtypes/common/bss.py
index 35bbfef6f7..195409aca8 100644
--- a/tools/splat/segtypes/common/bss.py
+++ b/tools/splat/segtypes/common/bss.py
@@ -1,6 +1,9 @@
 from segtypes.common.data import CommonSegData
+from segtypes.linker_entry import LinkerEntry
 from util import options, log
 
+from typing import List
+
 
 class CommonSegBss(CommonSegData):
     def get_linker_section(self) -> str:
@@ -12,12 +15,14 @@ class CommonSegBss(CommonSegData):
     def split(self, rom_bytes: bytes):
         pass
 
-    def get_linker_entries(self):
-        from segtypes.linker_entry import LinkerEntry
+    def get_linker_entries(self) -> "List[LinkerEntry]":
 
         if self.sibling:
             path = self.sibling.out_path()
         else:
-            path = options.get_src_path() / self.name
+            path = self.out_path()
 
-        return [LinkerEntry(self, [path], path, self.get_linker_section())]
+        if path:
+            return [LinkerEntry(self, [path], path, self.get_linker_section())]
+        else:
+            return []
diff --git a/tools/splat/segtypes/common/c.py b/tools/splat/segtypes/common/c.py
index bfca20e792..1cdac143de 100644
--- a/tools/splat/segtypes/common/c.py
+++ b/tools/splat/segtypes/common/c.py
@@ -4,6 +4,8 @@ from typing import Optional, Set
 import os
 import re
 from pathlib import Path
+import spimdisasm
+import rabbitizer
 
 from util import log, options
 from util.compiler import GCC, SN64
@@ -122,26 +124,25 @@ class CommonSegC(CommonSegCodeSubsegment):
             asm_out_dir = options.get_nonmatchings_path() / self.dir
             asm_out_dir.mkdir(parents=True, exist_ok=True)
 
-            is_new_c_file = False
+            self.print_file_boundaries()
 
-            self.funcs_text = self.split_code(rom_bytes)
+            is_new_c_file = False
 
             c_path = self.out_path()
             if c_path:
                 if not os.path.exists(c_path) and options.get_create_c_files():
-                    self.create_c_file(self.funcs_text, asm_out_dir, c_path)
+                    self.create_c_file(asm_out_dir, c_path)
                     is_new_c_file = True
 
-            for func_addr in self.funcs_text:
-                func_sym = self.parent.get_symbol(
-                    func_addr, type="func", local_only=True
+            for func in self.text_section.symbolList:
+                assert func.vram is not None
+                func_sym = self.get_symbol(
+                    func.vram, in_segment=True, type="func", local_only=True
                 )
                 assert func_sym is not None
 
-                if func_sym.name in self.global_asm_funcs or is_new_c_file:
-                    self.create_c_asm_file(
-                        self.funcs_text, func_addr, asm_out_dir, func_sym
-                    )
+                if func.getName() in self.global_asm_funcs or is_new_c_file:
+                    self.create_c_asm_file(func, asm_out_dir, func_sym)
 
     def get_c_preamble(self):
         ret = []
@@ -155,8 +156,8 @@ class CommonSegC(CommonSegCodeSubsegment):
     def mark_c_funcs_as_defined(self, c_funcs):
         for func_name in c_funcs:
             found = False
-            for func_addr in self.seg_symbols:
-                for symbol in self.seg_symbols[func_addr]:
+            for symbols in self.seg_symbols.values():
+                for symbol in symbols:
                     if symbol.name == func_name:
                         symbol.defined = True
                         found = True
@@ -164,8 +165,11 @@ class CommonSegC(CommonSegCodeSubsegment):
                 if found:
                     break
 
-    def create_c_asm_file(self, funcs_text, func_addr, out_dir, func_sym: Symbol):
+    def create_c_asm_file(
+        self, func: spimdisasm.mips.symbols.SymbolBase, out_dir, func_sym: Symbol
+    ):
         outpath = Path(os.path.join(out_dir, self.name, func_sym.name + ".s"))
+        assert func.vram is not None
 
         # Skip extraction if the file exists and the symbol is marked as extract=false
         if outpath.exists() and not func_sym.extract:
@@ -179,10 +183,10 @@ class CommonSegC(CommonSegCodeSubsegment):
         if self.parent and isinstance(self.parent, CommonSegGroup):
             if (
                 options.get_migrate_rodata_to_functions()
-                and func_addr in self.parent.rodata_syms
+                and func.vram in self.parent.rodata_syms
             ):
                 func_rodata = list(
-                    {s for s in self.parent.rodata_syms[func_addr] if s.disasm_str}
+                    {s for s in self.parent.rodata_syms[func.vram] if s.disasm_str}
                 )
                 func_rodata.sort(key=lambda s: s.vram_start)
 
@@ -205,8 +209,7 @@ class CommonSegC(CommonSegCodeSubsegment):
                         out_lines.append(".section .text")
                         out_lines.append("")
 
-        out_lines.extend(funcs_text[func_addr][0])
-        out_lines.append("")
+        out_lines.append(func.disassemble())
 
         outpath.parent.mkdir(parents=True, exist_ok=True)
 
@@ -215,21 +218,19 @@ class CommonSegC(CommonSegCodeSubsegment):
             f.write(newline_sep.join(out_lines))
         self.log(f"Disassembled {func_sym.name} to {outpath}")
 
-    def create_c_file(self, funcs_text, asm_out_dir, c_path):
+    def create_c_file(self, asm_out_dir, c_path):
         c_lines = self.get_c_preamble()
 
-        for func in funcs_text:
-            func_name = self.parent.get_symbol(func, type="func", local_only=True).name
+        for func in self.text_section.symbolList:
+            assert isinstance(func, spimdisasm.mips.symbols.SymbolFunction)
 
             # Terrible hack to "auto-decompile" empty functions
-            # TODO move disassembly into funcs_text or somewhere we can access it from here
             if (
                 options.get_auto_decompile_empty_functions()
-                and len(funcs_text[func][0]) == 3
-                and funcs_text[func][0][1][-3:] in ["$ra", "$31"]
-                and funcs_text[func][0][2][-3:] == "nop"
+                and func.instructions[0].isJrRa()
+                and func.instructions[1].isNop()
             ):
-                c_lines.append("void " + func_name + "(void) {")
+                c_lines.append("void " + func.getName() + "(void) {")
                 c_lines.append("}")
             else:
                 if options.get_compiler() in [GCC, SN64]:
@@ -237,12 +238,16 @@ class CommonSegC(CommonSegCodeSubsegment):
                         rel_asm_out_dir = asm_out_dir.relative_to(
                             options.get_nonmatchings_path()
                         )
-                        c_lines.append(f'INCLUDE_ASM(s32, "{rel_asm_out_dir / self.name}", {func_name});')
+                        c_lines.append(
+                            f'INCLUDE_ASM(s32, "{rel_asm_out_dir / self.name}", {func.getName()});'
+                        )
                     else:
-                        c_lines.append(f'INCLUDE_ASM("{asm_out_dir / self.name}", {func_name});')
+                        c_lines.append(
+                            f'INCLUDE_ASM("{asm_out_dir / self.name}", {func.getName()});'
+                        )
                 else:
                     asm_outpath = Path(
-                        os.path.join(asm_out_dir, self.name, func_name + ".s")
+                        os.path.join(asm_out_dir, self.name, func.getName() + ".s")
                     )
                     rel_asm_outpath = os.path.relpath(
                         asm_outpath, options.get_base_path()
diff --git a/tools/splat/segtypes/common/code.py b/tools/splat/segtypes/common/code.py
index 47750e66b7..8f68e79aed 100644
--- a/tools/splat/segtypes/common/code.py
+++ b/tools/splat/segtypes/common/code.py
@@ -1,7 +1,15 @@
-from typing import Dict, Tuple
+from collections import OrderedDict
+from typing import Dict, List, Optional, Tuple
+import typing
 from segtypes.common.group import CommonSegGroup
+from segtypes.common.linker_section import dotless_type
+from segtypes.segment import RomAddr, Segment
+from util import log, options
+from util.range import Range
 from util.symbols import Symbol
 
+CODE_TYPES = ["c", "asm", "hasm"]
+
 # code group
 class CommonSegCode(CommonSegGroup):
     def __init__(
@@ -13,11 +21,15 @@ class CommonSegCode(CommonSegGroup):
         vram_start,
         extract,
         given_subalign,
-        given_is_overlay,
+        exclusive_ram_id,
         given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
         args,
         yaml,
     ):
+        self.bss_size: int = yaml.get("bss_size", 0) if isinstance(yaml, dict) else 0
+
         super().__init__(
             rom_start,
             rom_end,
@@ -26,30 +38,295 @@ class CommonSegCode(CommonSegGroup):
             vram_start,
             extract,
             given_subalign,
-            given_is_overlay,
-            given_dir,
-            args,
-            yaml,
+            exclusive_ram_id=exclusive_ram_id,
+            given_dir=given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
         )
 
         self.reported_file_split = False
-        self.labels_to_add = set()
         self.jtbl_glabels_to_add = set()
-        self.jtbl_jumps = {}
         self.jumptables: Dict[int, Tuple[int, int]] = {}
+        self.rodata_syms: Dict[int, List[Symbol]] = {}
 
     @property
     def needs_symbols(self) -> bool:
         return True
 
+    @property
+    def vram_end(self) -> Optional[int]:
+        if self.vram_start is not None and self.size is not None:
+            return self.vram_start + self.size + self.bss_size
+        else:
+            return None
+
+    # def ram_to_rom(self, ram_addr: int) -> Optional[int]:
+    #     size_no_bss = self.vram_start + self.size
+
+    #     # Do not return a rom address if this is a BSS symbol
+    #     if ram_addr > size_no_bss:
+    #         return None
+
+    #     if not self.contains_vram(ram_addr) and ram_addr != self.vram_end:
+    #         return None
+
+    #     if self.vram_start is not None and isinstance(self.rom_start, int):
+    #         return self.rom_start + ram_addr - self.vram_start
+    #     else:
+    #         return None
+
     # Prepare symbol for migration to the function
     def check_rodata_sym(self, func_addr: int, sym: Symbol):
         if self.section_boundaries[".rodata"].is_complete():
-            if (
-                self.section_boundaries[".rodata"].start
-                <= sym.vram_start
-                < self.section_boundaries[".rodata"].end
-            ):
+            assert self.section_boundaries[".rodata"].start is not None
+            assert self.section_boundaries[".rodata"].end is not None
+
+            rodata_start: int = self.section_boundaries[".rodata"].start
+            rodata_end: int = self.section_boundaries[".rodata"].end
+            if rodata_start <= sym.vram_start < rodata_end:
                 if func_addr not in self.rodata_syms:
                     self.rodata_syms[func_addr] = []
                 self.rodata_syms[func_addr].append(sym)
+
+    def handle_alls(self, segs: List[Segment], base_segs) -> bool:
+        for i, elem in enumerate(segs):
+            if elem.type.startswith("all_"):
+                alls = []
+
+                rep_type = f"{elem.type[4:]}"
+                replace_class = Segment.get_class_for_type(rep_type)
+
+                for base in base_segs.items():
+                    if isinstance(elem.rom_start, int) and isinstance(
+                        self.rom_start, int
+                    ):
+                        # Shoddy rom to ram
+                        vram_start = elem.rom_start - self.rom_start + self.vram_start
+                    else:
+                        vram_start = "auto"
+                    rep: Segment = replace_class(
+                        rom_start=elem.rom_start,
+                        rom_end=elem.rom_end,
+                        type=rep_type,
+                        name=base[0],
+                        vram_start=vram_start,
+                        extract=False,
+                        given_subalign=self.given_subalign,
+                        exclusive_ram_id=self.get_exclusive_ram_id(),
+                        given_dir=self.given_dir,
+                        symbol_name_format=self.symbol_name_format,
+                        symbol_name_format_no_rom=self.symbol_name_format_no_rom,
+                        args=[],
+                        yaml={},
+                    )
+                    rep.sibling = base[1]
+                    rep.parent = self
+                    alls.append(rep)
+
+                # Insert alls into segs at i
+                del segs[i]
+                segs[i:i] = alls
+                return True
+        return False
+
+    # Find places we should automatically add "all_data" / "all_rodata" / "all_bss"
+    def find_inserts(
+        self, found_sections: typing.OrderedDict[str, Range]
+    ) -> "OrderedDict[str, int]":
+        inserts: OrderedDict[str, int] = OrderedDict()
+
+        section_order = self.section_order.copy()
+        section_order.remove(".text")
+
+        for i, section in enumerate(section_order):
+            if section not in options.auto_all_sections():
+                continue
+
+            if not found_sections[section].has_start():
+                search_done = False
+                for j in range(i - 1, -1, -1):
+                    end = found_sections[section_order[j]].end
+                    if end is not None:
+                        inserts[section] = end
+                        search_done = True
+                        break
+                if not search_done:
+                    inserts[section] = -1
+                    pass
+
+        return inserts
+
+    def parse_subsegments(self, segment_yaml) -> List[Segment]:
+        base_segments: OrderedDict[str, Segment] = OrderedDict()
+        ret = []
+        prev_start: RomAddr = -1
+        inserts: OrderedDict[
+            str, int
+        ] = (
+            OrderedDict()
+        )  # Used to manually add "all_" types for sections not otherwise defined in the yaml
+
+        self.section_boundaries = OrderedDict(
+            (s_name, Range()) for s_name in options.get_section_order()
+        )
+
+        found_sections = OrderedDict(
+            (s_name, Range()) for s_name in self.section_boundaries
+        )  # Stores yaml index where a section was first found
+        found_sections.pop(".text")
+
+        if "subsegments" not in segment_yaml:
+            return []
+
+        # Mark any manually added dot types
+        cur_section = None
+
+        for i, subsection_yaml in enumerate(segment_yaml["subsegments"]):
+            # rompos marker
+            if isinstance(subsection_yaml, list) and len(subsection_yaml) == 1:
+                continue
+
+            typ = Segment.parse_segment_type(subsection_yaml)
+            if typ.startswith("all_"):
+                typ = typ[4:]
+            if not typ.startswith("."):
+                typ = f".{typ}"
+
+            if typ in found_sections:
+                if cur_section is None:
+                    # Starting point
+                    found_sections[typ].start = i
+                    cur_section = typ
+                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!"
+                            )
+
+                        # End the current section
+                        found_sections[cur_section].end = i
+
+                        # Start the next section
+                        found_sections[typ].start = i
+                        cur_section = typ
+
+        if cur_section is not None:
+            found_sections[cur_section].end = -1
+
+        inserts = self.find_inserts(found_sections)
+
+        for i, subsection_yaml in enumerate(segment_yaml["subsegments"]):
+            # rompos marker
+            if isinstance(subsection_yaml, list) and len(subsection_yaml) == 1:
+                continue
+
+            typ = Segment.parse_segment_type(subsection_yaml)
+            start = Segment.parse_segment_start(subsection_yaml)
+
+            # Add dummy segments to be expanded later
+            if typ.startswith("all_"):
+                ret.append(Segment(start, "auto", typ, "", "auto"))
+                continue
+
+            segment_class = Segment.get_class_for_type(typ)
+
+            end = self.get_next_seg_start(i, segment_yaml["subsegments"])
+
+            if (
+                isinstance(start, int)
+                and isinstance(prev_start, int)
+                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})"
+                )
+
+            vram = None
+            if start != "auto":
+                assert isinstance(start, int)
+                vram = self.get_most_parent().rom_to_ram(start)
+
+            segment: Segment = Segment.from_yaml(
+                segment_class, subsection_yaml, start, end, vram
+            )
+            segment.sibling = base_segments.get(segment.name, None)
+            segment.parent = self
+
+            for i, section in enumerate(self.section_order):
+                if not self.section_boundaries[section].has_start() and dotless_type(
+                    section
+                ) == dotless_type(segment.type):
+                    if i > 0:
+                        prev_section = self.section_order[i - 1]
+                        self.section_boundaries[prev_section].end = segment.vram_start
+                    self.section_boundaries[section].start = segment.vram_start
+
+            ret.append(segment)
+
+            # todo change
+            if typ in CODE_TYPES:
+                base_segments[segment.name] = segment
+
+            prev_start = start
+
+        # Add the automatic all_ sections
+        orig_len = len(ret)
+        for section in reversed(inserts):
+            idx = inserts[section]
+
+            if idx == -1:
+                idx = orig_len
+
+            # bss hack TODO maybe rethink
+            if section == "bss" and self.vram_start is not None:
+                rom_start = self.rom_end
+                vram_start = self.vram_start + self.rom_end - self.rom_start
+            else:
+                rom_start = "auto"
+                vram_start = "auto"
+
+            ret.insert(
+                idx,
+                (
+                    Segment(
+                        rom_start,
+                        "auto",
+                        "all_" + section,
+                        "",
+                        vram_start,
+                    )
+                ),
+            )
+
+        check = True
+        while check:
+            check = self.handle_alls(ret, base_segments)
+
+        # TODO why is this necessary?
+        if (
+            self.section_boundaries[".rodata"].has_start()
+            and not self.section_boundaries[".rodata"].has_end()
+        ):
+            assert self.vram_end is not None
+            self.section_boundaries[".rodata"].end = self.vram_end
+
+        return ret
+
+    def scan(self, rom_bytes):
+        # Always scan code first
+        for sub in self.subsegments:
+            if sub.type in CODE_TYPES 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():
+                sub.scan(rom_bytes)
diff --git a/tools/splat/segtypes/common/codesubsegment.py b/tools/splat/segtypes/common/codesubsegment.py
index c03bf533e8..da6b4d548a 100644
--- a/tools/splat/segtypes/common/codesubsegment.py
+++ b/tools/splat/segtypes/common/codesubsegment.py
@@ -1,77 +1,39 @@
-from dataclasses import dataclass
-from typing import List, Optional
-import typing
 from util import options
 from segtypes.common.code import CommonSegCode
-from collections import OrderedDict
-import re
-
-from capstone import (
-    Cs,
-    CS_ARCH_MIPS,
-    CS_MODE_MIPS64,
-    CS_MODE_BIG_ENDIAN,
-    CS_MODE_MIPS32,
-    CS_MODE_LITTLE_ENDIAN,
-    CsInsn,
-)
-from capstone.mips import *
+import spimdisasm
+import rabbitizer
 
 from segtypes.segment import Segment
-from util.compiler import SN64
-from util.symbols import Instruction, Symbol
-from util import log
+from util.symbols import Symbol
+from util import symbols
+
 
 # abstract class for c, asm, data, etc
 class CommonSegCodeSubsegment(Segment):
-    double_mnemonics = ["ldc1", "sdc1"]
-    word_mnemonics = ["addiu", "sw", "lw", "jtbl"]
-    float_mnemonics = ["lwc1", "swc1"]
-    short_mnemonics = ["addiu", "lh", "sh", "lhu"]
-    byte_mnemonics = ["lb", "sb", "lbu"]
-    reg_numbers = {
-        "$zero": "$0",
-        "$at": "$1",
-        "$v0": "$2",
-        "$v1": "$3",
-        "$a0": "$4",
-        "$a1": "$5",
-        "$a2": "$6",
-        "$a3": "$7",
-        "$t0": "$8",
-        "$t1": "$9",
-        "$t2": "$10",
-        "$t3": "$11",
-        "$t4": "$12",
-        "$t5": "$13",
-        "$t6": "$14",
-        "$t7": "$15",
-        "$s0": "$16",
-        "$s1": "$17",
-        "$s2": "$18",
-        "$s3": "$19",
-        "$s4": "$20",
-        "$s5": "$21",
-        "$s6": "$22",
-        "$s7": "$23",
-        "$t8": "$24",
-        "$t9": "$25",
-        "$k0": "$26",
-        "$k1": "$27",
-        "$gp": "$28",
-        "$sp": "$sp",
-        "$fp": "$30",
-        "$ra": "$31",
-    }
-
-    if options.get_endianess() == "big":
-        capstone_mode = CS_MODE_MIPS64 | CS_MODE_BIG_ENDIAN
-    else:
-        capstone_mode = CS_MODE_MIPS32 | CS_MODE_LITTLE_ENDIAN
-
-    md = Cs(CS_ARCH_MIPS, capstone_mode)
-    md.detail = False
-    md.skipdata = True
+    double_mnemonics = [
+        rabbitizer.InstrId.cpu_ldc1,
+        rabbitizer.InstrId.cpu_sdc1,
+    ]
+    word_mnemonics = [
+        rabbitizer.InstrId.cpu_addiu,
+        rabbitizer.InstrId.cpu_sw,
+        rabbitizer.InstrId.cpu_lw,
+    ]
+    float_mnemonics = [
+        rabbitizer.InstrId.cpu_lwc1,
+        rabbitizer.InstrId.cpu_swc1,
+    ]
+    short_mnemonics = [
+        rabbitizer.InstrId.cpu_addiu,
+        rabbitizer.InstrId.cpu_lh,
+        rabbitizer.InstrId.cpu_sh,
+        rabbitizer.InstrId.cpu_lhu,
+    ]
+    byte_mnemonics = [
+        rabbitizer.InstrId.cpu_lb,
+        rabbitizer.InstrId.cpu_sb,
+        rabbitizer.InstrId.cpu_lbu,
+    ]
 
     @property
     def needs_symbols(self) -> bool:
@@ -80,545 +42,148 @@ class CommonSegCodeSubsegment(Segment):
     def get_linker_section(self) -> str:
         return ".text"
 
-    @staticmethod
-    def is_nops(insns: List[CsInsn]) -> bool:
-        for insn in insns:
-            if insn.mnemonic != "nop":
-                return False
-        return True
-
-    @staticmethod
-    def is_branch_insn(mnemonic):
-        return (
-            mnemonic.startswith("b")
-            and not mnemonic.startswith("binsl")
-            and not mnemonic == "break"
-        ) or mnemonic == "j"
-
-    @staticmethod
-    def replace_reg_names(op_str):
-        for regname, regnum in CommonSegCodeSubsegment.reg_numbers.items():
-            op_str = op_str.replace(regname, regnum)
-        return op_str
-
     def scan_code(self, rom_bytes, is_asm=False):
-        insns: List[CsInsn] = [
-            insn
-            for insn in CommonSegCodeSubsegment.md.disasm(
-                rom_bytes[self.rom_start : self.rom_end], self.vram_start
-            )
-        ]
-
-        self.funcs: typing.OrderedDict[int, Symbol] = self.process_insns(
-            insns, self.rom_start, is_asm=is_asm
+        self.text_section = spimdisasm.mips.sections.SectionText(
+            symbols.spim_context,
+            self.rom_start,
+            self.rom_end,
+            self.vram_start,
+            self.name,
+            rom_bytes,
+            self.get_most_parent().rom_start,
+            self.get_exclusive_ram_id(),
         )
 
-        # TODO: set these in creation
-        for func in self.funcs.values():
-            func.define = True
-            func.local_only = True
-            func.size = len(func.insns) * 4
+        for symbol_list in self.seg_symbols.values():
+            symbols.add_symbol_to_spim_section(self.text_section, symbol_list[0])
 
-        self.determine_symbols()
+        for sym in symbols.all_symbols:
+            if sym.user_declared:
+                symbols.add_symbol_to_spim_section(self.text_section, sym)
 
-    def split_code(self, rom_bytes):
+        self.text_section.isHandwritten = is_asm
+
+        self.text_section.analyze()
+        self.text_section.setCommentOffset(self.rom_start)
+
+        for func in self.text_section.symbolList:
+            assert isinstance(func, spimdisasm.mips.symbols.SymbolFunction)
+
+            self.process_insns(func)
+
+        # Process jumptable labels and pass them to spimdisasm
         self.gather_jumptable_labels(rom_bytes)
-        return self.add_labels()
+        for jtbl_label_vram in self.parent.jtbl_glabels_to_add:
+            sym = self.create_symbol(
+                jtbl_label_vram, True, type="jtbl_label", define=True
+            )
+            sym.type = "jtbl_label"
+            symbols.add_symbol_to_spim_section(self.text_section, sym)
 
     def process_insns(
-        self, insns: List[CsInsn], rom_addr, is_asm=False
-    ) -> typing.OrderedDict[int, Symbol]:
+        self,
+        func_spim: spimdisasm.mips.symbols.SymbolFunction,
+    ):
         assert isinstance(self.parent, CommonSegCode)
+        assert func_spim.vram is not None
+        assert func_spim.vramEnd is not None
         self.parent: CommonSegCode = self.parent
 
-        ret: typing.OrderedDict[int, Symbol] = OrderedDict()
+        symbols.create_symbol_from_spim_symbol(
+            self.get_most_parent(), func_spim.contextSym
+        )
 
-        end_func = False
-        start_new_func = True
-        labels = []
-
-        big_endian = options.get_endianess() == "big"
-
-        # Collect labels
-        for insn in insns:
-            if self.is_branch_insn(insn.mnemonic):
-                op_str_split = insn.op_str.split(" ")
-                branch_target = op_str_split[-1]
-                branch_addr = int(branch_target, 0)
-                labels.append((insn.address, branch_addr))
+        # Gather symbols found by spimdisasm and create those symbols in splat's side
+        for referenced_vram in func_spim.instrAnalyzer.referencedVrams:
+            context_sym = self.text_section.getSymbol(
+                referenced_vram, tryPlusOffset=False
+            )
+            if context_sym is not None:
+                if context_sym.type == spimdisasm.common.SymbolSpecialType.jumptable:
+                    self.parent.jumptables[referenced_vram] = (
+                        func_spim.vram,
+                        func_spim.vramEnd,
+                    )
+                symbols.create_symbol_from_spim_symbol(
+                    self.get_most_parent(), context_sym
+                )
 
         # Main loop
-        for i, insn in enumerate(insns):
-            mnemonic = insn.mnemonic
-            op_str = insn.op_str
+        for i, insn in enumerate(func_spim.instructions):
+            instr_offset = i * 4
 
-            # If this is non-zero, disasm size insns
-            hard_size = 0
+            # update pointer accesses from this function
+            if instr_offset in func_spim.instrAnalyzer.symbolInstrOffset:
+                sym_address = func_spim.instrAnalyzer.symbolInstrOffset[instr_offset]
 
-            if start_new_func:
-                func: Symbol = self.parent.create_symbol(insn.address, type="func")
-                start_new_func = False
-
-            if func.size > 4:
-                hard_size = func.size / 4
-
-            if options.get_compiler() == SN64:
-                op_str = self.replace_reg_names(op_str)
-
-            if mnemonic == "move":
-                # Let's get the actual instruction out
-                idx = 3 if big_endian else 0
-                opcode = insn.bytes[idx] & 0b00111111
-
-                if options.get_compiler() == SN64:
-                    op_str += ", $0"
-                else:
-                    op_str += ", $zero"
-
-                if opcode == 37:
-                    mnemonic = "or"
-                elif opcode == 45:
-                    mnemonic = "daddu"
-                elif opcode == 33:
-                    mnemonic = "addu"
-                else:
-                    print("INVALID INSTRUCTION " + str(insn), opcode)
-            elif mnemonic == "jal":
-                jal_addr = int(op_str, 0)
-                jump_func = self.parent.create_symbol(
-                    jal_addr, type="func", reference=True
+                context_sym = self.text_section.getSymbol(
+                    sym_address, tryPlusOffset=False
                 )
-                op_str = jump_func.name
-            elif self.is_branch_insn(insn.mnemonic):
-                op_str_split = op_str.split(" ")
-                branch_target = op_str_split[-1]
-                branch_target_int = int(branch_target, 0)
+                if context_sym is not None:
+                    sym = symbols.create_symbol_from_spim_symbol(
+                        self.get_most_parent(), context_sym
+                    )
 
-                label_sym = self.parent.get_symbol(
-                    branch_target_int, type="label", reference=True, local_only=True
-                )
-
-                if label_sym:
-                    label_name = label_sym.name
-                else:
-                    self.parent.labels_to_add.add(branch_target_int)
-                    label_name = f".L{branch_target[2:].upper()}"
-
-                op_str = " ".join(op_str_split[:-1] + [label_name])
-            elif mnemonic in ["mtc0", "mfc0", "mtc2", "mfc2"]:
-                idx = 2 if big_endian else 1
-                rd = (insn.bytes[idx] & 0xF8) >> 3
-                op_str = op_str.split(" ")[0] + " $" + str(rd)
-            elif (
-                mnemonic == "break"
-                and op_str in ["6", "7"]
-                and options.get_compiler() == SN64
-                and not is_asm
-            ):
-                # SN64's assembler expands div to have break if dividing by zero
-                # However, the break it generates is different than the one it generates with `break N`
-                # So we replace break instrutions for SN64 with the exact word that the assembler generates when expanding div
-                if op_str == "6":
-                    mnemonic = ".word 0x0006000D"
-                    op_str = ""
-                elif op_str == "7":
-                    mnemonic = ".word 0x0007000D"
-                    op_str = ""
-            elif (
-                mnemonic in ["div", "divu"]
-                and options.get_compiler() == SN64
-                and not is_asm
-            ):
-                # SN64's assembler also doesn't like assembling `div $0, a, b` with .set noat active
-                # Removing the $0 fixes this issue
-                if op_str.startswith("$0, "):
-                    op_str = op_str[4:]
-
-            func.insns.append(Instruction(insn, mnemonic, op_str, rom_addr))
-            rom_addr += 4
-
-            size_remaining = hard_size - len(func.insns) if hard_size > 0 else 0
-
-            if mnemonic == "jr":
-                # Record potential jtbl jumps
-                if op_str not in ["$ra", "$31"]:
-                    self.parent.jtbl_jumps[insn.address] = op_str
-
-                keep_going = False
-                for label in labels:
-                    if (label[0] > insn.address and label[1] <= insn.address) or (
-                        label[0] <= insn.address and label[1] > insn.address
+                    if any(
+                        insn.uniqueId in mnemonics
+                        for mnemonics in (
+                            self.double_mnemonics,
+                            self.word_mnemonics,
+                            self.float_mnemonics,
+                            self.short_mnemonics,
+                            self.byte_mnemonics,
+                        )
                     ):
-                        keep_going = True
-                        break
-                if not keep_going and not size_remaining:
-                    end_func = True
-                    continue
+                        self.update_access_mnemonic(sym, insn)
 
-            # Stop here if a size was specified and we have disassembled up to the size
-            if hard_size > 0 and size_remaining == 0:
-                end_func = True
+                    if self.parent:
+                        self.parent.check_rodata_sym(func_spim.vram, sym)
 
-            if i < len(insns) - 1 and self.parent.get_symbol(
-                insns[i + 1].address, local_only=True, type="func", dead=False
-            ):
-                end_func = True
-
-            if end_func:
-                if (
-                    self.is_nops(insns[i:])
-                    or i < len(insns) - 1
-                    and insns[i + 1].mnemonic != "nop"
-                ):
-                    end_func = False
-                    start_new_func = True
-                    ret[func.vram_start] = func
-
-        # Add the last function (or append nops to the previous one)
-        if not self.is_nops([insn.instruction for insn in func.insns]):
-            ret[func.vram_start] = func
-        else:
-            next(reversed(ret.values())).insns.extend(func.insns)
-
-        return ret
-
-    def update_access_mnemonic(self, sym, mnemonic):
+    def update_access_mnemonic(self, sym: Symbol, insn: rabbitizer.Instruction):
         if not sym.access_mnemonic:
-            sym.access_mnemonic = mnemonic
-        elif sym.access_mnemonic == "addiu":
-            sym.access_mnemonic = mnemonic
+            sym.access_mnemonic = insn.uniqueId
         elif sym.access_mnemonic in self.double_mnemonics:
             return
         elif (
             sym.access_mnemonic in self.float_mnemonics
-            and mnemonic in self.double_mnemonics
+            and insn.uniqueId in self.double_mnemonics
         ):
-            sym.access_mnemonic = mnemonic
+            sym.access_mnemonic = insn.uniqueId
+        elif sym.access_mnemonic == rabbitizer.InstrId.cpu_addiu:
+            sym.access_mnemonic = insn.uniqueId
         elif sym.access_mnemonic in self.short_mnemonics:
             return
         elif sym.access_mnemonic in self.byte_mnemonics:
             return
         else:
-            sym.access_mnemonic = mnemonic
+            sym.access_mnemonic = insn.uniqueId
 
-    # Determine symbols
-    def determine_symbols(self):
-        hi_lo_max_distance = options.hi_lo_max_distance()
+    def print_file_boundaries(self):
+        if not options.find_file_boundaries():
+            return
 
-        for func_addr in self.funcs:
-            func = self.funcs[func_addr]
-            func_end_addr = func.insns[-1].instruction.address + 4
+        for in_file_offset in self.text_section.fileBoundaries:
+            if (in_file_offset % 16) != 0:
+                continue
 
-            possible_jtbl_jumps = [
-                (k, v)
-                for k, v in self.parent.jtbl_jumps.items()
-                if k >= func_addr and k < func_end_addr
-            ]
-            possible_jtbl_jumps.sort(key=lambda x: x[0])
+            if not self.parent.reported_file_split:
+                self.parent.reported_file_split = True
 
-            for i in range(len(func.insns)):
-                hi_insn: CsInsn = func.insns[i].instruction
+                # Look up for the last function in this boundary
+                func_addr = 0
+                for func in self.text_section.symbolList:
+                    funcOffset = func.inFileOffset - self.text_section.inFileOffset
+                    if in_file_offset == funcOffset:
+                        break
+                    func_addr = func.vram
 
-                # Ensure the first item in the list is always ahead of where we're looking
-                while (
-                    len(possible_jtbl_jumps) > 0
-                    and possible_jtbl_jumps[0][0] < hi_insn.address
-                ):
-                    del possible_jtbl_jumps[0]
-
-                # Find gp relative reads and writes e.g  lw $a1, 0x670($gp)
-                if hi_insn.op_str.endswith("($gp)"):
-                    gp_base = options.get_gp()
-                    if gp_base is None:
-                        log.error(
-                            "gp_value not set in yaml, can't calculate %gp_rel reloc value for "
-                            + hi_insn.op_str
-                        )
-
-                    op_split = hi_insn.op_str.split(", ")
-                    gp_offset = op_split[1][:-5]  # extract the 0x670 part
-                    if len(gp_offset) == 0:
-                        gp_offset = 0
-                    else:
-                        gp_offset = int(gp_offset, 16)
-                    symbol_addr = gp_base + gp_offset
-
-                    sym = self.parent.create_symbol(
-                        symbol_addr, offsets=True, reference=True
-                    )
-                    offset = symbol_addr - sym.vram_start
-                    offset_str = f"+0x{offset:X}"
-
-                    if self.parent:
-                        self.parent.check_rodata_sym(func_addr, sym)
-
-                    self.update_access_mnemonic(sym, hi_insn.mnemonic)
-
-                    func.insns[i].is_gp = True
-                    func.insns[i].hi_lo_sym = sym
-                    func.insns[i].sym_offset_str = offset_str
-                # All hi/lo pairs start with a lui
-                elif hi_insn.mnemonic == "lui":
-                    op_split = hi_insn.op_str.split(", ")
-                    hi_reg = op_split[0]
-
-                    if not op_split[1].startswith("0x"):
-                        continue
-
-                    lui_val = int(op_split[1], 0)
-
-                    # Assumes all luis are going to load from 0x80000000 or higher (maybe false)
-                    if lui_val >= 0x8000:
-                        # Iterate over the next few instructions to see if we can find a matching lo
-                        for j in range(
-                            i + 1, min(i + hi_lo_max_distance, len(func.insns))
-                        ):
-                            lo_insn = func.insns[j].instruction
-
-                            s_op_split = lo_insn.op_str.split(", ")
-
-                            if lo_insn.mnemonic == "lui" and hi_reg == s_op_split[0]:
-                                break
-
-                            if lo_insn.mnemonic in ["addiu", "ori"]:
-                                lo_reg = s_op_split[-2]
-                            else:
-                                lo_reg = s_op_split[-1][
-                                    s_op_split[-1].rfind("(") + 1 : -1
-                                ]
-
-                            if hi_reg == lo_reg:
-                                if lo_insn.mnemonic not in [
-                                    "addiu",
-                                    "lw",
-                                    "sw",
-                                    "lh",
-                                    "sh",
-                                    "lhu",
-                                    "lb",
-                                    "sb",
-                                    "lbu",
-                                    "lwc1",
-                                    "swc1",
-                                    "ldc1",
-                                    "sdc1",
-                                ]:
-                                    break
-
-                                # Match!
-                                reg_ext = ""
-
-                                # I forgot what this is doing
-                                junk_search = re.search(r"[\(]", s_op_split[-1])
-                                if junk_search is not None:
-                                    if junk_search.start() == 0:
-                                        break
-                                    s_str = s_op_split[-1][: junk_search.start()]
-                                    reg_ext = s_op_split[-1][junk_search.start() :]
-                                else:
-                                    s_str = s_op_split[-1]
-
-                                if options.get_compiler() == SN64:
-                                    reg_ext = CommonSegCodeSubsegment.replace_reg_names(
-                                        reg_ext
-                                    )
-
-                                symbol_addr = (lui_val * 0x10000) + int(s_str, 0)
-
-                                sym: Optional[Symbol] = None
-                                offset_str = ""
-
-                                # If the symbol is likely in the rodata section
-                                if (
-                                    not self.parent.text_follows_rodata
-                                    and symbol_addr > func_addr
-                                ) or (
-                                    self.parent.text_follows_rodata
-                                    and symbol_addr < func_addr
-                                ):
-                                    # Sanity check that the symbol is within this segment's vram
-                                    if (
-                                        self.parent.vram_end
-                                        and symbol_addr < self.parent.vram_end
-                                    ):
-                                        # If we've seen possible jumps to a jumptable and this symbol isn't too close to the end of the function
-                                        if (
-                                            len(possible_jtbl_jumps) > 0
-                                            and func_end_addr - lo_insn.address >= 0x30
-                                        ):
-                                            for jump in possible_jtbl_jumps:
-                                                if jump[1] == s_op_split[0]:
-                                                    dist_to_jump = (
-                                                        possible_jtbl_jumps[0][0]
-                                                        - lo_insn.address
-                                                    )
-                                                    if dist_to_jump <= 16:
-                                                        sym = self.parent.create_symbol(
-                                                            symbol_addr,
-                                                            reference=True,
-                                                            type="jtbl",
-                                                            local_only=True,
-                                                        )
-
-                                                        self.parent.jumptables[
-                                                            symbol_addr
-                                                        ] = (func_addr, func_end_addr)
-                                                        break
-
-                                if not sym:
-                                    sym = self.parent.create_symbol(
-                                        symbol_addr, offsets=True, reference=True
-                                    )
-                                    offset = symbol_addr - sym.vram_start
-                                    if offset != 0:
-                                        offset_str = f"+0x{offset:X}"
-
-                                if self.parent:
-                                    self.parent.check_rodata_sym(func_addr, sym)
-
-                                self.update_access_mnemonic(sym, lo_insn.mnemonic)
-
-                                func.insns[i].is_hi = True
-                                func.insns[i].hi_lo_sym = sym
-                                func.insns[i].sym_offset_str = offset_str
-
-                                func.insns[j].is_lo = True
-                                func.insns[j].hi_lo_sym = sym
-                                func.insns[j].sym_offset_str = offset_str
-                                func.insns[j].hi_lo_reg = reg_ext
-                                break
-
-    def add_labels(self):
-        ret = {}
-
-        function_macro = options.get_asm_function_macro()
-        data_macro = options.get_asm_data_macro()
-
-        for func_addr in self.funcs:
-            func_text = []
-            func = self.funcs[func_addr]
-
-            # Add function label
-            func_text.append(f"{function_macro} {func.name}")
-
-            if options.get_compiler() == SN64:
-                func_text.append(f".ent {func.name}")
-                func_text.append(f"{func.name}:")
-
-            indent_next = False
-
-            mnemonic_ljust = options.mnemonic_ljust()
-            rom_addr_padding = options.rom_address_padding()
-
-            for insn in func.insns:
-                insn_addr = insn.instruction.address
-                # Add a label if we need one
-                if insn_addr in self.parent.jtbl_glabels_to_add:
-                    func_text.append(f"{data_macro} L{insn_addr:X}_{insn.rom_addr:X}")
-                elif insn_addr in self.parent.labels_to_add:
-                    self.parent.labels_to_add.remove(insn_addr)
-                    func_text.append(".L{:X}:".format(insn_addr))
-
-                if rom_addr_padding:
-                    rom_str = "{0:0{1}X}".format(insn.rom_addr, rom_addr_padding)
-                else:
-                    rom_str = "{:X}".format(insn.rom_addr)
-
-                if options.get_compiler() == SN64:
-                    asm_comment = ""
-                else:
-                    asm_comment = "/* {} {:X} {} */".format(
-                        rom_str, insn_addr, insn.instruction.bytes.hex().upper()
-                    )
-
-                if insn.is_hi:
-                    assert insn.hi_lo_sym
-                    op_str = ", ".join(
-                        insn.op_str.split(", ")[:-1]
-                        + [f"%hi({insn.hi_lo_sym.name}{insn.sym_offset_str})"]
-                    )
-                elif insn.is_lo:
-                    assert insn.hi_lo_sym
-                    op_str = ", ".join(
-                        insn.op_str.split(", ")[:-1]
-                        + [
-                            f"%lo({insn.hi_lo_sym.name}{insn.sym_offset_str}){insn.hi_lo_reg}"
-                        ]
-                    )
-                elif insn.is_gp:
-                    op_str = ", ".join(
-                        insn.op_str.split(", ")[:-1]
-                        + [f"%gp_rel({insn.hi_lo_sym.name}{insn.sym_offset_str})($gp)"]
-                    )
-                else:
-                    op_str = insn.op_str
-
-                if self.is_branch_insn(insn.instruction.mnemonic):
-                    branch_addr = int(insn.instruction.op_str.split(",")[-1].strip(), 0)
-                    if branch_addr in self.parent.jtbl_glabels_to_add:
-                        label_str = f"L{branch_addr:X}_{self.ram_to_rom(branch_addr):X}"
-                        op_str = ", ".join(insn.op_str.split(", ")[:-1] + [label_str])
-
-                insn_text = insn.mnemonic
-                if indent_next:
-                    indent_next = False
-                    insn_text = " " + insn_text
-
-                asm_insn_text = "  {}{}".format(
-                    insn_text.ljust(mnemonic_ljust), op_str
-                ).rstrip()
-
-                func_text.append(asm_comment + asm_insn_text)
-
-                if (
-                    insn.instruction.mnemonic != "branch"
-                    and insn.instruction.mnemonic.startswith("b")
-                    or insn.instruction.mnemonic.startswith("j")
-                ):
-                    indent_next = True
-
-            end_label = options.get_asm_end_label()
-
-            if end_label:
-                func_text.append(f"{end_label} {func.name}")
-
-            ret[func_addr] = (func_text, func.rom)
-
-            if options.find_file_boundaries():
-                # If this is not the last function in the file
-                if func_addr != list(self.funcs.keys())[-1]:
-
-                    # Find where the function returns
-                    jr_pos: Optional[int] = None
-                    for i, insn in enumerate(reversed(func.insns)):
-                        if (
-                            insn.instruction.mnemonic == "jr"
-                            and insn.instruction.op_str in ["$ra", "$31"]
-                        ):
-                            jr_pos = i
-                            break
-
-                    # If there is more than 1 nop after the return
-                    if (
-                        jr_pos is not None
-                        and jr_pos > 1
-                        and self.is_nops(
-                            [insn.instruction for insn in func.insns[-jr_pos + 1 :]]
-                        )
-                    ):
-                        new_file_addr = func.insns[-1].rom_addr + 4
-                        if (new_file_addr % 16) == 0:
-                            if not self.parent.reported_file_split:
-                                self.parent.reported_file_split = True
-                                print(
-                                    f"Segment {self.name}, function at vram {func_addr:X} ends with extra nops, indicating a likely file split."
-                                )
-                                print(
-                                    "File split suggestions for this segment will follow in config yaml format:"
-                                )
-                            print(f"      - [0x{new_file_addr:X}, asm]")
-
-        return ret
+                print(
+                    f"Segment {self.name}, function at vram {func_addr:X} ends with extra nops, indicating a likely file split."
+                )
+                print(
+                    "File split suggestions for this segment will follow in config yaml format:"
+                )
+            print(f"      - [0x{self.rom_start+in_file_offset:X}, asm]")
 
     def gather_jumptable_labels(self, rom_bytes):
         # TODO: use the seg_symbols for this
diff --git a/tools/splat/segtypes/common/data.py b/tools/splat/segtypes/common/data.py
index b30f57d62f..62873f3c7c 100644
--- a/tools/splat/segtypes/common/data.py
+++ b/tools/splat/segtypes/common/data.py
@@ -3,6 +3,7 @@ from segtypes.common.codesubsegment import CommonSegCodeSubsegment
 from segtypes.common.group import CommonSegGroup
 from pathlib import Path
 from typing import List, Optional
+import rabbitizer
 from util.symbols import Symbol
 from util import floats, options
 
@@ -80,13 +81,15 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
                         new_sym_ram_start = self.get_most_parent().rom_to_ram(
                             new_sym_rom_start
                         )
-                        sym.size = new_sym_rom_start - sym.rom
+                        assert sym.rom is not None
+                        assert new_sym_ram_start is not None
+                        sym.given_size = new_sym_rom_start - sym.rom
 
                         # It turns out this isn't a valid jump table, so create a new symbol where it breaks
                         syms.insert(
                             i + 1,
-                            self.get_most_parent().create_symbol(
-                                new_sym_ram_start, define=True, local_only=True
+                            self.create_symbol(
+                                new_sym_ram_start, True, define=True, local_only=True
                             ),
                         )
                         return False
@@ -102,12 +105,13 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
         endian = options.get_endianess()
 
         # Find inter-data symbols
+        assert isinstance(self.rom_start, int) and isinstance(self.rom_end, int)
         for i in range(self.rom_start, self.rom_end, 4):
             bits = int.from_bytes(rom_bytes[i : i + 4], endian)
             if self.contains_vram(bits):
                 symset.add(
-                    self.get_most_parent().create_symbol(
-                        bits, define=True, local_only=True
+                    self.create_symbol(
+                        bits, in_segment=True, define=True, local_only=True
                     )
                 )
 
@@ -123,12 +127,13 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
         if len(ret) == 0 or ret[0].vram_start != self.vram_start:
             ret.insert(
                 0,
-                self.get_most_parent().create_symbol(
-                    self.vram_start, define=True, local_only=True
+                self.create_symbol(
+                    self.vram_start, in_segment=True, define=True, local_only=True
                 ),
             )
 
         # Make a dummy symbol here that marks the end of the previous symbol's disasm range
+        assert self.vram_end is not None
         ret.append(Symbol(self.vram_end))
 
         while True:
@@ -231,6 +236,10 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
         if not jtbl_func:
             return False
 
+        # A label of a jump table shouldn't point to the start of the function
+        if word == jtbl_func.vram_start:
+            return False
+
         for i in range(4, len(bytes), 4):
             word = int.from_bytes(bytes[i : i + 4], options.get_endianess())
 
@@ -240,6 +249,10 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
                 if i < min_jtbl_len or any(b != 0 for b in bytes[i:]):
                     return False
 
+            # A label of a jump table shouldn't point to the start of the function
+            if word == jtbl_func.vram_start:
+                return False
+
         # Mark this symbol as a jump table and record the jump table for later
         sym.type = "jtbl"
         most_parent.jumptables[sym.vram_start] = (
@@ -287,14 +300,13 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
                 if bits == 0:
                     byte_str = "0"
                 else:
-                    rom_addr = self.get_most_parent().ram_to_rom(bits)
-
-                    if rom_addr:
-                        byte_str = f"L{bits:X}_{rom_addr:X}"
+                    sym = self.get_symbol(bits, True)
+                    if sym is not None:
+                        byte_str = sym.name
                     else:
                         byte_str = f"0x{bits:X}"
             elif slen == 4 and bits >= 0x80000000:
-                sym = self.get_most_parent().get_symbol(bits, reference=True)
+                sym = self.get_symbol(bits, reference=True)
                 if sym:
                     byte_str = sym.name
                 else:
@@ -336,12 +348,13 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
 
         for i in range(len(syms) - 1):
             mnemonic = syms[i].access_mnemonic
-            sym = self.get_most_parent().create_symbol(
-                syms[i].vram_start, define=True, local_only=True
+            sym = self.create_symbol(
+                syms[i].vram_start, in_segment=True, define=True, local_only=True
             )
 
             dis_start = self.get_most_parent().ram_to_rom(syms[i].vram_start)
             dis_end = self.get_most_parent().ram_to_rom(syms[i + 1].vram_start)
+            assert dis_start is not None and dis_end is not None
             sym_len = dis_end - dis_start
 
             if self.type == "bss":
@@ -350,7 +363,10 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
                 sym_bytes = rom_bytes[dis_start:dis_end]
 
                 # Checking if the mnemonic is addiu may be too picky - we'll see
-                if self.is_valid_ascii(sym_bytes) and mnemonic == "addiu":
+                if (
+                    self.is_valid_ascii(sym_bytes)
+                    and mnemonic == rabbitizer.InstrId.cpu_addiu
+                ):
                     stype = "ascii"
                 elif sym.type == "jtbl":
                     stype = "jtbl"
@@ -396,7 +412,7 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
                 # Hint to the user that we are now in the .rodata section and no longer in the .data section (assuming rodata follows data)
                 if (
                     not rodata_encountered
-                    and mnemonic == "jtbl"
+                    and stype == "jtbl"
                     and self.get_most_parent().rodata_follows_data
                 ):
                     rodata_encountered = True
diff --git a/tools/splat/segtypes/common/group.py b/tools/splat/segtypes/common/group.py
index a83ea71aa5..029c6734ba 100644
--- a/tools/splat/segtypes/common/group.py
+++ b/tools/splat/segtypes/common/group.py
@@ -1,14 +1,8 @@
-from collections import OrderedDict
-from typing import List, Dict, Optional
-import typing
+from typing import List, Optional
 from segtypes.common.linker_section import dotless_type
-from util.range import Range
-from util import log, options
 from segtypes.common.segment import CommonSegment
 from segtypes.segment import RomAddr, Segment
-from util.symbols import Symbol
-
-CODE_TYPES = ["c", "asm", "hasm"]
+from util import log
 
 
 class CommonSegGroup(CommonSegment):
@@ -21,8 +15,10 @@ class CommonSegGroup(CommonSegment):
         vram_start,
         extract,
         given_subalign,
-        given_is_overlay,
+        exclusive_ram_id,
         given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
         args,
         yaml,
     ):
@@ -34,85 +30,15 @@ class CommonSegGroup(CommonSegment):
             vram_start,
             extract,
             given_subalign,
-            given_is_overlay,
-            given_dir,
-            args,
-            yaml,
+            exclusive_ram_id=exclusive_ram_id,
+            given_dir=given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
         )
 
-        self.rodata_syms: Dict[int, List[Symbol]] = {}
-
-        # TODO: move this to CommonSegCode
-        self.section_boundaries = OrderedDict(
-            (s_name, Range()) for s_name in options.get_section_order()
-        )
-        self.subsegments = self.parse_subsegments(yaml)
-
-    @property
-    def needs_symbols(self) -> bool:
-        for seg in self.subsegments:
-            if seg.needs_symbols:
-                return True
-        return False
-
-    def handle_alls(self, segs: List[Segment], base_segs) -> bool:
-        for i, elem in enumerate(segs):
-            if elem.type.startswith("all_"):
-                alls = []
-
-                rep_type = f"{elem.type[4:]}"
-                replace_class = Segment.get_class_for_type(rep_type)
-
-                for base in base_segs.items():
-                    if isinstance(elem.rom_start, int):
-                        # Shoddy rom to ram
-                        vram_start = elem.rom_start - self.rom_start + self.vram_start
-                    else:
-                        vram_start = "auto"
-                    rep = replace_class(
-                        elem.rom_start,
-                        elem.rom_end,
-                        rep_type,
-                        base[0],
-                        vram_start,
-                        False,
-                        self.given_subalign,
-                        self.given_is_overlay,
-                        self.given_dir,
-                        [],
-                        {},
-                    )
-                    rep.sibling = base[1]
-                    rep.parent = self
-                    alls.append(rep)
-
-                # Insert alls into segs at i
-                del segs[i]
-                segs[i:i] = alls
-                return True
-        return False
-
-    def find_inserts(
-        self, found_sections: typing.OrderedDict[str, Range]
-    ) -> "OrderedDict[str, int]":
-        inserts = OrderedDict()
-
-        section_order = self.section_order
-        section_order.remove(".text")
-
-        for i, section in enumerate(section_order):
-            if not found_sections[section].has_start():
-                search_done = False
-                for j in range(i - 1, -1, -1):
-                    if found_sections[section_order[j]].has_end():
-                        inserts[section] = found_sections[section_order[j]].end
-                        search_done = True
-                        break
-                if not search_done:
-                    inserts[section] = -1
-                    pass
-
-        return inserts
+        self.subsegments: List[Segment] = self.parse_subsegments(yaml)
 
     def get_next_seg_start(self, i, subsegment_yamls):
         return (
@@ -121,87 +47,25 @@ class CommonSegGroup(CommonSegment):
             else Segment.parse_segment_start(subsegment_yamls[i + 1])
         )
 
-    def parse_subsegments(self, segment_yaml) -> List[Segment]:
-        base_segments: OrderedDict[str, Segment] = OrderedDict()
-        ret = []
+    def parse_subsegments(self, yaml) -> List[Segment]:
+        ret: List[Segment] = []
+
+        if not yaml or "subsegments" not in yaml:
+            return ret
+
         prev_start: RomAddr = -1
-        inserts: OrderedDict[
-            str, int
-        ] = (
-            OrderedDict()
-        )  # Used to manually add "all_" types for sections not otherwise defined in the yaml
 
-        found_sections = OrderedDict(
-            (s_name, Range()) for s_name in self.section_boundaries
-        )  # Stores yaml index where a section was first found
-
-        if "subsegments" not in segment_yaml:
-            return []
-
-        # Mark any manually added dot types
-        if options.auto_all_sections():
-            cur_section = None
-
-            for i, subsection_yaml in enumerate(segment_yaml["subsegments"]):
-                # rompos marker
-                if isinstance(subsection_yaml, list) and len(subsection_yaml) == 1:
-                    if cur_section is not None:
-                        # End the current section
-                        found_sections[cur_section].end = i
-                        cur_section = None
-                    continue
-
-                typ = Segment.parse_segment_type(subsection_yaml)
-                if typ.startswith("all_"):
-                    typ = typ[4:]
-                if not typ.startswith("."):
-                    typ = f".{typ}"
-
-                if typ in found_sections:
-                    if cur_section is None:
-                        # Starting point
-                        found_sections[typ].start = i
-                        cur_section = typ
-                    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!"
-                                )
-
-                            # End the current section
-                            found_sections[cur_section].end = i
-
-                            # Start the next section
-                            found_sections[typ].start = i
-                            cur_section = typ
-
-            if cur_section is not None:
-                found_sections[cur_section].end = len(segment_yaml["subsegments"])
-
-            inserts = self.find_inserts(found_sections)
-
-        for i, subsection_yaml in enumerate(segment_yaml["subsegments"]):
-            # rompos marker
+        for i, subsection_yaml in enumerate(yaml["subsegments"]):
+            # End of previous segment
             if isinstance(subsection_yaml, list) and len(subsection_yaml) == 1:
                 continue
 
             typ = Segment.parse_segment_type(subsection_yaml)
             start = Segment.parse_segment_start(subsection_yaml)
 
-            # Add dummy segments to be expanded later
-            if typ.startswith("all_"):
-                ret.append(Segment(start, "auto", typ, "", "auto"))
-                continue
-
             segment_class = Segment.get_class_for_type(typ)
 
-            end = self.get_next_seg_start(i, segment_yaml["subsegments"])
+            end = self.get_next_seg_start(i, yaml["subsegments"])
 
             if (
                 isinstance(start, int)
@@ -220,72 +84,26 @@ class CommonSegGroup(CommonSegment):
             segment: Segment = Segment.from_yaml(
                 segment_class, subsection_yaml, start, end, vram
             )
-            segment.sibling = base_segments.get(segment.name, None)
             segment.parent = self
 
-            for i, section in enumerate(self.section_order):
-                if not self.section_boundaries[section].has_start() and dotless_type(
-                    section
-                ) == dotless_type(segment.type):
-                    if i > 0:
-                        prev_section = self.section_order[i - 1]
-                        self.section_boundaries[prev_section].end = segment.vram_start
-                    self.section_boundaries[section].start = segment.vram_start
-
             ret.append(segment)
-
-            # todo change
-            if typ in CODE_TYPES:
-                base_segments[segment.name] = segment
-
             prev_start = start
 
-        # Add the automatic all_ sections
-        orig_len = len(ret)
-        for section in reversed(inserts):
-            idx = inserts[section]
-
-            if idx == -1:
-                idx = orig_len
-
-            # bss hack TODO maybe rethink
-            if section == "bss" and self.vram_start is not None:
-                rom_start = self.rom_end
-                vram_start = self.vram_start + self.rom_end - self.rom_start
-            else:
-                rom_start = "auto"
-                vram_start = "auto"
-
-            ret.insert(
-                idx, (Segment(rom_start, "auto", "all_" + section, "", vram_start))
-            )
-
-        check = True
-        while check:
-            check = self.handle_alls(ret, base_segments)
-
-        # TODO why is this necessary?
-        if (
-            self.section_boundaries[".rodata"].has_start()
-            and not self.section_boundaries[".rodata"].has_end()
-        ):
-            assert self.vram_end is not None
-            self.section_boundaries[".rodata"].end = self.vram_end
-
         return ret
 
+    @property
+    def needs_symbols(self) -> bool:
+        for seg in self.subsegments:
+            if seg.needs_symbols:
+                return True
+        return False
+
     def get_linker_entries(self):
         return [entry for sub in self.subsegments for entry in sub.get_linker_entries()]
 
     def scan(self, rom_bytes):
-        # Always scan code first
         for sub in self.subsegments:
-            if sub.type in CODE_TYPES 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 sub.should_scan():
                 sub.scan(rom_bytes)
 
     def split(self, rom_bytes):
diff --git a/tools/splat/segtypes/common/hasm.py b/tools/splat/segtypes/common/hasm.py
new file mode 100644
index 0000000000..e8dcf17698
--- /dev/null
+++ b/tools/splat/segtypes/common/hasm.py
@@ -0,0 +1,16 @@
+from segtypes.common.asm import CommonSegAsm
+
+
+class CommonSegHasm(CommonSegAsm):
+    def split(self, rom_bytes: bytes):
+        if not self.rom_start == self.rom_end:
+            out_path = self.out_path()
+            if out_path and not out_path.exists():
+                out_path.parent.mkdir(parents=True, exist_ok=True)
+
+                self.print_file_boundaries()
+
+                with open(out_path, "w", newline="\n") as f:
+                    for line in self.get_file_header():
+                        f.write(line + "\n")
+                    f.write(self.text_section.disassemble())
diff --git a/tools/splat/segtypes/common/lib.py b/tools/splat/segtypes/common/lib.py
index 430218541c..39f568eee3 100644
--- a/tools/splat/segtypes/common/lib.py
+++ b/tools/splat/segtypes/common/lib.py
@@ -14,8 +14,10 @@ class CommonSegLib(N64Segment):
         vram_start,
         extract,
         given_subalign,
-        given_is_overlay,
+        exclusive_ram_id,
         given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
         args,
         yaml,
     ):
@@ -27,11 +29,14 @@ class CommonSegLib(N64Segment):
             vram_start,
             extract,
             given_subalign,
-            given_is_overlay,
-            given_dir,
-            args,
-            yaml,
+            exclusive_ram_id=exclusive_ram_id,
+            given_dir=given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
         )
+
         if isinstance(yaml, dict):
             log.error("Error: 'dict' not currently supported for 'lib' segment")
             return
diff --git a/tools/splat/segtypes/linker_entry.py b/tools/splat/segtypes/linker_entry.py
index f6ece746f3..8a9cf24138 100644
--- a/tools/splat/segtypes/linker_entry.py
+++ b/tools/splat/segtypes/linker_entry.py
@@ -1,6 +1,9 @@
 from typing import Union, List
 from pathlib import Path
+from segtypes.common.data import CommonSegData
 from segtypes.common.linker_section import LinkerSection, dotless_type
+from segtypes.n64.img import N64SegImg
+from segtypes.n64.palette import N64SegPalette
 from util import options
 from segtypes.segment import Segment
 import os
@@ -57,10 +60,14 @@ def to_cname(symbol: str) -> str:
 
 
 def get_segment_cname(segment: Segment) -> str:
+    name = segment.name
     if segment.parent:
-        return to_cname(segment.parent.name + "_" + segment.name)
-    else:
-        return to_cname(segment.name)
+        name = segment.parent.name + "_" + name
+
+    if isinstance(segment, N64SegPalette):
+        name += "_pal"
+
+    return to_cname(name)
 
 
 class LinkerEntry:
@@ -163,6 +170,15 @@ class LinkerWriter:
                 )
                 self._write_symbol(path_cname, ".")
 
+            # Write out manual entries for images inside .data segments
+            seg = entry.segment
+            if isinstance(seg, CommonSegData):
+                for subseg in seg.subsegments:
+                    if isinstance(subseg, N64SegImg):
+                        self._write_symbol(
+                            get_segment_cname(subseg), f"0x{subseg.rom_start:X}"
+                        )
+
             self._writeln(f"{entry.object_path}({cur_section});")
 
         for section in section_labels:
diff --git a/tools/splat/segtypes/n64/ci8.py b/tools/splat/segtypes/n64/ci8.py
index 9db4dae273..1ad5bd04a8 100644
--- a/tools/splat/segtypes/n64/ci8.py
+++ b/tools/splat/segtypes/n64/ci8.py
@@ -19,8 +19,10 @@ class N64SegCi8(N64SegRgba16):
         vram_start,
         extract,
         given_subalign,
-        given_is_overlay,
+        exclusive_ram_id,
         given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
         args,
         yaml,
     ):
@@ -32,10 +34,12 @@ class N64SegCi8(N64SegRgba16):
             vram_start,
             extract,
             given_subalign,
-            given_is_overlay,
-            given_dir,
-            args,
-            yaml,
+            exclusive_ram_id=exclusive_ram_id,
+            given_dir=given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
         )
 
         self.palette: "Optional[Palette]" = None
@@ -52,7 +56,6 @@ class N64SegCi8(N64SegRgba16):
             log.error(
                 f"no palette sibling segment exists\n(hint: add a segment with type 'palette' and name '{self.name}')"
             )
-            return
 
         w = png.Writer(
             self.width, self.height, palette=self.palette.parse_palette(rom_bytes)
diff --git a/tools/splat/segtypes/n64/cpp.py b/tools/splat/segtypes/n64/cpp.py
deleted file mode 100644
index f656b925a8..0000000000
--- a/tools/splat/segtypes/n64/cpp.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from segtypes.n64.c import N64SegC
-from util import options
-
-
-class N64SegCpp(N64SegC):
-    def out_path(self):
-        return options.get_src_path() / self.dir / f"{self.name}.cpp"
diff --git a/tools/splat/segtypes/n64/gfx.py b/tools/splat/segtypes/n64/gfx.py
new file mode 100644
index 0000000000..9c11e63622
--- /dev/null
+++ b/tools/splat/segtypes/n64/gfx.py
@@ -0,0 +1,214 @@
+"""
+N64 f3dex display list splitter
+Dumps out Gfx[] as a .inc.c file.
+"""
+
+from pathlib import Path
+from pygfxd import *
+from util import log
+from util.log import error
+
+from util import options
+from segtypes.common.codesubsegment import CommonSegCodeSubsegment
+
+
+class N64SegGfx(CommonSegCodeSubsegment):
+    def __init__(
+        self,
+        rom_start,
+        rom_end,
+        type,
+        name,
+        vram_start,
+        extract,
+        given_subalign,
+        exclusive_ram_id,
+        given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
+        args,
+        yaml,
+    ):
+        super().__init__(
+            rom_start,
+            rom_end,
+            type,
+            name,
+            vram_start,
+            extract,
+            given_subalign,
+            exclusive_ram_id=exclusive_ram_id,
+            given_dir=given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
+        )
+        self.file_text = None
+
+    def get_linker_section(self) -> str:
+        return ".data"
+
+    def out_path(self) -> Path:
+        return options.get_asset_path() / self.dir / f"{self.name}.gfx.inc.c"
+
+    def scan(self, rom_bytes: bytes):
+        self.file_text = self.disassemble_data(rom_bytes)
+
+    def get_gfxd_target(self):
+        opt = options.get_gfx_ucode()
+
+        if opt == "f3d":
+            return gfxd_f3d  # type: ignore
+        elif opt == "f3db":
+            return gfxd_f3db  # type: ignore
+        elif opt == "f3dex":
+            return gfxd_f3dex  # type: ignore
+        elif opt == "f3dexb":
+            return gfxd_f3dexb  # type: ignore
+        elif opt == "f3dex2":
+            return gfxd_f3dex2  # type: ignore
+        else:
+            log.error(f"Unknown target {opt}")
+
+    def tlut_handler(self, addr, idx, count):
+        sym = self.create_symbol(
+            addr=addr, in_segment=True, type="data", reference=True
+        )
+        gfxd_printf(sym.name)
+        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
+        )
+        gfxd_printf(sym.name)
+        return 1
+
+    def cimg_handler(self, addr, fmt, size, width):
+        sym = self.create_symbol(
+            addr=addr, in_segment=True, type="data", reference=True
+        )
+        gfxd_printf(sym.name)
+        return 1
+
+    def zimg_handler(self, addr):
+        sym = self.create_symbol(
+            addr=addr, in_segment=True, type="data", reference=True
+        )
+        gfxd_printf(sym.name)
+        return 1
+
+    def dl_handler(self, addr):
+        sym = self.create_symbol(
+            addr=addr, in_segment=True, type="data", reference=True
+        )
+        gfxd_printf(sym.name)
+        return 1
+
+    def mtx_handler(self, addr):
+        sym = self.create_symbol(
+            addr=addr, in_segment=True, type="data", reference=True
+        )
+        gfxd_printf(sym.name)
+        return 1
+
+    def lookat_handler(self, addr, count):
+        sym = self.create_symbol(
+            addr=addr, in_segment=True, type="data", reference=True
+        )
+        gfxd_printf(sym.name)
+        return 1
+
+    def light_handler(self, addr, count):
+        sym = self.create_symbol(
+            addr=addr, in_segment=True, type="data", reference=True
+        )
+        gfxd_printf(sym.name)
+        return 1
+
+    def vtx_handler(self, addr, count):
+        sym = self.create_symbol(
+            addr=addr, in_segment=True, type="data", reference=True
+        )
+        gfxd_printf(sym.name)
+        return 1
+
+    def vp_handler(self, addr):
+        sym = self.create_symbol(
+            addr=addr, in_segment=True, type="data", reference=True
+        )
+        gfxd_printf(sym.name)
+        return 1
+
+    def macro_fn(self):
+        gfxd_puts("    ")
+        gfxd_macro_dflt()
+        gfxd_puts(",\n")
+        return 0
+
+    def disassemble_data(self, rom_bytes):
+        gfx_data = rom_bytes[self.rom_start : self.rom_end]
+        segment_length = len(gfx_data)
+        if (segment_length) % 8 != 0:
+            error(
+                f"Error: gfx segment {self.name} length ({segment_length}) is not a multiple of 8!"
+            )
+
+        out_str = options.get_generated_c_premble() + "\n\n"
+
+        sym = self.create_symbol(
+            addr=self.vram_start, in_segment=True, type="data", define=True
+        )
+
+        gfxd_input_buffer(gfx_data)
+
+        # TODO terrible guess at the size we'll need - improve this
+        outb = bytes([0] * segment_length * 100)
+        outbuf = gfxd_output_buffer(outb, len(outb))
+
+        gfxd_target(self.get_gfxd_target())
+        gfxd_endian(
+            GfxdEndian.big if options.get_endianess() == "big" else GfxdEndian.little, 4
+        )
+
+        # Callbacks
+        gfxd_macro_fn(self.macro_fn)
+
+        gfxd_tlut_callback(self.tlut_handler)
+        gfxd_timg_callback(self.timg_handler)
+        gfxd_cimg_callback(self.cimg_handler)
+        gfxd_zimg_callback(self.zimg_handler)
+        gfxd_dl_callback(self.dl_handler)
+        gfxd_mtx_callback(self.mtx_handler)
+        gfxd_lookat_callback(self.lookat_handler)
+        gfxd_light_callback(self.light_handler)
+        # gfxd_seg_callback ?
+        gfxd_vtx_callback(self.vtx_handler)
+        gfxd_vp_callback(self.vp_handler)
+        # gfxd_uctext_callback ?
+        # gfxd_ucdata_callback ?
+        # gfxd_dram_callback ?
+
+        gfxd_execute()
+        out_str += "Gfx " + sym.name + "[] = {\n"
+        out_str += gfxd_buffer_to_string(outbuf)
+        out_str += "};\n"
+        return out_str
+
+    def split(self, rom_bytes: bytes):
+        if self.file_text and self.out_path():
+            self.out_path().parent.mkdir(parents=True, exist_ok=True)
+
+            with open(self.out_path(), "w", newline="\n") as f:
+                f.write(self.file_text)
+
+    def should_scan(self) -> bool:
+        return (
+            options.mode_active("gfx")
+            and self.rom_start != "auto"
+            and self.rom_end != "auto"
+        )
+
+    def should_split(self) -> bool:
+        return self.extract and options.mode_active("gfx")
diff --git a/tools/splat/segtypes/n64/hasm.py b/tools/splat/segtypes/n64/hasm.py
index d097e0b0fb..5f9e607986 100644
--- a/tools/splat/segtypes/n64/hasm.py
+++ b/tools/splat/segtypes/n64/hasm.py
@@ -1,8 +1,25 @@
-from segtypes.n64.asm import N64SegAsm
+from segtypes.common.hasm import CommonSegHasm
+
+from util import options
 
 
-class N64SegHasm(N64SegAsm):
-    def split_write(self, out_path, out_lines):
-        if not out_path.exists():
-            with open(out_path, "w", newline="\n") as f:
-                f.write("\n".join(out_lines))
+class N64SegHasm(CommonSegHasm):
+    @staticmethod
+    def get_file_header():
+        ret = []
+
+        ret.append('.include "macro.inc"')
+        ret.append("")
+        ret.append("# assembler directives")
+        ret.append(".set noat      # allow manual use of $at")
+        ret.append(".set noreorder # don't insert nops after branches")
+        ret.append(".set gp=64     # allow use of 64-bit general purpose registers")
+        ret.append("")
+        preamble = options.get_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/n64/img.py b/tools/splat/segtypes/n64/img.py
index b67ee080ed..0eb58c6c06 100644
--- a/tools/splat/segtypes/n64/img.py
+++ b/tools/splat/segtypes/n64/img.py
@@ -15,8 +15,10 @@ class N64SegImg(N64Segment):
         vram_start,
         extract,
         given_subalign,
-        given_is_overlay,
+        exclusive_ram_id,
         given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
         args,
         yaml,
     ):
@@ -28,10 +30,12 @@ class N64SegImg(N64Segment):
             vram_start,
             extract,
             given_subalign,
-            given_is_overlay,
-            given_dir,
-            args,
-            yaml,
+            exclusive_ram_id=exclusive_ram_id,
+            given_dir=given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
         )
 
         if isinstance(yaml, dict):
diff --git a/tools/splat/segtypes/n64/palette.py b/tools/splat/segtypes/n64/palette.py
index 15c2f1ed7c..2476c312be 100644
--- a/tools/splat/segtypes/n64/palette.py
+++ b/tools/splat/segtypes/n64/palette.py
@@ -23,8 +23,10 @@ class N64SegPalette(N64Segment):
         vram_start,
         extract,
         given_subalign,
-        given_is_overlay,
+        exclusive_ram_id,
         given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
         args,
         yaml,
     ):
@@ -36,10 +38,12 @@ class N64SegPalette(N64Segment):
             vram_start,
             extract,
             given_subalign,
-            given_is_overlay,
-            given_dir,
-            args,
-            yaml,
+            exclusive_ram_id=exclusive_ram_id,
+            given_dir=given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
         )
 
         self.raster: "Optional[Raster]" = None
@@ -81,7 +85,6 @@ class N64SegPalette(N64Segment):
         if self.raster is None:
             # TODO: output with no raster
             log.error(f"orphaned palette segment: {self.name} lacks ci4/ci8 sibling")
-            return
 
         w = png.Writer(
             self.raster.width, self.raster.height, palette=self.parse_palette(rom_bytes)
diff --git a/tools/splat/segtypes/n64/vtx.py b/tools/splat/segtypes/n64/vtx.py
index f18fb19f89..0ef946200e 100644
--- a/tools/splat/segtypes/n64/vtx.py
+++ b/tools/splat/segtypes/n64/vtx.py
@@ -7,7 +7,6 @@ Originally written by Mark Street (https://github.com/mkst)
 
 import re
 import struct
-from typing import Optional
 from pathlib import Path
 from util.log import error
 
@@ -25,10 +24,12 @@ class N64SegVtx(CommonSegCodeSubsegment):
         vram_start,
         extract,
         given_subalign,
-        given_is_overlay,
+        exclusive_ram_id,
         given_dir,
-        args=[],
-        yaml={},
+        symbol_name_format,
+        symbol_name_format_no_rom,
+        args,
+        yaml,
     ):
         super().__init__(
             rom_start,
@@ -38,10 +39,12 @@ class N64SegVtx(CommonSegCodeSubsegment):
             vram_start,
             extract,
             given_subalign,
-            given_is_overlay,
-            given_dir,
-            args,
-            yaml,
+            exclusive_ram_id=exclusive_ram_id,
+            given_dir=given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
         )
         self.file_text = None
 
@@ -68,8 +71,10 @@ class N64SegVtx(CommonSegCodeSubsegment):
         lines.append("")
 
         vertex_count = segment_length // 16
-        cname = re.sub(r"[^0-9a-zA-Z_]", "_", self.name)
-        lines.append(f"Vtx {cname}[{vertex_count}] = {{")
+        sym = self.create_symbol(
+            addr=self.vram_start, in_segment=True, type="data", define=True
+        )
+        lines.append(f"Vtx {sym.name}[{vertex_count}] = {{")
 
         for vtx in struct.iter_unpack(">hhhHhhBBBB", vertex_data):
             x, y, z, flg, t, c, r, g, b, a = vtx
diff --git a/tools/splat/segtypes/psx/hasm.py b/tools/splat/segtypes/psx/hasm.py
deleted file mode 100644
index 161a8d3050..0000000000
--- a/tools/splat/segtypes/psx/hasm.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from segtypes.psx.asm import PsxSegAsm
-
-
-class PsxSegHasm(PsxSegAsm):
-    def split_write(self, out_path, out_lines):
-        if not out_path.exists():
-            with open(out_path, "w", newline="\n") as f:
-                f.write("\n".join(out_lines))
diff --git a/tools/splat/segtypes/segment.py b/tools/splat/segtypes/segment.py
index 8168d77277..c4a274fc39 100644
--- a/tools/splat/segtypes/segment.py
+++ b/tools/splat/segtypes/segment.py
@@ -1,7 +1,7 @@
 import importlib
 import importlib.util
 
-from typing import Dict, TYPE_CHECKING, Type, Union, Optional, List
+from typing import Any, Dict, TYPE_CHECKING, Type, Union, Optional, List
 from pathlib import Path
 
 from util import log
@@ -41,7 +41,7 @@ class Segment:
     require_unique_name = True
 
     @staticmethod
-    def get_class_for_type(seg_type):
+    def get_class_for_type(seg_type) -> Type["Segment"]:
         # so .data loads SegData, for example
         if seg_type.startswith("."):
             seg_type = seg_type[1:]
@@ -126,17 +126,33 @@ class Segment:
         else:
             return str(cls.get_default_name(rom_start))
 
+    @staticmethod
+    def parse_segment_symbol_name_format(segment: Union[dict, list]) -> str:
+        if isinstance(segment, dict) and "symbol_name_format" in segment:
+            return str(segment["symbol_name_format"])
+        else:
+            return options.get_symbol_name_format()
+
+    @staticmethod
+    def parse_segment_symbol_name_format_no_rom(segment: Union[dict, list]) -> str:
+        if isinstance(segment, dict) and "symbol_name_format_no_rom" in segment:
+            return str(segment["symbol_name_format_no_rom"])
+        else:
+            return options.get_symbol_name_format_no_rom()
+
     def __init__(
         self,
-        rom_start,
-        rom_end,
-        type,
-        name,
-        vram_start,
-        extract=True,
-        given_subalign=options.get_subalign(),
-        given_is_overlay: Optional[bool] = False,
+        rom_start: RomAddr,
+        rom_end: RomAddr,
+        type: str,
+        name: str,
+        vram_start: Any,
+        extract: bool = True,
+        given_subalign: int = options.get_subalign(),
+        exclusive_ram_id: Optional[str] = None,
         given_dir: Path = Path(),
+        symbol_name_format: str = options.get_symbol_name_format(),
+        symbol_name_format_no_rom: str = options.get_symbol_name_format_no_rom(),
         args=[],
         yaml={},
     ):
@@ -148,27 +164,22 @@ class Segment:
         self.extract = extract
 
         self.given_subalign = given_subalign
-        self.given_is_overlay = given_is_overlay
+        self.exclusive_ram_id = exclusive_ram_id
         self.given_dir = given_dir
         self.given_seg_symbols: Dict[
             int, List[Symbol]
         ] = {}  # Symbols known to be in this segment
-        self.given_ext_symbols: Dict[
-            int, List[Symbol]
-        ] = (
-            {}
-        )  # Symbols not in this segment but also not from other overlapping ram address ranges
         self.given_section_order: List[str] = options.get_section_order()
 
+        self.given_symbol_name_format = symbol_name_format
+        self.given_symbol_name_format_no_rom = symbol_name_format_no_rom
+
         self.parent: Optional[Segment] = None
         self.sibling: Optional[Segment] = None
 
         self.args: List[str] = args
         self.yaml = yaml
 
-        if "skip" in self.args:
-            self.extract = False
-
         if self.rom_start == "auto":
             self.extract = False
 
@@ -197,24 +208,30 @@ class Segment:
         vram_start = vram if vram is not None else parse_segment_vram(yaml)
         extract = bool(yaml.get("extract", True)) if isinstance(yaml, dict) else True
         given_subalign = parse_segment_subalign(yaml)
-        given_is_overlay: Optional[bool] = (
-            yaml.get("overlay", False) if isinstance(yaml, dict) else False
+        exclusive_ram_id: Optional[str] = (
+            yaml.get("exclusive_ram_id") if isinstance(yaml, dict) else None
         )
         given_dir = Path(yaml.get("dir", "")) if isinstance(yaml, dict) else Path()
+        given_symbol_name_format = Segment.parse_segment_symbol_name_format(yaml)
+        given_symbol_name_format_no_rom = (
+            Segment.parse_segment_symbol_name_format_no_rom(yaml)
+        )
         args: List[str] = [] if isinstance(yaml, dict) else yaml[3:]
 
         ret = cls(
-            rom_start,
-            rom_end,
-            type,
-            name,
-            vram_start,
-            extract,
-            given_subalign,
-            given_is_overlay,
-            given_dir,
-            args,
-            yaml,
+            rom_start=rom_start,
+            rom_end=rom_end,
+            type=type,
+            name=name,
+            vram_start=vram_start,
+            extract=extract,
+            given_subalign=given_subalign,
+            exclusive_ram_id=exclusive_ram_id,
+            given_dir=given_dir,
+            symbol_name_format=given_symbol_name_format,
+            symbol_name_format_no_rom=given_symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
         )
         cls.given_section_order = parse_segment_section_order(yaml)
         return ret
@@ -230,6 +247,14 @@ class Segment:
         else:
             return self.given_dir
 
+    @property
+    def symbol_name_format(self) -> str:
+        return self.given_symbol_name_format
+
+    @property
+    def symbol_name_format_no_rom(self) -> str:
+        return self.given_symbol_name_format_no_rom
+
     @property
     def subalign(self) -> int:
         if self.parent:
@@ -237,13 +262,15 @@ class Segment:
         else:
             return self.given_subalign
 
-    @property
-    def is_overlay(self) -> bool:
+    def get_exclusive_ram_id(self) -> Optional[str]:
         if self.parent:
-            return self.parent.is_overlay
-        if self.given_is_overlay is not None:
-            return self.given_is_overlay
-        return False
+            return self.parent.get_exclusive_ram_id()
+        return self.exclusive_ram_id
+
+    def add_symbol(self, symbol: Symbol):
+        if symbol.vram_start not in self.given_seg_symbols:
+            self.given_seg_symbols[symbol.vram_start] = []
+        self.given_seg_symbols[symbol.vram_start].append(symbol)
 
     @property
     def seg_symbols(self) -> Dict[int, List[Symbol]]:
@@ -252,13 +279,6 @@ class Segment:
         else:
             return self.given_seg_symbols
 
-    @property
-    def ext_symbols(self) -> Dict[int, List[Symbol]]:
-        if self.parent:
-            return self.parent.ext_symbols
-        else:
-            return self.given_ext_symbols
-
     @property
     def size(self) -> Optional[int]:
         if isinstance(self.rom_start, int) and isinstance(self.rom_end, int):
@@ -285,14 +305,6 @@ class Segment:
             self.section_order.index(".rodata") - self.section_order.index(".data") == 1
         )
 
-    @property
-    def text_follows_rodata(self) -> bool:
-        if ".text" not in self.section_order or ".rodata" not in self.section_order:
-            return False
-        return (
-            self.section_order.index(".text") - self.section_order.index(".rodata") == 1
-        )
-
     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
@@ -395,43 +407,59 @@ class Segment:
     def get_default_name(addr) -> str:
         return f"{addr:X}"
 
-    def retrieve_symbol(self, d, k, t):
-        if k not in d:
+    @staticmethod
+    def visible_ram(seg1: "Segment", seg2: "Segment") -> bool:
+        if seg1.get_most_parent() == seg2.get_most_parent():
+            return True
+        if seg1.get_exclusive_ram_id() is None or seg2.get_exclusive_ram_id() is None:
+            return True
+        return seg1.get_exclusive_ram_id() != seg2.get_exclusive_ram_id()
+
+    def retrieve_symbol(
+        self, syms: Dict[int, List[Symbol]], addr: int
+    ) -> Optional[Symbol]:
+        if addr not in syms:
             return None
 
-        if t:
-            items = [s for s in d[k] if s.type == t or s.type == "unknown"]
-        else:
-            items = d[k]
+        items = syms[addr]
+
+        # Filter out symbols that are in different top-level segments with the same unique_ram_id
+        items = [
+            i
+            for i in items
+            if i.segment is None or Segment.visible_ram(self, i.segment)
+        ]
 
         if len(items) > 1:
-            pass  # print(f"Trying to retrieve {k:X} from symbol dict but there are {len(items)} entries to pick from - picking the first")
+            # print(f"Trying to retrieve {addr:X} from symbol dict but there are {len(items)} entries to pick from - picking the first")
+            pass
         if len(items) == 0:
             return None
         return items[0]
 
     def get_symbol(
         self,
-        addr,
-        type=None,
-        create=False,
-        define=False,
-        reference=False,
-        offsets=False,
-        local_only=False,
-        dead=True,
+        addr: int,
+        in_segment: bool = False,
+        type: Optional[str] = None,
+        create: bool = False,
+        define: bool = False,
+        reference: bool = False,
+        offsets: bool = False,
+        local_only: bool = False,
+        dead: bool = True,
     ) -> Optional[Symbol]:
-        ret = None
-        rom = None
+        ret: Optional[Symbol] = None
+        rom: Optional[int] = None
 
-        in_segment = self.contains_vram(addr)
+        most_parent = self.get_most_parent()
 
         if in_segment:
             # If the vram address is within this segment, we can calculate the symbol's rom address
-            rom = self.ram_to_rom(addr)
-            ret = self.retrieve_symbol(self.seg_symbols, addr, type)
+            rom = most_parent.ram_to_rom(addr)
+            ret = most_parent.retrieve_symbol(most_parent.seg_symbols, addr)
         elif not local_only:
-            ret = self.retrieve_symbol(self.ext_symbols, addr, type)
+            ret = most_parent.retrieve_symbol(symbols.all_symbols_dict, addr)
 
         # Search for symbol ranges
         if not ret and offsets:
@@ -444,39 +472,43 @@ class Segment:
         # Create the symbol if it doesn't exist
         if not ret and create:
             ret = Symbol(addr, rom=rom, type=type)
-            symbols.all_symbols.append(ret)
+            symbols.add_symbol(ret)
 
             if in_segment:
-                if self.is_overlay:
-                    ret.in_overlay = True
-                if addr not in self.seg_symbols:
-                    self.seg_symbols[addr] = []
-                self.seg_symbols[addr].append(ret)
-            elif not local_only:
-                if addr not in self.ext_symbols:
-                    self.ext_symbols[addr] = []
-                self.ext_symbols[addr].append(ret)
+                ret.segment = most_parent
+                if addr not in most_parent.seg_symbols:
+                    most_parent.seg_symbols[addr] = []
+                most_parent.seg_symbols[addr].append(ret)
 
         if ret:
             if define:
                 ret.defined = True
             if reference:
                 ret.referenced = True
+            if ret.type is None:
+                ret.type = type
+            if ret.rom is None:
+                ret.rom = rom
+            if in_segment:
+                if ret.segment is None:
+                    ret.segment = most_parent
 
         return ret
 
     def create_symbol(
         self,
-        addr,
-        type=None,
-        define=False,
-        reference=False,
-        offsets=False,
-        local_only=False,
-        dead=True,
+        addr: int,
+        in_segment: bool,
+        type: Optional[str] = None,
+        define: bool = False,
+        reference: bool = False,
+        offsets: bool = False,
+        local_only: bool = False,
+        dead: bool = True,
     ) -> Symbol:
         ret = self.get_symbol(
             addr,
+            in_segment=in_segment,
             type=type,
             create=True,
             define=define,
diff --git a/tools/splat/split.py b/tools/splat/split.py
index a7a94138b0..7a6178da23 100755
--- a/tools/splat/split.py
+++ b/tools/splat/split.py
@@ -3,7 +3,9 @@
 import hashlib
 from typing import Dict, List, Union, Set, Any
 import argparse
-import pylibyaml
+import spimdisasm
+import rabbitizer
+import tqdm
 import yaml
 import pickle
 from colorama import Style, Fore
@@ -13,8 +15,12 @@ from util import log
 from util import options
 from util import symbols
 from util import palettes
+from util import compiler
+from util.symbols import Symbol
 
-VERSION = "0.8.1.0"
+from intervaltree import Interval, IntervalTree
+
+VERSION = "0.9.0"
 
 parser = argparse.ArgumentParser(
     description="Split a rom given a rom, a config, and output directory"
@@ -31,6 +37,9 @@ parser.add_argument(
 linker_writer: LinkerWriter
 config: Dict[str, Any]
 
+segment_roms: IntervalTree = IntervalTree()
+segment_rams: IntervalTree = IntervalTree()
+
 
 def fmt_size(size):
     if size > 1000000:
@@ -42,6 +51,12 @@ def fmt_size(size):
 
 
 def initialize_segments(config_segments: Union[dict, list]) -> List[Segment]:
+    global segment_roms
+    global segment_rams
+
+    segment_roms = IntervalTree()
+    segment_rams = IntervalTree()
+
     seen_segment_names: Set[str] = set()
     ret = []
 
@@ -68,35 +83,42 @@ def initialize_segments(config_segments: Union[dict, list]) -> List[Segment]:
             seen_segment_names.add(segment.name)
 
         ret.append(segment)
+        if (
+            isinstance(segment.rom_start, int)
+            and isinstance(segment.rom_end, int)
+            and segment.rom_start != segment.rom_end
+        ):
+            segment_roms.addi(segment.rom_start, segment.rom_end, segment)
+        if (
+            isinstance(segment.vram_start, int)
+            and isinstance(segment.vram_end, int)
+            and segment.vram_start != segment.vram_end
+        ):
+            segment_rams.addi(segment.vram_start, segment.vram_end, segment)
 
     return ret
 
 
-def get_segment_symbols(segment, all_segments):
-    seg_syms = {}
-    other_syms = {}
+def assign_symbols_to_segments():
+    seg_syms: dict[int, list[Symbol]] = {}
 
     for symbol in symbols.all_symbols:
-        if symbols.is_symbol_isolated(symbol, all_segments) and not symbol.rom:
-            if segment.contains_vram(symbol.vram_start):
-                if symbol.vram_start not in seg_syms:
-                    seg_syms[symbol.vram_start] = []
-                seg_syms[symbol.vram_start].append(symbol)
+        if symbol.rom:
+            cands = segment_roms[symbol.rom]
+            if len(cands) > 1:
+                log.error("multiple segments rom overlap symbol", symbol)
+            elif len(cands) == 0:
+                log.error("no segment rom overlaps symbol", symbol)
             else:
-                if symbol.vram_start not in other_syms:
-                    other_syms[symbol.vram_start] = []
-                other_syms[symbol.vram_start].append(symbol)
+                cand: Interval = cands.pop()
+                seg: Segment = cand.data
+                seg.add_symbol(symbol)
         else:
-            if symbol.rom and segment.contains_rom(symbol.rom):
-                if symbol.vram_start not in seg_syms:
-                    seg_syms[symbol.vram_start] = []
-                seg_syms[symbol.vram_start].append(symbol)
-            else:
-                if symbol.vram_start not in other_syms:
-                    other_syms[symbol.vram_start] = []
-                other_syms[symbol.vram_start].append(symbol)
-
-    return seg_syms, other_syms
+            cands: Set[Interval] = segment_rams[symbol.vram_start]
+            segs: List[Segment] = [cand.data for cand in cands]
+            for seg in segs:
+                if not seg.get_exclusive_ram_id():
+                    seg.add_symbol(symbol)
 
 
 def do_statistics(seg_sizes, rom_bytes, seg_split, seg_cached):
@@ -152,10 +174,84 @@ def merge_configs(main_config, additional_config):
     return main_config
 
 
+def configure_disassembler():
+    # Configure spimdisasm
+    spimdisasm.common.GlobalConfig.PRODUCE_SYMBOLS_PLUS_OFFSET = True
+    spimdisasm.common.GlobalConfig.TRUST_USER_FUNCTIONS = True
+    spimdisasm.common.GlobalConfig.TRUST_JAL_FUNCTIONS = True
+    spimdisasm.common.GlobalConfig.GLABEL_ASM_COUNT = False
+
+    if options.rom_address_padding():
+        spimdisasm.common.GlobalConfig.ASM_COMMENT_OFFSET_WIDTH = 6
+    else:
+        spimdisasm.common.GlobalConfig.ASM_COMMENT_OFFSET_WIDTH = 0
+
+    # spimdisasm is not performing any analyzis on non-text sections so enabling this options is pointless
+    spimdisasm.common.GlobalConfig.AUTOGENERATED_NAMES_BASED_ON_SECTION_TYPE = False
+    spimdisasm.common.GlobalConfig.AUTOGENERATED_NAMES_BASED_ON_DATA_TYPE = False
+
+    spimdisasm.common.GlobalConfig.SYMBOL_FINDER_FILTERED_ADDRESSES_AS_HILO = False
+
+    rabbitizer.config.regNames_userFpcCsr = False
+    rabbitizer.config.regNames_vr4300Cop0NamedRegisters = False
+
+    rabbitizer.config.misc_opcodeLJust = options.mnemonic_ljust() - 1
+
+    rabbitizer.config.regNames_gprAbiNames = rabbitizer.Abi.fromStr(
+        options.get_mips_abi_gpr()
+    )
+    rabbitizer.config.regNames_fprAbiNames = rabbitizer.Abi.fromStr(
+        options.get_mips_abi_float_regs()
+    )
+
+    if options.get_endianess() == "big":
+        spimdisasm.common.GlobalConfig.ENDIAN = spimdisasm.common.InputEndian.BIG
+    else:
+        spimdisasm.common.GlobalConfig.ENDIAN = spimdisasm.common.InputEndian.LITTLE
+
+    rabbitizer.config.pseudos_pseudoMove = False
+
+    selectedCompiler = options.get_compiler()
+    if selectedCompiler == compiler.SN64:
+        rabbitizer.config.regNames_namedRegisters = False
+        rabbitizer.config.toolchainTweaks_sn64DivFix = True
+        rabbitizer.config.toolchainTweaks_treatJAsUnconditionalBranch = True
+        spimdisasm.common.GlobalConfig.ASM_COMMENT = False
+        spimdisasm.common.GlobalConfig.SYMBOL_FINDER_FILTERED_ADDRESSES_AS_HILO = False
+        spimdisasm.common.GlobalConfig.COMPILER = spimdisasm.common.Compiler.SN64
+    elif selectedCompiler == compiler.GCC:
+        rabbitizer.config.toolchainTweaks_treatJAsUnconditionalBranch = True
+        spimdisasm.common.GlobalConfig.COMPILER = spimdisasm.common.Compiler.GCC
+    elif selectedCompiler == compiler.IDO:
+        spimdisasm.common.GlobalConfig.COMPILER = spimdisasm.common.Compiler.IDO
+
+    spimdisasm.common.GlobalConfig.GP_VALUE = options.get_gp()
+
+    spimdisasm.common.GlobalConfig.ASM_TEXT_LABEL = options.get_asm_function_macro()
+    spimdisasm.common.GlobalConfig.ASM_DATA_LABEL = options.get_asm_data_macro()
+    spimdisasm.common.GlobalConfig.ASM_TEXT_END_LABEL = options.get_asm_end_label()
+
+    if spimdisasm.common.GlobalConfig.ASM_TEXT_LABEL == ".globl":
+        spimdisasm.common.GlobalConfig.ASM_TEXT_ENT_LABEL = ".ent"
+        spimdisasm.common.GlobalConfig.ASM_TEXT_FUNC_AS_LABEL = True
+
+    spimdisasm.common.GlobalConfig.LINE_ENDS = options.c_newline()
+
+    if options.get_platform() == "n64":
+        symbols.spim_context.fillDefaultBannedSymbols()
+
+
+def brief_seg_name(seg: Segment, limit: int, ellipsis="…") -> str:
+    s = seg.name.strip()
+    if len(s) > limit:
+        return s[:limit].strip() + ellipsis
+    return s
+
+
 def main(config_path, base_dir, target_path, modes, verbose, use_cache=True):
     global config
 
-    log.write(f"splat {VERSION}")
+    log.write(f"splat {VERSION} (powered by spimdisasm {spimdisasm.__version__})")
 
     # Load config
     config = {}
@@ -210,21 +306,29 @@ def main(config_path, base_dir, target_path, modes, verbose, use_cache=True):
             "__options__": config.get("options"),
         }
 
+    configure_disassembler()
+
     # Initialize segments
     all_segments = initialize_segments(config["segments"])
 
     # Load and process symbols
+    symbols.initialize(all_segments)
+
+    # Assign symbols to segments
+    assign_symbols_to_segments()
+
     if options.mode_active("code"):
-        log.write("Loading and processing symbols")
-        symbols.initialize(all_segments)
+        symbols.initialize_spim_context(all_segments)
 
     # Resolve raster/palette siblings
     if options.mode_active("img"):
         palettes.initialize(all_segments)
 
     # Scan
-    log.write("Starting scan")
-    for segment in all_segments:
+    scan_bar = tqdm.tqdm(all_segments, total=len(all_segments))
+    for segment in scan_bar:
+        assert isinstance(segment, Segment)
+        scan_bar.set_description(f"Scanning {brief_seg_name(segment, 20)}")
         typ = segment.type
         if segment.type == "bin" and segment.is_name_default():
             typ = "unk"
@@ -241,13 +345,6 @@ def main(config_path, base_dir, target_path, modes, verbose, use_cache=True):
                 if segment.cache() == cache.get(segment.unique_id()):
                     continue
 
-            if segment.needs_symbols:
-                segment_symbols, other_symbols = get_segment_symbols(
-                    segment, all_segments
-                )
-                segment.given_seg_symbols = segment_symbols
-                segment.given_ext_symbols = other_symbols
-
             segment.did_run = True
             segment.scan(rom_bytes)
 
@@ -255,11 +352,12 @@ def main(config_path, base_dir, target_path, modes, verbose, use_cache=True):
 
             seg_split[typ] += 1
 
-        log.dot(status=segment.status())
-
     # Split
-    log.write("Starting split")
-    for segment in all_segments:
+    for segment in tqdm.tqdm(
+        all_segments,
+        total=len(all_segments),
+        desc=f"Splitting {brief_seg_name(segment, 20)}",
+    ):
         if use_cache:
             cached = segment.cache()
 
@@ -274,12 +372,14 @@ def main(config_path, base_dir, target_path, modes, verbose, use_cache=True):
         if segment.should_split():
             segment.split(rom_bytes)
 
-        log.dot(status=segment.status())
-
     if options.mode_active("ld"):
         global linker_writer
         linker_writer = LinkerWriter()
-        for segment in all_segments:
+        for segment in tqdm.tqdm(
+            all_segments,
+            total=len(all_segments),
+            desc=f"Writing linker script {brief_seg_name(segment, 20)}",
+        ):
             linker_writer.add(segment)
         linker_writer.save_linker_script()
         linker_writer.save_symbol_header()
@@ -300,22 +400,27 @@ def main(config_path, base_dir, target_path, modes, verbose, use_cache=True):
             for s in symbols.all_symbols
             if s.referenced and not s.defined and not s.dead and s.type == "func"
         ]
-        if len(to_write) > 0:
-            with open(options.get_undefined_funcs_auto_path(), "w", newline="\n") as f:
-                for symbol in to_write:
-                    f.write(f"{symbol.name} = 0x{symbol.vram_start:X};\n")
+        to_write.sort(key=lambda x: x.vram_start)
+
+        with open(options.get_undefined_funcs_auto_path(), "w", newline="\n") as f:
+            for symbol in to_write:
+                f.write(f"{symbol.name} = 0x{symbol.vram_start:X};\n")
 
     # write undefined_syms_auto.txt
     if options.get_create_undefined_syms_auto():
         to_write = [
             s
             for s in symbols.all_symbols
-            if s.referenced and not s.defined and not s.dead and not s.type == "func"
+            if s.referenced
+            and not s.defined
+            and not s.dead
+            and s.type not in {"func", "label", "jtbl_label"}
         ]
-        if len(to_write) > 0:
-            with open(options.get_undefined_syms_auto_path(), "w", newline="\n") as f:
-                for symbol in to_write:
-                    f.write(f"{symbol.name} = 0x{symbol.vram_start:X};\n")
+        to_write.sort(key=lambda x: x.vram_start)
+
+        with open(options.get_undefined_syms_auto_path(), "w", newline="\n") as f:
+            for symbol in to_write:
+                f.write(f"{symbol.name} = 0x{symbol.vram_start:X};\n")
 
     # print warnings during split
     for segment in all_segments:
diff --git a/tools/splat/util/compiler.py b/tools/splat/util/compiler.py
index 046dee5084..3af478428c 100644
--- a/tools/splat/util/compiler.py
+++ b/tools/splat/util/compiler.py
@@ -24,7 +24,9 @@ SN64 = Compiler(
     c_newline="\r\n",
 )
 
-compiler_for_name = {"GCC": GCC, "SN64": SN64}
+IDO = Compiler("IDO")
+
+compiler_for_name = {"GCC": GCC, "SN64": SN64, "IDO": IDO}
 
 
 def for_name(name: str) -> Compiler:
diff --git a/tools/splat/util/log.py b/tools/splat/util/log.py
index 63ad240cee..e5cca3580e 100644
--- a/tools/splat/util/log.py
+++ b/tools/splat/util/log.py
@@ -31,13 +31,6 @@ def parsing_error_preamble(path, line_num, line):
     write(f"\t{line}")
 
 
-def dot(status: Status = None):
-    global newline
-
-    print(status_to_ansi(status) + ".", end="")
-    newline = False
-
-
 def status_to_ansi(status: Status):
     if status == "ok":
         return Fore.GREEN
diff --git a/tools/splat/util/n64/find_code_length.py b/tools/splat/util/n64/find_code_length.py
index 3b8d958200..8d7b8b522f 100755
--- a/tools/splat/util/n64/find_code_length.py
+++ b/tools/splat/util/n64/find_code_length.py
@@ -1,22 +1,25 @@
 #! /usr/bin/env python3
 
-from capstone import *
-
-from capstone import Cs, CS_ARCH_MIPS, CS_MODE_MIPS64, CS_MODE_BIG_ENDIAN
-from capstone.mips import *
-
 import argparse
+import spimdisasm
+import rabbitizer
+
+
+def int_any_base(x):
+    return int(x, 0)
 
-md = Cs(CS_ARCH_MIPS, CS_MODE_MIPS64 + CS_MODE_BIG_ENDIAN)
 
 parser = argparse.ArgumentParser(
     description="Given a rom and start offset, find where the code ends"
 )
 parser.add_argument("rom", help="path to a .z64 rom")
-parser.add_argument("start", help="start offset")
-parser.add_argument("--end", help="end offset", default=None)
+parser.add_argument("start", help="start offset", type=int_any_base)
+parser.add_argument("--end", help="end offset", default=None, type=int_any_base)
 parser.add_argument(
-    "--vram", help="vram address to start disassembly at", default="0x80000000"
+    "--vram",
+    help="vram address to start disassembly at",
+    default="0x80000000",
+    type=int_any_base,
 )
 
 
@@ -24,28 +27,35 @@ def run(rom_bytes, start_offset, vram, end_offset=None):
     rom_addr = start_offset
     last_return = rom_addr
 
-    for insn in md.disasm(rom_bytes[start_offset:], vram):
-        if insn.mnemonic == "jr" and insn.op_str == "$ra":
+    wordList = spimdisasm.common.Utils.bytesToBEWords(rom_bytes[start_offset:])
+    for word in wordList:
+        insn = rabbitizer.Instruction(word)
+        if not insn.isImplemented():
+            break
+
+        if insn.isJrRa():
             last_return = rom_addr
         rom_addr += 4
         if end_offset and rom_addr >= end_offset:
             break
 
-    return last_return + (0x10 - (last_return % 0x10))
+    # align to next 0x10 boundary
+    end = last_return + 0x10
+    end -= end % 0x10
+    return end
 
 
 def main():
     args = parser.parse_args()
 
-    rom_bytes = open(args.rom, "rb").read()
-    start = int(args.start, 0)
-    end = None
-    vram = int(args.vram, 0)
+    with open(args.rom, "rb") as f:
+        rom_bytes = f.read()
 
-    if args.end:
-        end = int(args.end, 0)
+    start = args.start
+    end = args.end
+    vram = args.vram
 
-    print(f"{run(rom_bytes, start, vram, end):X}")
+    print(f"0x{run(rom_bytes, start, vram, end):X}")
 
 
 if __name__ == "__main__":
diff --git a/tools/splat/util/n64/rominfo.py b/tools/splat/util/n64/rominfo.py
index 34a4e89d3b..52ad30f98a 100755
--- a/tools/splat/util/n64/rominfo.py
+++ b/tools/splat/util/n64/rominfo.py
@@ -1,21 +1,28 @@
 #! /usr/bin/env python3
 
+from dataclasses import dataclass
+
+import sys
 import argparse
 import itertools
 import struct
+import spimdisasm
+import rabbitizer
 
 from pathlib import Path
 
 import hashlib
 import zlib
 
-from capstone import Cs, CS_ARCH_MIPS, CS_MODE_MIPS64, CS_MODE_BIG_ENDIAN
-
 parser = argparse.ArgumentParser(description="Gives information on N64 roms")
 parser.add_argument("rom", help="path to an N64 rom")
 parser.add_argument(
     "--header-encoding",
-    help="Text encoding the game header is using; see docs.python.org/3/library/codecs.html#standard-encodings for valid encodings",
+    dest="header_encoding",
+    help=(
+        "Text encoding the game header is using;"
+        " see docs.python.org/3/library/codecs.html#standard-encodings for valid encodings"
+    ),
 )
 
 country_codes = {
@@ -42,27 +49,34 @@ country_codes = {
     0x59: "European",
 }
 
+
+@dataclass
+class CIC:
+    ntsc_name: str
+    pal_name: str
+    offset: int
+
+
 crc_to_cic = {
-    0x6170A4A1: {"ntsc-name": "6101", "pal-name": "7102", "offset": 0x000000},
-    0x90BB6CB5: {"ntsc-name": "6102", "pal-name": "7101", "offset": 0x000000},
-    0x0B050EE0: {"ntsc-name": "6103", "pal-name": "7103", "offset": 0x100000},
-    0x98BC2C86: {"ntsc-name": "6105", "pal-name": "7105", "offset": 0x000000},
-    0xACC8580A: {"ntsc-name": "6106", "pal-name": "7106", "offset": 0x200000},
-    0x00000000: {"ntsc-name": "unknown", "pal-name": "unknown", "offset": 0x0000000},
+    0x6170A4A1: CIC("6101", "7102", 0x000000),
+    0x90BB6CB5: CIC("6102", "7101", 0x000000),
+    0x0B050EE0: CIC("6103", "7103", 0x100000),
+    0x98BC2C86: CIC("6105", "7105", 0x000000),
+    0xACC8580A: CIC("6106", "7106", 0x200000),
 }
+unknown_cic = CIC("unknown", "unknown", 0x0000000)
 
 
 def swap_bytes(data):
     return bytes(
         itertools.chain.from_iterable(
-            struct.pack(">H", x) for x, in struct.iter_unpack("<H", data)
+            struct.pack(">H", x) for (x,) in struct.iter_unpack("<H", data)
         )
     )
 
 
-def read_rom(rom_path):
-    with open(rom_path, "rb") as f:
-        rom_bytes = f.read()
+def read_rom(rom_path: Path):
+    rom_bytes = rom_path.read_bytes()
 
     if rom_path.suffix.lower() == ".n64":
         print("Warning: Input file has .n64 suffix, byte-swapping!")
@@ -70,24 +84,21 @@ def read_rom(rom_path):
         as_z64 = rom_path.with_suffix(".z64")
         if not as_z64.exists():
             print(f"Writing down {as_z64}")
-            with open(as_z64, "wb") as o:
-                o.write(rom_bytes)
+            as_z64.write_bytes(rom_bytes)
     return rom_bytes
 
 
-def get_cic(rom_bytes):
-    crc = zlib.crc32(rom_bytes[0x40:0x1000])
-    if crc in crc_to_cic:
-        return crc_to_cic[crc]
-    else:
-        return crc_to_cic[0]
+def get_cic(rom_bytes: bytes):
+    ipl3_crc = zlib.crc32(rom_bytes[0x40:0x1000])
+
+    return crc_to_cic.get(ipl3_crc, unknown_cic)
 
 
-def get_entry_point(program_counter, cic):
-    return program_counter - cic["offset"]
+def get_entry_point(program_counter: int, cic: CIC):
+    return program_counter - cic.offset
 
 
-def guess_header_encoding(rom_bytes):
+def guess_header_encoding(rom_bytes: bytes):
     header = rom_bytes[0x20:0x34]
     encodings = ["ASCII", "shift_jis", "euc-jp"]
     for encoding in encodings:
@@ -98,12 +109,11 @@ def guess_header_encoding(rom_bytes):
             # we guessed wrong...
             pass
 
-    print("Unknown header encoding, please raise an Issue with us")
-    exit(1)
+    sys.exit("Unknown header encoding, please raise an Issue with us")
 
 
-def get_info(rom_path, rom_bytes=None, header_encoding=None):
-    if not rom_bytes:
+def get_info(rom_path: Path, rom_bytes: bytes = None, header_encoding=None):
+    if rom_bytes is None:
         rom_bytes = read_rom(rom_path)
 
     if header_encoding is None:
@@ -112,31 +122,25 @@ def get_info(rom_path, rom_bytes=None, header_encoding=None):
     return get_info_bytes(rom_bytes, header_encoding)
 
 
-def get_info_bytes(rom_bytes, header_encoding):
-    program_counter = int(rom_bytes[0x8:0xC].hex(), 16)
+def get_info_bytes(rom_bytes: bytes, header_encoding):
+    (program_counter,) = struct.unpack(">I", rom_bytes[0x8:0xC])
     libultra_version = chr(rom_bytes[0xF])
-    crc1 = rom_bytes[0x10:0x14].hex().upper()
-    crc2 = rom_bytes[0x14:0x18].hex().upper()
+    checksum = rom_bytes[0x10:0x18].hex().upper()
 
     try:
         name = rom_bytes[0x20:0x34].decode(header_encoding).strip()
     except:
-        print(
-            "splat could not decode the game name; try using a different encoding by passing the --header-encoding argument (see docs.python.org/3/library/codecs.html#standard-encodings for valid encodings)"
+        sys.exit(
+            "splat could not decode the game name;"
+            " try using a different encoding by passing the --header-encoding argument"
+            " (see docs.python.org/3/library/codecs.html#standard-encodings for valid encodings)"
         )
-        exit(1)
 
     country_code = rom_bytes[0x3E]
 
     cic = get_cic(rom_bytes)
     entry_point = get_entry_point(program_counter, cic)
 
-    # TODO: add support for
-    # compression_formats = []
-    #  for format in ["Yay0", "vpk0"]:
-    #     if rom_bytes.find(bytes(format, "ASCII")) != -1:
-    #         compression_formats.append(format)
-
     compiler = get_compiler_info(rom_bytes, entry_point, print_result=False)
 
     sha1 = hashlib.sha1(rom_bytes).hexdigest()
@@ -146,8 +150,7 @@ def get_info_bytes(rom_bytes, header_encoding):
         header_encoding,
         country_code,
         libultra_version,
-        crc1,
-        crc2,
+        checksum,
         cic,
         entry_point,
         len(rom_bytes),
@@ -159,15 +162,14 @@ def get_info_bytes(rom_bytes, header_encoding):
 class N64Rom:
     def __init__(
         self,
-        name,
+        name: str,
         header_encoding,
         country_code,
         libultra_version,
-        crc1,
-        crc2,
-        cic,
-        entry_point,
-        size,
+        checksum,
+        cic: CIC,
+        entry_point: int,
+        size: int,
         compiler,
         sha1,
     ):
@@ -175,8 +177,7 @@ class N64Rom:
         self.header_encoding = header_encoding
         self.country_code = country_code
         self.libultra_version = libultra_version
-        self.crc1 = crc1
-        self.crc2 = crc2
+        self.checksum = checksum
         self.cic = cic
         self.entry_point = entry_point
         self.size = size
@@ -188,28 +189,33 @@ class N64Rom:
 
 
 def get_compiler_info(rom_bytes, entry_point, print_result=True):
-    md = Cs(CS_ARCH_MIPS, CS_MODE_MIPS64 + CS_MODE_BIG_ENDIAN)
-    md.detail = True
-
     jumps = 0
     branches = 0
 
-    for insn in md.disasm(rom_bytes[0x1000:], entry_point):
-        if insn.mnemonic == "j":
+    vram = entry_point
+    wordList = spimdisasm.common.Utils.bytesToBEWords(rom_bytes[0x1000:])
+    for word in wordList:
+        insn = rabbitizer.Instruction(word)
+        if not insn.isImplemented():
+            break
+
+        if insn.uniqueId == rabbitizer.InstrId.cpu_j:
             jumps += 1
-        elif insn.mnemonic == "b":
+        elif insn.uniqueId == rabbitizer.InstrId.cpu_b:
             branches += 1
 
     compiler = "IDO" if branches > jumps else "GCC"
     if print_result:
         print(
-            f"{branches} branches and {jumps} jumps detected in the first code segment. Compiler is most likely {compiler}"
+            f"{branches} branches and {jumps} jumps detected in the first code segment."
+            f" Compiler is most likely {compiler}"
         )
     return compiler
 
 
-# TODO: support .n64 extension
 def main():
+    rabbitizer.config.pseudos_pseudoB = True
+
     args = parser.parse_args()
     rom_bytes = read_rom(Path(args.rom))
     rom = get_info(Path(args.rom), rom_bytes, args.header_encoding)
@@ -217,9 +223,8 @@ def main():
     print("Image name: " + rom.name)
     print("Country code: " + chr(rom.country_code) + " - " + rom.get_country_name())
     print("Libultra version: " + rom.libultra_version)
-    print("CRC1: " + rom.crc1)
-    print("CRC2: " + rom.crc2)
-    print("CIC: " + rom.cic["ntsc-name"] + " / " + rom.cic["pal-name"])
+    print("Checksum: " + rom.checksum)
+    print("CIC: " + rom.cic.ntsc_name + " / " + rom.cic.pal_name)
     print("RAM entry point: " + hex(rom.entry_point))
     print("Header encoding: " + rom.header_encoding)
     print("")
diff --git a/tools/splat/util/options.py b/tools/splat/util/options.py
index ceee838d07..d16e76792b 100644
--- a/tools/splat/util/options.py
+++ b/tools/splat/util/options.py
@@ -226,10 +226,16 @@ def get_subalign() -> int:
     return opts.get("subalign", 16)
 
 
-# Determines whether to automatically configure the linker script to link against common sections for all files
-# when the yaml doesn't have specific configurations for these sections. See release notes for details
-def auto_all_sections() -> bool:
-    return opts.get("auto_all_sections", False)
+# The following option determines whether to automatically configure the linker script to link against
+# specified sections for all "base" (asm/c) files when the yaml doesn't have manual configurations
+# for these sections.
+def auto_all_sections() -> List[str]:
+    val = opts.get("auto_all_sections", [".data", ".rodata", ".bss"])
+    if not isinstance(val, list):
+        raise RuntimeError(
+            'auto_all_sections must be a list (for example, [".data", ".rodata", ".bss"])'
+        )
+    return val
 
 
 # Determines the desired path to the linker symbol header, which exposes externed definitions for all segment ram/rom start/end locations
@@ -268,10 +274,12 @@ def ld_section_labels() -> List[str]:
 def get_create_c_files() -> bool:
     return opts.get("create_c_files", True)
 
+
 # Determines whether to "auto-decompile" empty functions
 def get_auto_decompile_empty_functions() -> bool:
     return opts.get("auto_decompile_empty_functions", True)
 
+
 # Determines whether to detect matched/unmatched functions in existing c files
 # so we can avoid creating .s files for already-decompiled functions
 def do_c_func_detection() -> bool:
@@ -287,6 +295,16 @@ def c_newline() -> str:
 # (Dis)assembly-related options
 ################################################################################
 
+# The following options determine the format that symbols should be named by default
+def get_symbol_name_format() -> str:
+    return opts.get("symbol_name_format", "$VRAM")
+
+
+# Same as above but for symbols with no rom address
+def get_symbol_name_format_no_rom() -> str:
+    return opts.get("symbol_name_format_no_rom", "$VRAM_$SEG")
+
+
 # Determines whether to detect and hint to the user about likely file splits when disassembling
 def find_file_boundaries() -> bool:
     return opts.get("find_file_boundaries", True)
@@ -332,6 +350,20 @@ def rom_address_padding() -> bool:
     return opts.get("rom_address_padding", False)
 
 
+# Determines which ABI names to use for general purpose registers
+# Valid values: 'numeric', 'o32', 'n32', 'n64'
+def get_mips_abi_gpr() -> str:
+    return opts.get("mips_abi_gpr", "o32")
+
+
+# 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
+def get_mips_abi_float_regs() -> str:
+    return opts.get("mips_abi_float_regs", "numeric")
+
+
 ################################################################################
 # N64-specific options
 ################################################################################
@@ -341,6 +373,16 @@ def get_header_encoding() -> str:
     return opts.get("header_encoding", "ASCII")
 
 
+# Determines the type gfx ucode (used by gfx segments)
+# Valid options are ['f3d', 'f3db', 'f3dex', 'f3dexb', 'f3dex2']
+def get_gfx_ucode() -> str:
+    valid_options = ["f3d", "f3db", "f3dex", "f3dexb", "f3dex2"]
+    ret = opts.get("gfx_ucode", "f3dex2")
+    if ret not in valid_options:
+        log.error(f"Invalid gfx_ucode: {ret}. Valid options are: {valid_options}")
+    return ret
+
+
 ################################################################################
 # Compiler-specific options
 ################################################################################
diff --git a/tools/splat/util/range.py b/tools/splat/util/range.py
index 7716873669..d3e3c60e02 100644
--- a/tools/splat/util/range.py
+++ b/tools/splat/util/range.py
@@ -1,7 +1,11 @@
+import dataclasses
+from typing import Optional
+
+
+@dataclasses.dataclass
 class Range:
-    def __init__(self, start=None, end=None):
-        self.start = start
-        self.end = end
+    start: Optional[int] = None
+    end: Optional[int] = None
 
     def has_start(self):
         return self.start is not None
diff --git a/tools/splat/util/symbols.py b/tools/splat/util/symbols.py
index c3697ca0f4..dfabf3034a 100644
--- a/tools/splat/util/symbols.py
+++ b/tools/splat/util/symbols.py
@@ -1,12 +1,21 @@
-from dataclasses import dataclass
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, TYPE_CHECKING, Set
+import spimdisasm
+import rabbitizer
+import tqdm
+
+# circular import
+if TYPE_CHECKING:
+    from segtypes.segment import Segment
 
-from capstone import CsInsn
 from util import options, log
 
-all_symbols: "List[Symbol]" = []
-symbol_ranges: "List[Symbol]" = []
-sym_isolated_map: "Dict[Symbol, bool]" = {}
+all_symbols: List["Symbol"] = []
+all_symbols_dict: Dict[int, List["Symbol"]] = {}
+ignored_addresses: Set[int] = set()
+symbol_ranges: List["Symbol"] = []
+
+# Initialize a spimdisasm context, used to store symbols and functions
+spim_context = spimdisasm.common.Context()
 
 TRUEY_VALS = ["true", "on", "yes", "y"]
 FALSEY_VALS = ["false", "off", "no", "n"]
@@ -20,19 +29,37 @@ def is_falsey(str: str) -> bool:
     return str.lower() in FALSEY_VALS
 
 
-def initialize(all_segments):
+def add_symbol(sym: "Symbol"):
+    all_symbols.append(sym)
+    if sym.vram_start is not None:
+        if sym.vram_start not in all_symbols_dict:
+            all_symbols_dict[sym.vram_start] = []
+        all_symbols_dict[sym.vram_start].append(sym)
+
+
+def initialize(all_segments: "List[Segment]"):
     global all_symbols
+    global all_symbols_dict
     global symbol_ranges
 
     all_symbols = []
+    all_symbols_dict = {}
     symbol_ranges = []
 
+    def get_seg_for_name(name: str) -> Optional["Segment"]:
+        for segment in all_segments:
+            if segment.name == name:
+                return segment
+        return None
+
     # Manual list of func name / addrs
     for path in options.get_symbol_addrs_paths():
         if path.exists():
             with open(path) as f:
                 sym_addrs_lines = f.readlines()
-                for line_num, line in enumerate(sym_addrs_lines):
+                for line_num, line in enumerate(
+                    tqdm.tqdm(sym_addrs_lines, desc=f"Loading symbols ({path.stem})")
+                ):
                     line = line.strip()
                     if not line == "" and not line.startswith("//"):
                         comment_loc = line.find("//")
@@ -59,10 +86,11 @@ def initialize(all_segments):
 
                         sym = Symbol(addr, given_name=name)
 
+                        ignore_sym = False
                         if line_ext:
                             for info in line_ext.split(" "):
                                 if ":" in info:
-                                    if info.count(':') > 1:
+                                    if info.count(":") > 1:
                                         log.parsing_error_preamble(path, line_num, line)
                                         log.write(f"Too many ':'s in '{info}'")
                                         log.error("")
@@ -70,14 +98,17 @@ def initialize(all_segments):
                                     attr_name, attr_val = info.split(":")
                                     if attr_name == "":
                                         log.parsing_error_preamble(path, line_num, line)
-                                        log.write(f"Missing attribute name in '{info}', is there extra whitespace?")
+                                        log.write(
+                                            f"Missing attribute name in '{info}', is there extra whitespace?"
+                                        )
                                         log.error("")
                                     if attr_val == "":
                                         log.parsing_error_preamble(path, line_num, line)
-                                        log.write(f"Missing attribute value in '{info}', is there extra whitespace?")
+                                        log.write(
+                                            f"Missing attribute value in '{info}', is there extra whitespace?"
+                                        )
                                         log.error("")
 
-
                                     # Non-Boolean attributes
                                     try:
                                         if attr_name == "type":
@@ -86,12 +117,27 @@ def initialize(all_segments):
                                             continue
                                         if attr_name == "size":
                                             size = int(attr_val, 0)
-                                            sym.size = size
+                                            sym.given_size = size
                                             continue
                                         if attr_name == "rom":
                                             rom_addr = int(attr_val, 0)
                                             sym.rom = rom_addr
                                             continue
+                                        if attr_name == "segment":
+                                            seg = get_seg_for_name(attr_val)
+                                            if seg is None:
+                                                log.parsing_error_preamble(
+                                                    path, line_num, line
+                                                )
+                                                log.write(
+                                                    f"Cannot find segment '{attr_val}'"
+                                                )
+                                                log.error("")
+                                            else:
+                                                # Add segment to symbol, symbol to segment
+                                                sym.segment = seg
+                                                seg.add_symbol(sym)
+                                            continue
                                     except:
                                         log.parsing_error_preamble(path, line_num, line)
                                         log.write(
@@ -115,39 +161,180 @@ def initialize(all_segments):
                                         )
                                         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
+                                        if attr_name == "extract":
+                                            sym.extract = tf_val
+                                            continue
+                                        if attr_name == "ignore":
+                                            ignore_sym = tf_val
+                                            continue
+                        if ignore_sym:
+                            ignored_addresses.add(sym.vram_start)
+                            ignore_sym = False
+                            continue
 
-                                    if attr_name == "dead":
-                                        sym.dead = tf_val
-                                        continue
-                                    if attr_name == "defined":
-                                        sym.defined = tf_val
-                                        continue
-                                    if attr_name == "extract":
-                                        sym.extract = tf_val
-                                        continue
-                        all_symbols.append(sym)
+                        sym.user_declared = True
+                        add_symbol(sym)
 
                         # Symbol ranges
                         if sym.size > 4:
                             symbol_ranges.append(sym)
 
-                        is_symbol_isolated(sym, all_segments)
 
+def initialize_spim_context(all_segments: "List[Segment]") -> None:
+    global_vrom_start = None
+    global_vrom_end = None
+    global_vram_start = None
+    global_vram_end = None
 
-def is_symbol_isolated(symbol, all_segments):
-    if symbol in sym_isolated_map:
-        return sym_isolated_map[symbol]
-
-    relevant_segs = 0
+    spim_context.bannedSymbols |= ignored_addresses
 
     for segment in all_segments:
-        if segment.contains_vram(symbol.vram_start):
-            relevant_segs += 1
-            if relevant_segs > 1:
-                break
+        if segment.type == "code":
+            # We only care about the VRAMs of code segments
+            if isinstance(segment.vram_start, int) and isinstance(
+                segment.vram_end, int
+            ):
+                ram_id = segment.get_exclusive_ram_id()
+                if ram_id is None:
+                    if global_vram_start is None:
+                        global_vram_start = segment.vram_start
+                    else:
+                        if segment.vram_start < global_vram_start:
+                            global_vram_start = segment.vram_start
 
-    sym_isolated_map[symbol] = relevant_segs < 2
-    return sym_isolated_map[symbol]
+                    if global_vram_end is None:
+                        global_vram_end = segment.vram_end
+                    else:
+                        if global_vram_end < segment.vram_end:
+                            global_vram_end = segment.vram_end
+
+                    if isinstance(segment.rom_start, int):
+                        if global_vrom_start is None:
+                            global_vrom_start = segment.rom_start
+                        else:
+                            if segment.rom_start < global_vrom_start:
+                                global_vrom_start = segment.rom_start
+
+                    if isinstance(segment.rom_end, int):
+                        if global_vrom_end is None:
+                            global_vrom_end = segment.rom_end
+                        else:
+                            if global_vrom_end < segment.rom_end:
+                                global_vrom_end = segment.rom_end
+
+                else:
+                    spim_context.addOverlaySegment(
+                        ram_id,
+                        segment.rom_start,
+                        segment.rom_end,
+                        segment.vram_start,
+                        segment.vram_end,
+                    )
+
+    if (
+        global_vram_start is not None
+        and global_vram_end is not None
+        and global_vrom_start is not None
+        and global_vrom_end is not None
+    ):
+        spim_context.globalSegment.changeRanges(
+            global_vrom_start, global_vrom_end, global_vram_start, global_vram_end
+        )
+
+
+def add_symbol_to_spim_section(
+    section: spimdisasm.common.ElementBase, sym: "Symbol"
+) -> spimdisasm.common.ContextSymbol:
+    if sym.type == "func":
+        context_sym = section.addFunction(
+            sym.vram_start, isAutogenerated=not sym.user_declared, symbolVrom=sym.rom
+        )
+    elif sym.type == "jtbl":
+        context_sym = section.addJumpTable(
+            sym.vram_start, isAutogenerated=not sym.user_declared, symbolVrom=sym.rom
+        )
+    elif sym.type == "jtbl_label":
+        context_sym = section.addJumpTableLabel(
+            sym.vram_start, isAutogenerated=not sym.user_declared, symbolVrom=sym.rom
+        )
+    elif sym.type == "label":
+        context_sym = section.addBranchLabel(
+            sym.vram_start, isAutogenerated=not sym.user_declared, symbolVrom=sym.rom
+        )
+    else:
+        context_sym = section.addSymbol(
+            sym.vram_start, isAutogenerated=not sym.user_declared, symbolVrom=sym.rom
+        )
+        if sym.type and sym.type != "unknown":
+            context_sym.type = sym.type
+
+    if sym.user_declared:
+        context_sym.isUserDeclared = True
+    if sym.defined:
+        context_sym.isDefined = True
+    if sym.rom is not None:
+        context_sym.vromAddress = sym.rom
+    if sym.given_size is not None:
+        context_sym.size = sym.size
+    context_sym.setNameGetCallbackIfUnset(lambda _: sym.name)
+
+    return context_sym
+
+
+def create_symbol_from_spim_symbol(
+    segment: "Segment", context_sym: spimdisasm.common.ContextSymbol
+) -> "Symbol":
+    in_segment = False
+
+    sym_type = None
+    if context_sym.type == spimdisasm.common.SymbolSpecialType.jumptable:
+        in_segment = True
+        sym_type = "jtbl"
+    elif context_sym.type == spimdisasm.common.SymbolSpecialType.function:
+        sym_type = "func"
+    elif context_sym.type == spimdisasm.common.SymbolSpecialType.branchlabel:
+        in_segment = True
+        sym_type = "label"
+    elif context_sym.type == spimdisasm.common.SymbolSpecialType.jumptablelabel:
+        in_segment = True
+        sym_type = "jtbl_label"
+
+    if not in_segment:
+        if (
+            context_sym.overlayCategory is None
+            and segment.get_exclusive_ram_id() is None
+        ):
+            in_segment = segment.contains_vram(context_sym.vram)
+        elif context_sym.overlayCategory == segment.get_exclusive_ram_id():
+            if context_sym.vromAddress is not None:
+                in_segment = segment.contains_rom(context_sym.vromAddress)
+            else:
+                in_segment = segment.contains_vram(context_sym.vram)
+
+    sym = segment.create_symbol(
+        context_sym.vram, in_segment, type=sym_type, reference=True
+    )
+
+    # To keep the symbol name in sync between splat and spimdisasm
+    context_sym.setNameGetCallback(lambda _: sym.name)
+
+    if context_sym.size is not None:
+        sym.given_size = context_sym.getSize()
+    if context_sym.vromAddress is not None:
+        sym.rom = context_sym.getVrom()
+    if context_sym.isDefined:
+        sym.defined = True
+    if context_sym.referenceCounter > 0:
+        sym.referenced = True
+
+    return sym
 
 
 def retrieve_from_ranges(vram, rom=None):
@@ -169,36 +356,79 @@ def retrieve_from_ranges(vram, rom=None):
         return None
 
 
-@dataclass
-class Instruction:
-    instruction: CsInsn
-    mnemonic: str
-    op_str: str
-    rom_addr: int
-    is_gp: bool = False
-    is_hi: bool = False
-    is_lo: bool = False
-    hi_lo_sym: Optional["Symbol"] = None
-    sym_offset_str: str = ""
-    hi_lo_reg: str = ""
-
-
 class Symbol:
+    def __init__(
+        self,
+        vram: int,
+        given_name: Optional[str] = None,
+        rom: Optional[int] = None,
+        type: Optional[str] = "unknown",
+        given_size: Optional[int] = None,
+        segment: Optional["Segment"] = None,
+    ):
+        self.defined: bool = False
+        self.referenced: bool = False
+        self.vram_start = vram
+        self.rom = rom
+        self.type = type
+        self.given_size = given_size
+        self.given_name = given_name
+        self.access_mnemonic: Optional[rabbitizer.Enum] = None
+        self.disasm_str: Optional[str] = None
+        self.dead: bool = False
+        self.extract: bool = True
+        self.user_declared: bool = False
+        self.segment: Optional["Segment"] = segment
+
+    def __str__(self):
+        return self.name
+
+    def format_name(self, format: str) -> str:
+        ret = format
+
+        ret = ret.replace("$VRAM", f"{self.vram_start:08X}")
+
+        if "$ROM" in ret:
+            if not isinstance(self.rom, int):
+                log.error(
+                    f"Attempting to rom-name a symbol with no ROM address: {self.vram_start:X} typed {self.type}"
+                )
+            ret = ret.replace("$ROM", f"{self.rom:X}")
+
+        if "$SEG" in ret:
+            if self.segment is None:
+                # This probably is fine - we can't expect every symbol to have a segment. Fall back to just the ram address
+                return f"{self.vram_start:X}"
+            assert self.segment is not None
+            ret = ret.replace("$SEG", self.segment.name)
+
+        return ret
+
     @property
     def default_name(self) -> str:
-        suffix = f"_{self.vram_start:X}"
-
-        if self.in_overlay:
-            suffix += f"_{self.rom:X}"
+        if self.segment:
+            if isinstance(self.rom, int):
+                suffix = self.format_name(self.segment.symbol_name_format)
+            else:
+                suffix = self.format_name(self.segment.symbol_name_format_no_rom)
+        else:
+            if isinstance(self.rom, int):
+                suffix = self.format_name(options.get_symbol_name_format())
+            else:
+                suffix = self.format_name(options.get_symbol_name_format_no_rom())
 
         if self.type == "func":
             prefix = "func"
         elif self.type == "jtbl":
             prefix = "jtbl"
+        elif self.type == "jtbl_label":
+            return f"L{suffix}"
+        elif self.type == "label":
+            return f".L{suffix}"
         else:
             prefix = "D"
 
-        return prefix + suffix
+        return f"{prefix}_{suffix}"
 
     @property
     def rom_end(self):
@@ -212,31 +442,14 @@ class Symbol:
     def name(self) -> str:
         return self.given_name if self.given_name else self.default_name
 
+    @property
+    def size(self) -> int:
+        if self.given_size is not None:
+            return self.given_size
+        return 4
+
     def contains_vram(self, offset):
         return offset >= self.vram_start and offset < self.vram_end
 
     def contains_rom(self, offset):
         return offset >= self.rom and offset < self.rom_end
-
-    def __init__(
-        self,
-        vram,
-        given_name: str = "",
-        rom=None,
-        type="unknown",
-        in_overlay=False,
-        size=4,
-    ):
-        self.defined = False
-        self.referenced = False
-        self.vram_start = vram
-        self.rom = rom
-        self.type = type
-        self.in_overlay = in_overlay
-        self.size = size
-        self.given_name: str = given_name
-        self.insns: List[Instruction] = []
-        self.access_mnemonic = None
-        self.disasm_str = None
-        self.dead = False
-        self.extract = True
diff --git a/tools/splat_ext/pm_effect_loads.py b/tools/splat_ext/pm_effect_loads.py
index e50070d3b6..822cbc321a 100644
--- a/tools/splat_ext/pm_effect_loads.py
+++ b/tools/splat_ext/pm_effect_loads.py
@@ -1,7 +1,6 @@
-from yaml.loader import Loader
 from segtypes.n64.segment import N64Segment
 from util import options
-import yaml
+import yaml as yaml_loader
 
 class N64SegPm_effect_loads(N64Segment):
     effects = []
@@ -47,11 +46,40 @@ glabel {name}
     def effect_path(self, effect):
         return options.get_build_path() / "asm" / "effects" / f"{effect}.s"
 
-    def __init__(self, rom_start, rom_end, type, name, vram_start, extract, given_subalign, given_is_overlay, given_dir, args, yml):
-        super().__init__(rom_start, rom_end, type, name, vram_start, extract, given_subalign, given_is_overlay, given_dir, args, yml)
+    def __init__(
+        self,
+        rom_start,
+        rom_end,
+        type,
+        name,
+        vram_start,
+        extract,
+        given_subalign,
+        exclusive_ram_id,
+        given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
+        args,
+        yaml,
+    ):
+        super().__init__(
+            rom_start,
+            rom_end,
+            type,
+            name,
+            vram_start,
+            extract,
+            given_subalign,
+            exclusive_ram_id,
+            given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
+        )
 
         with open(options.get_asm_path() / ".." / "effects.yaml") as f:
-            self.effects = yaml.load(f.read(), Loader=yaml.SafeLoader)
+            self.effects = yaml_loader.load(f.read(), Loader=yaml_loader.SafeLoader)
 
     def split(self, rom_bytes):
         for i, effect in enumerate(self.effects):
diff --git a/tools/splat_ext/pm_effect_shims.py b/tools/splat_ext/pm_effect_shims.py
index 0b346177ea..da583bee85 100644
--- a/tools/splat_ext/pm_effect_shims.py
+++ b/tools/splat_ext/pm_effect_shims.py
@@ -1,7 +1,7 @@
 from yaml.loader import Loader
 from segtypes.n64.segment import N64Segment
 from util import options
-import yaml
+import yaml as yaml_loader
 
 class N64SegPm_effect_shims(N64Segment):
     shims = []
@@ -27,11 +27,40 @@ glabel {name}
     def shim_path(self, shim):
         return options.get_build_path() / "asm" / "effect_shims" / f"{shim}.s"
 
-    def __init__(self, rom_start, rom_end, type, name, vram_start, extract, given_subalign, given_is_overlay, given_dir, args, yml):
-        super().__init__(rom_start, rom_end, type, name, vram_start, extract, given_subalign, given_is_overlay, given_dir, args, yml)
+    def __init__(
+        self,
+        rom_start,
+        rom_end,
+        type,
+        name,
+        vram_start,
+        extract,
+        given_subalign,
+        exclusive_ram_id,
+        given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
+        args,
+        yaml,
+    ):
+        super().__init__(
+            rom_start,
+            rom_end,
+            type,
+            name,
+            vram_start,
+            extract,
+            given_subalign,
+            exclusive_ram_id,
+            given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
+        )
 
         with open(options.get_asm_path() / ".." / "effect_shims.yaml") as f:
-            self.shims = yaml.load(f.read(), Loader=yaml.SafeLoader)
+            self.shims = yaml_loader.load(f.read(), Loader=yaml_loader.SafeLoader)
 
     def split(self, rom_bytes):
         for i, shim in enumerate(self.shims):
diff --git a/tools/splat_ext/pm_map_data.py b/tools/splat_ext/pm_map_data.py
index 62c6c23d95..11e50cec94 100644
--- a/tools/splat_ext/pm_map_data.py
+++ b/tools/splat_ext/pm_map_data.py
@@ -38,8 +38,37 @@ def add_file_ext(name: str) -> str:
         return name + ".bin"
 
 class N64SegPm_map_data(N64Segment):
-    def __init__(self, rom_start, rom_end, type, name, vram_start, extract, given_subalign, given_is_overlay, given_dir, args, yaml):
-        super().__init__(rom_start, rom_end, type, name, vram_start, extract, given_subalign, given_is_overlay, given_dir, args, yaml)
+    def __init__(
+        self,
+        rom_start,
+        rom_end,
+        type,
+        name,
+        vram_start,
+        extract,
+        given_subalign,
+        exclusive_ram_id,
+        given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
+        args,
+        yaml,
+    ):
+        super().__init__(
+            rom_start,
+            rom_end,
+            type,
+            name,
+            vram_start,
+            extract,
+            given_subalign,
+            exclusive_ram_id,
+            given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
+        )
 
         self.files = yaml["files"]
 
diff --git a/tools/splat_ext/pm_msg.py b/tools/splat_ext/pm_msg.py
index dc7a83541c..05486cccd8 100644
--- a/tools/splat_ext/pm_msg.py
+++ b/tools/splat_ext/pm_msg.py
@@ -5,7 +5,7 @@ from util import options
 import re
 
 import pylibyaml
-import yaml
+import yaml as yaml_loader
 
 CHARSET = {
     0x00: "[NOTE]",
@@ -367,13 +367,42 @@ CHARSET_CREDITS = {
 }
 
 class N64SegPm_msg(N64Segment):
-    def __init__(self, rom_start, rom_end, type, name, vram_start, extract, given_subalign, given_is_overlay, given_dir, args, yml):
-        super().__init__(rom_start, rom_end, type, name, vram_start, extract, given_subalign, given_is_overlay, given_dir, args, yml)
+    def __init__(
+        self,
+        rom_start,
+        rom_end,
+        type,
+        name,
+        vram_start,
+        extract,
+        given_subalign,
+        exclusive_ram_id,
+        given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
+        args,
+        yaml,
+    ):
+        super().__init__(
+            rom_start,
+            rom_end,
+            type,
+            name,
+            vram_start,
+            extract,
+            given_subalign,
+            exclusive_ram_id,
+            given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
+        )
 
-        self.files = yml.get("files", []) if isinstance(yml, dict) else []
+        self.files = yaml.get("files", []) if isinstance(yaml, dict) else []
 
         with (Path(__file__).parent / f"{self.name}.yaml").open("r") as f:
-            self.msg_names = yaml.load(f.read(), Loader=yaml.SafeLoader)
+            self.msg_names = yaml_loader.load(f.read(), Loader=yaml_loader.SafeLoader)
 
     def split(self, rom_bytes):
         data = rom_bytes[self.rom_start: self.rom_end]
diff --git a/tools/splat_ext/pm_npc_sprites.py b/tools/splat_ext/pm_npc_sprites.py
index 65623bba24..4fa242e33e 100644
--- a/tools/splat_ext/pm_npc_sprites.py
+++ b/tools/splat_ext/pm_npc_sprites.py
@@ -10,7 +10,7 @@ import xml.etree.ElementTree as ET
 import struct
 
 import pylibyaml
-import yaml
+import yaml as yaml_loader
 
 class Sprite:
     def __init__(self):
@@ -253,13 +253,42 @@ class Component:
 class N64SegPm_npc_sprites(N64Segment):
     DEFAULT_SPRITE_NAMES = [f"{i:02X}" for i in range(0xEA)]
 
-    def __init__(self, rom_start, rom_end, type, name, vram_start, extract, given_subalign, given_is_overlay, given_dir, args, yml):
-        super().__init__(rom_start, rom_end, type, name, vram_start, extract, given_subalign, given_is_overlay, given_dir, args, yml)
+    def __init__(
+        self,
+        rom_start,
+        rom_end,
+        type,
+        name,
+        vram_start,
+        extract,
+        given_subalign,
+        exclusive_ram_id,
+        given_dir,
+        symbol_name_format,
+        symbol_name_format_no_rom,
+        args,
+        yaml,
+    ):
+        super().__init__(
+            rom_start,
+            rom_end,
+            type,
+            name,
+            vram_start,
+            extract,
+            given_subalign,
+            exclusive_ram_id,
+            given_dir,
+            symbol_name_format=symbol_name_format,
+            symbol_name_format_no_rom=symbol_name_format_no_rom,
+            args=args,
+            yaml=yaml,
+        )
 
-        self.files = yml["files"]
+        self.files = yaml["files"]
 
         with (Path(__file__).parent / f"{self.name}.yaml").open("r") as f:
-            self.sprite_cfg = yaml.load(f.read(), Loader=yaml.SafeLoader)
+            self.sprite_cfg = yaml_loader.load(f.read(), Loader=yaml_loader.SafeLoader)
 
     def split(self, rom_bytes):
         out_dir = options.get_asset_path() / self.dir / self.name
diff --git a/tools/update_symbol_addrs.py b/tools/update_symbol_addrs.py
index c798382cc4..9c0b862cbd 100755
--- a/tools/update_symbol_addrs.py
+++ b/tools/update_symbol_addrs.py
@@ -129,6 +129,7 @@ def read_elf():
                 continue
 
             if "/" in name or \
+               "." in name or \
                name in ignores or \
                name.startswith("_") or \
                name.startswith("jtbl_") or \
diff --git a/ver/jp/splat.yaml b/ver/jp/splat.yaml
index 7f1d884925..5f2847a869 100644
--- a/ver/jp/splat.yaml
+++ b/ver/jp/splat.yaml
@@ -17,7 +17,9 @@ options:
   asset_path: assets/jp
   build_path: ver/jp/build
   cache_path: ver/jp/.splat_cache
+  create_undefined_funcs_auto: False
   undefined_funcs_auto_path: ver/jp/undefined_funcs_auto.txt
+  create_undefined_syms_auto: False
   undefined_syms_auto_path: ver/jp/undefined_syms_auto.txt
 asset_stack:
   - jp
diff --git a/ver/us/asm/data/E2CA0.data.s b/ver/us/asm/data/E2CA0.data.s
new file mode 100644
index 0000000000..08cfceaff6
--- /dev/null
+++ b/ver/us/asm/data/E2CA0.data.s
@@ -0,0 +1,27 @@
+.include "macro.inc"
+
+.section .data
+
+dlabel D_8014C5A0
+.word 0xFFF40000, 0x00000000, 0x23002300, 0x000000FF, 0x000B0000, 0x00000000, 0x20002300, 0x000000FF, 0x000B0017, 0x00000000, 0x20002000, 0x000000FF, 0xFFF40017, 0x00000000, 0x23002000, 0x000000FF
+
+dlabel D_8014C5E0
+.word 0xFFF00000, 0x00000000, 0x24002400, 0x000000FF, 0x000F0000, 0x00000000, 0x20002400, 0x000000FF, 0x000F001F, 0x00000000, 0x20002000, 0x000000FF, 0xFFF0001F, 0x00000000, 0x24002000, 0x000000FF
+
+dlabel D_8014C620
+.word 0xE7000000, 0x00000000, 0xD7000002, 0xFFFFFFFF, 0xFCFFFFFF, 0xFFFCF279, 0xE3000C00, 0x00080000, 0xE3000D01, 0x00000000, 0xE3000F00, 0x00000000, 0xE3001001, 0x00000000, 0xE3001201, 0x00002000, 0xE3001402, 0x00000C00, 0xE3001001, 0x00008000, 0xDF000000, 0x00000000
+
+dlabel D_8014C678
+.word 0xD9DDFBFF, 0x00000000, 0x01004008, D_8014C5A0, 0x06000204, 0x00000406, 0xE7000000, 0x00000000, 0xDF000000, 0x00000000
+
+dlabel D_8014C6A0
+.word 0xD9DDFBFF, 0x00000000, 0x01004008, D_8014C5E0, 0x06000204, 0x00000406, 0xE7000000, 0x00000000, 0xDF000000, 0x00000000
+
+dlabel D_8014C6C8
+.word 0xFFFFFF00, 0xFFFFFF00, 0x00000000, 0x00000000, 0x00000000, 0x00000000
+
+dlabel D_8014C6E0
+.short 0x0020, 0x0028
+
+dlabel D_8014C6E4
+.short 0x0008, 0x0004, 0x0000, 0x0000, 0x0000, 0x0000
diff --git a/ver/us/asm/nonmatchings/8560/func_8002D160.s b/ver/us/asm/nonmatchings/8560/func_8002D160.s
deleted file mode 100644
index 5c22cb54c7..0000000000
--- a/ver/us/asm/nonmatchings/8560/func_8002D160.s
+++ /dev/null
@@ -1,182 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel func_8002D160
-/* 8560 8002D160 27BDFFC0 */  addiu     $sp, $sp, -0x40
-/* 8564 8002D164 AFB60030 */  sw        $s6, 0x30($sp)
-/* 8568 8002D168 3C16759A */  lui       $s6, 0x759a
-/* 856C 8002D16C 26D6F6D8 */  addiu     $s6, $s6, -0x928
-/* 8570 8002D170 AFB5002C */  sw        $s5, 0x2c($sp)
-/* 8574 8002D174 3C15F79E */  lui       $s5, %hi(D_F79DDD0F)
-/* 8578 8002D178 26B5DD0F */  addiu     $s5, $s5, %lo(D_F79DDD0F)
-/* 857C 8002D17C AFB30024 */  sw        $s3, 0x24($sp)
-/* 8580 8002D180 3C130B11 */  lui       $s3, 0xb11
-/* 8584 8002D184 36732D28 */  ori       $s3, $s3, 0x2d28
-/* 8588 8002D188 AFB00018 */  sw        $s0, 0x18($sp)
-/* 858C 8002D18C 0000802D */  daddu     $s0, $zero, $zero
-/* 8590 8002D190 3C05B000 */  lui       $a1, 0xb000
-/* 8594 8002D194 34A50D10 */  ori       $a1, $a1, 0xd10
-/* 8598 8002D198 3C04800A */  lui       $a0, %hi(nuPiCartHandle)
-/* 859C 8002D19C 8C84A638 */  lw        $a0, %lo(nuPiCartHandle)($a0)
-/* 85A0 8002D1A0 27A60010 */  addiu     $a2, $sp, 0x10
-/* 85A4 8002D1A4 AFB20020 */  sw        $s2, 0x20($sp)
-/* 85A8 8002D1A8 0200902D */  daddu     $s2, $s0, $zero
-/* 85AC 8002D1AC AFB40028 */  sw        $s4, 0x28($sp)
-/* 85B0 8002D1B0 3C148006 */  lui       $s4, %hi(osEPiReadIo)
-/* 85B4 8002D1B4 26940DC0 */  addiu     $s4, $s4, %lo(osEPiReadIo)
-/* 85B8 8002D1B8 AFBF003C */  sw        $ra, 0x3c($sp)
-/* 85BC 8002D1BC AFBE0038 */  sw        $fp, 0x38($sp)
-/* 85C0 8002D1C0 AFB70034 */  sw        $s7, 0x34($sp)
-/* 85C4 8002D1C4 0280F809 */  jalr      $s4
-/* 85C8 8002D1C8 AFB1001C */   sw       $s1, 0x1c($sp)
-/* 85CC 8002D1CC 3C110031 */  lui       $s1, 0x31
-/* 85D0 8002D1D0 26316D90 */  addiu     $s1, $s1, 0x6d90
-/* 85D4 8002D1D4 8FA20010 */  lw        $v0, 0x10($sp)
-/* 85D8 8002D1D8 3C030031 */  lui       $v1, 0x31
-/* 85DC 8002D1DC 24636F30 */  addiu     $v1, $v1, 0x6f30
-/* 85E0 8002D1E0 02629823 */  subu      $s3, $s3, $v0
-/* 85E4 8002D1E4 0223102B */  sltu      $v0, $s1, $v1
-/* 85E8 8002D1E8 1040002B */  beqz      $v0, .L8002D298
-/* 85EC 8002D1EC 241E0003 */   addiu    $fp, $zero, 3
-/* 85F0 8002D1F0 0060B82D */  daddu     $s7, $v1, $zero
-.L8002D1F4:
-/* 85F4 8002D1F4 0220282D */  daddu     $a1, $s1, $zero
-/* 85F8 8002D1F8 3C04800A */  lui       $a0, %hi(nuPiCartHandle)
-/* 85FC 8002D1FC 8C84A638 */  lw        $a0, %lo(nuPiCartHandle)($a0)
-/* 8600 8002D200 0280F809 */  jalr      $s4
-/* 8604 8002D204 27A60010 */   addiu    $a2, $sp, 0x10
-/* 8608 8002D208 8FA30010 */  lw        $v1, 0x10($sp)
-/* 860C 8002D20C 2407000F */  addiu     $a3, $zero, 0xf
-/* 8610 8002D210 3065FFFF */  andi      $a1, $v1, 0xffff
-/* 8614 8002D214 00032402 */  srl       $a0, $v1, 0x10
-/* 8618 8002D218 00A41021 */  addu      $v0, $a1, $a0
-/* 861C 8002D21C 02028021 */  addu      $s0, $s0, $v0
-/* 8620 8002D220 00121682 */  srl       $v0, $s2, 0x1a
-/* 8624 8002D224 14470010 */  bne       $v0, $a3, .L8002D268
-/* 8628 8002D228 00031682 */   srl      $v0, $v1, 0x1a
-/* 862C 8002D22C 24070009 */  addiu     $a3, $zero, 9
-/* 8630 8002D230 50470004 */  beql      $v0, $a3, .L8002D244
-/* 8634 8002D234 00031542 */   srl      $v0, $v1, 0x15
-/* 8638 8002D238 24070023 */  addiu     $a3, $zero, 0x23
-/* 863C 8002D23C 1447000A */  bne       $v0, $a3, .L8002D268
-/* 8640 8002D240 00031542 */   srl      $v0, $v1, 0x15
-.L8002D244:
-/* 8644 8002D244 3043001F */  andi      $v1, $v0, 0x1f
-/* 8648 8002D248 00121402 */  srl       $v0, $s2, 0x10
-/* 864C 8002D24C 3042001F */  andi      $v0, $v0, 0x1f
-/* 8650 8002D250 14620005 */  bne       $v1, $v0, .L8002D268
-/* 8654 8002D254 3082001F */   andi     $v0, $a0, 0x1f
-/* 8658 8002D258 14620003 */  bne       $v1, $v0, .L8002D268
-/* 865C 8002D25C 3242FFFF */   andi     $v0, $s2, 0xffff
-/* 8660 8002D260 02058023 */  subu      $s0, $s0, $a1
-/* 8664 8002D264 02028023 */  subu      $s0, $s0, $v0
-.L8002D268:
-/* 8668 8002D268 8FA40010 */  lw        $a0, 0x10($sp)
-/* 866C 8002D26C 00041682 */  srl       $v0, $a0, 0x1a
-/* 8670 8002D270 145E0006 */  bne       $v0, $fp, .L8002D28C
-/* 8674 8002D274 26310004 */   addiu    $s1, $s1, 4
-/* 8678 8002D278 3083FFFF */  andi      $v1, $a0, 0xffff
-/* 867C 8002D27C 00041402 */  srl       $v0, $a0, 0x10
-/* 8680 8002D280 3042FC00 */  andi      $v0, $v0, 0xfc00
-/* 8684 8002D284 00621821 */  addu      $v1, $v1, $v0
-/* 8688 8002D288 02038023 */  subu      $s0, $s0, $v1
-.L8002D28C:
-/* 868C 8002D28C 0237102B */  sltu      $v0, $s1, $s7
-/* 8690 8002D290 1440FFD8 */  bnez      $v0, .L8002D1F4
-/* 8694 8002D294 0080902D */   daddu    $s2, $a0, $zero
-.L8002D298:
-/* 8698 8002D298 3C02FFD5 */  lui       $v0, 0xffd5
-/* 869C 8002D29C 3442B14A */  ori       $v0, $v0, 0xb14a
-/* 86A0 8002D2A0 02021021 */  addu      $v0, $s0, $v0
-/* 86A4 8002D2A4 02621023 */  subu      $v0, $s3, $v0
-/* 86A8 8002D2A8 02C2B021 */  addu      $s6, $s6, $v0
-/* 86AC 8002D2AC 3C1318F4 */  lui       $s3, 0x18f4
-/* 86B0 8002D2B0 367314AB */  ori       $s3, $s3, 0x14ab
-/* 86B4 8002D2B4 0000802D */  daddu     $s0, $zero, $zero
-/* 86B8 8002D2B8 3C05B000 */  lui       $a1, 0xb000
-/* 86BC 8002D2BC 34A50E38 */  ori       $a1, $a1, 0xe38
-/* 86C0 8002D2C0 27A60014 */  addiu     $a2, $sp, 0x14
-/* 86C4 8002D2C4 3C04800A */  lui       $a0, %hi(nuPiCartHandle)
-/* 86C8 8002D2C8 8C84A638 */  lw        $a0, %lo(nuPiCartHandle)($a0)
-/* 86CC 8002D2CC 3C148006 */  lui       $s4, %hi(osEPiReadIo)
-/* 86D0 8002D2D0 26940DC0 */  addiu     $s4, $s4, %lo(osEPiReadIo)
-/* 86D4 8002D2D4 0280F809 */  jalr      $s4
-/* 86D8 8002D2D8 0200902D */   daddu    $s2, $s0, $zero
-/* 86DC 8002D2DC 3C110031 */  lui       $s1, 0x31
-/* 86E0 8002D2E0 26316F30 */  addiu     $s1, $s1, 0x6f30
-/* 86E4 8002D2E4 8FA20014 */  lw        $v0, 0x14($sp)
-/* 86E8 8002D2E8 3C030031 */  lui       $v1, 0x31
-/* 86EC 8002D2EC 24637020 */  addiu     $v1, $v1, 0x7020
-/* 86F0 8002D2F0 02629823 */  subu      $s3, $s3, $v0
-/* 86F4 8002D2F4 0223102B */  sltu      $v0, $s1, $v1
-/* 86F8 8002D2F8 1040002B */  beqz      $v0, .L8002D3A8
-/* 86FC 8002D2FC 241E0003 */   addiu    $fp, $zero, 3
-/* 8700 8002D300 0060B82D */  daddu     $s7, $v1, $zero
-.L8002D304:
-/* 8704 8002D304 0220282D */  daddu     $a1, $s1, $zero
-/* 8708 8002D308 3C04800A */  lui       $a0, %hi(nuPiCartHandle)
-/* 870C 8002D30C 8C84A638 */  lw        $a0, %lo(nuPiCartHandle)($a0)
-/* 8710 8002D310 0280F809 */  jalr      $s4
-/* 8714 8002D314 27A60014 */   addiu    $a2, $sp, 0x14
-/* 8718 8002D318 8FA30014 */  lw        $v1, 0x14($sp)
-/* 871C 8002D31C 2407000F */  addiu     $a3, $zero, 0xf
-/* 8720 8002D320 3065FFFF */  andi      $a1, $v1, 0xffff
-/* 8724 8002D324 00032402 */  srl       $a0, $v1, 0x10
-/* 8728 8002D328 00A41021 */  addu      $v0, $a1, $a0
-/* 872C 8002D32C 02028021 */  addu      $s0, $s0, $v0
-/* 8730 8002D330 00121682 */  srl       $v0, $s2, 0x1a
-/* 8734 8002D334 14470010 */  bne       $v0, $a3, .L8002D378
-/* 8738 8002D338 00031682 */   srl      $v0, $v1, 0x1a
-/* 873C 8002D33C 24070009 */  addiu     $a3, $zero, 9
-/* 8740 8002D340 50470004 */  beql      $v0, $a3, .L8002D354
-/* 8744 8002D344 00031542 */   srl      $v0, $v1, 0x15
-/* 8748 8002D348 24070023 */  addiu     $a3, $zero, 0x23
-/* 874C 8002D34C 1447000A */  bne       $v0, $a3, .L8002D378
-/* 8750 8002D350 00031542 */   srl      $v0, $v1, 0x15
-.L8002D354:
-/* 8754 8002D354 3043001F */  andi      $v1, $v0, 0x1f
-/* 8758 8002D358 00121402 */  srl       $v0, $s2, 0x10
-/* 875C 8002D35C 3042001F */  andi      $v0, $v0, 0x1f
-/* 8760 8002D360 14620005 */  bne       $v1, $v0, .L8002D378
-/* 8764 8002D364 3082001F */   andi     $v0, $a0, 0x1f
-/* 8768 8002D368 14620003 */  bne       $v1, $v0, .L8002D378
-/* 876C 8002D36C 3242FFFF */   andi     $v0, $s2, 0xffff
-/* 8770 8002D370 02058023 */  subu      $s0, $s0, $a1
-/* 8774 8002D374 02028023 */  subu      $s0, $s0, $v0
-.L8002D378:
-/* 8778 8002D378 8FA40014 */  lw        $a0, 0x14($sp)
-/* 877C 8002D37C 00041682 */  srl       $v0, $a0, 0x1a
-/* 8780 8002D380 145E0006 */  bne       $v0, $fp, .L8002D39C
-/* 8784 8002D384 26310004 */   addiu    $s1, $s1, 4
-/* 8788 8002D388 3083FFFF */  andi      $v1, $a0, 0xffff
-/* 878C 8002D38C 00041402 */  srl       $v0, $a0, 0x10
-/* 8790 8002D390 3042FC00 */  andi      $v0, $v0, 0xfc00
-/* 8794 8002D394 00621821 */  addu      $v1, $v1, $v0
-/* 8798 8002D398 02038023 */  subu      $s0, $s0, $v1
-.L8002D39C:
-/* 879C 8002D39C 0237102B */  sltu      $v0, $s1, $s7
-/* 87A0 8002D3A0 1440FFD8 */  bnez      $v0, .L8002D304
-/* 87A4 8002D3A4 0080902D */   daddu    $s2, $a0, $zero
-.L8002D3A8:
-/* 87A8 8002D3A8 3C04FFF1 */  lui       $a0, 0xfff1
-/* 87AC 8002D3AC 34842BE4 */  ori       $a0, $a0, 0x2be4
-/* 87B0 8002D3B0 02042021 */  addu      $a0, $s0, $a0
-/* 87B4 8002D3B4 02642023 */  subu      $a0, $s3, $a0
-/* 87B8 8002D3B8 02A42021 */  addu      $a0, $s5, $a0
-/* 87BC 8002D3BC 3C050031 */  lui       $a1, 0x31
-/* 87C0 8002D3C0 24A57020 */  addiu     $a1, $a1, 0x7020
-/* 87C4 8002D3C4 0C00A5CF */  jal       dma_copy
-/* 87C8 8002D3C8 02C0302D */   daddu    $a2, $s6, $zero
-/* 87CC 8002D3CC 8FBF003C */  lw        $ra, 0x3c($sp)
-/* 87D0 8002D3D0 8FBE0038 */  lw        $fp, 0x38($sp)
-/* 87D4 8002D3D4 8FB70034 */  lw        $s7, 0x34($sp)
-/* 87D8 8002D3D8 8FB60030 */  lw        $s6, 0x30($sp)
-/* 87DC 8002D3DC 8FB5002C */  lw        $s5, 0x2c($sp)
-/* 87E0 8002D3E0 8FB40028 */  lw        $s4, 0x28($sp)
-/* 87E4 8002D3E4 8FB30024 */  lw        $s3, 0x24($sp)
-/* 87E8 8002D3E8 8FB20020 */  lw        $s2, 0x20($sp)
-/* 87EC 8002D3EC 8FB1001C */  lw        $s1, 0x1c($sp)
-/* 87F0 8002D3F0 8FB00018 */  lw        $s0, 0x18($sp)
-/* 87F4 8002D3F4 03E00008 */  jr        $ra
-/* 87F8 8002D3F8 27BD0040 */   addiu    $sp, $sp, 0x40
-/* 87FC 8002D3FC 00000000 */  nop
diff --git a/ver/us/splat.yaml b/ver/us/splat.yaml
index 6f0b3579d9..b7a5a3e320 100644
--- a/ver/us/splat.yaml
+++ b/ver/us/splat.yaml
@@ -7,7 +7,8 @@ options:
   mnemonic_ljust: 10
   platform: n64
   subalign: 8
-  auto_all_sections: True
+  auto_all_sections: [".data", ".rodata", ".bss"]
+  asm_data_macro: "dlabel"
 
   base_path: ../..
   target_path: ver/us/baserom.z64
@@ -37,7 +38,8 @@ segments:
     subsegments:
     - [0x0040, asm, boot]
     - [0x0B70, bin, rspboot_font]
-  - type: code
+  - name: main
+    type: code
     start: 0x1000
     vram: 0x80025C00
     subsegments:
@@ -286,7 +288,6 @@ segments:
       type: .data
       name: curtains
       subsegments:
-      - [0x4F9E0, .data, curtains]
       - [0x4F9E0, i4, sprite/unk_checkers, 16, 32]
       - [0x4FAE0]
       - [0x4FB30, rgba32, sprite/curtains, 32, 32]
@@ -758,7 +759,7 @@ segments:
       type: .data
       name: 8e790_len_2850
       subsegments:
-      - [0xA2D90, .data, 8e790_len_2850]
+      - [0xA2D90]
       - [0xA2E90, ia8, ui/box/corners9, 16, 64]
       - [0xA3290, ia8, ui/box/corners8, 24, 96]
       - [0xA3B90, ia8, ui/box/corners6, 16, 40]
@@ -805,7 +806,7 @@ segments:
       type: .data
       name: cd180_len_38f0
       subsegments:
-      - [0xE2DF0, .data, cd180_len_38f0]
+      - [0xE2DF0]
       - [0xE2E00, i4, ui/stencil/star, 32, 64]
       - [0xE3200, i4, ui/stencil/mario, 64, 64]
       - [0xE3A00, i4, ui/stencil/sharp_circle, 32, 32]
@@ -1111,7 +1112,8 @@ segments:
       - [0x161E70, .data,      pause_gfx]
     - [0x162D30, .data,      pause_styles]
     - [0x1632A0]
-  - type: code
+  - name: filemenu
+    type: code
     start: 0x163400
     vram: 0x80242BA0
     subsegments:
@@ -2494,7 +2496,42 @@ segments:
     - [0x325AD0, c]
     - [0x325EE0, pm_effect_shims, effect_shims]
     - [0x326160, .data, 325AD0]
-  - [0x326410, bin] # big_smoke_puff gfx
+  - name: effect_gfx_big_smoke_puff
+    dir: effects/gfx
+    type: code
+    start: 0x326410
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x326410, c, big_smoke_puff]
+    - start: 0x326410
+      type: .data
+      name: big_smoke_puff
+      subsegments:
+      - [0x326410, ci4,     D_09000000_326410, 32, 32]
+      - [0x326610, palette, D_09000000_326410]
+      - [0x326630, ci4,     D_09000220_326630, 32, 32]
+      - [0x326830, palette, D_09000220_326630]
+      - [0x326850, ci4,     D_09000440_326850, 32, 32]
+      - [0x326A50, palette, D_09000440_326850]
+      - [0x326A70, ci4,     D_09000660_326A70, 32, 32]
+      - [0x326C70, palette, D_09000660_326A70]
+      - [0x326C90, ci4,     D_09000880_326C90, 32, 32]
+      - [0x326E90, palette, D_09000880_326C90]
+      - [0x326EB0, ci4,     D_09000AA0_326EB0, 32, 32]
+      - [0x3270B0, palette, D_09000AA0_326EB0]
+      - [0x3270D0, ci4,     D_09000CC0_3270D0, 32, 32]
+      - [0x3272D0, palette, D_09000CC0_3270D0]
+      - [0x3272F0, vtx, D_09000EE0_3272F0]
+      - [0x327330, gfx, D_09000F20_327330]
+      - [0x327398, gfx, D_09000F88_327398]
+      - [0x3273B0, gfx, D_09000FA0_3273B0]
+      - [0x327470, gfx, D_09001060_327470]
+      - [0x327530, gfx, D_09001120_327530]
+      - [0x3275F0, gfx, D_090011E0_3275F0]
+      - [0x3276B0, gfx, D_090012A0_3276B0]
+      - [0x327770, gfx, D_09001360_327770]
+      - [0x327830, gfx, D_09001420_327830]
   - name: effect_big_smoke_puff
     dir: effects
     type: code
@@ -2528,7 +2565,37 @@ segments:
     subsegments:
     - [0x32C7A0, c, flower_splash]
     - [0x32CEB0]
-  - [0x32CEC0, bin] # flower_splash, flower_trail gfx
+  - name: effect_gfx_flower_splash_trail
+    dir: effects/gfx
+    type: code
+    start: 0x32CEC0
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x32CEC0, c, flower_splash_trail]
+    - start: 0x32CEC0
+      type: .data
+      name: flower_splash_trail
+      subsegments:
+      - [0x32CEC0, ci4, D_09000000_32CEC0, 16, 16]
+      - [0x32CF40, palette, D_09000000_32CEC0]
+      - [0x32CF60, palette, D_09000000_32CEC0.yellow]
+      - [0x32CF80, rgba16, D_090000C0_32CF80, 32, 32]
+      - [0x32D780, vtx, D_090008C0_32D780]
+      - [0x32D8F0, vtx, D_09000A30_32D8F0]
+      - [0x32D900, vtx, D_09000A40_32D900]
+      - [0x32D910, vtx, D_09000A50_32D910]
+      - [0x32D950, vtx, D_09000A90_32D950]
+      - [0x32D970, vtx, D_09000AB0_32D970]
+      - [0x32D9B0, vtx, D_09000AF0_32D9B0]
+      - [0x32DA10, gfx, D_09000B50_32DA10]
+      - [0x32DAD0, gfx, D_09000C10_32DAD0]
+      - [0x32DB90, gfx, D_09000CD0_32DB90]
+      - [0x32DC18, gfx, D_09000D58_32DC18]
+      - [0x32DC50, gfx, D_09000D90_32DC50]
+      - [0x32DCC8, gfx, D_09000E08_32DCC8]
+      - [0x32DCE0, gfx, D_09000E20_32DCE0]
+      - [0x32DCF8, gfx, D_09000E38_32DCF8]
   - name: effect_flower_trail
     dir: effects
     type: code
@@ -2544,7 +2611,24 @@ segments:
     subsegments:
     - [0x32E490, c, cloud_puff]
     - [0x32EC10]
-  - [0x32EC50, bin] # cloud_puff, cloud_trail gfx
+  - name: effect_gfx_cloud_puff_trail
+    dir: effects/gfx
+    type: code
+    start: 0x32EC50
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x32EC50, c, cloud_puff_trail]
+    - start: 0x32EC50
+      type: .data
+      name: cloud_puff_trail
+      subsegments:
+      - [0x32EC50, ci4, D_09000000_32EC50, 16, 16]
+      - [0x32ECD0, palette, D_09000000_32EC50]
+      - [0x32ECF0, vtx, D_090000A0_32ECF0]
+      - [0x32ED30, gfx, D_090000E0_32ED30]
+      - [0x32EE08, gfx, D_090001B8_32EE08]
+      - [0x32EE28]
   - name: effect_cloud_trail
     dir: effects
     type: code
@@ -2560,7 +2644,22 @@ segments:
     vram: 0xE0018000
     subsegments:
     - [0x32F580, c, footprint]
-  - [0x32FB50, bin] # footprint gfx
+  - name: effect_gfx_footprint
+    dir: effects/gfx
+    type: code
+    start: 0x32FB50
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x32FB50, c, footprint]
+    - start: 0x32FB50
+      type: .data
+      name: footprint
+      subsegments:
+      - [0x32FB50, i4, D_09000000_32FB50, 32, 32]
+      - [0x32FD50, vtx, D_09000200_32FD50]
+      - [0x32FD90, gfx, D_09000240_32FD90]
+      - [0x32FE28]
   - name: effect_floating_flower
     dir: effects
     type: code
@@ -2569,7 +2668,26 @@ segments:
     subsegments:
     - [0x32FE30, c, floating_flower]
     - [0x330440]
-  - [0x330460, bin] # floating_flower gfx
+  - name: effect_gfx_floating_flower
+    dir: effects/gfx
+    type: code
+    start: 0x330460
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x330460, c, floating_flower]
+    - start: 0x330460
+      type: .data
+      name: floating_flower
+      subsegments:
+      - [0x330460, ci4, D_09000000_330460, 16, 16]
+      - [0x3304E0, palette, D_09000000_330460]
+      - [0x330500, vtx, D_090000A0_330500]
+      - [0x3305D0, vtx, D_09000170_3305D0]
+      - [0x330690, vtx, D_09000230_330690]
+      - [0x330750, gfx, D_090002F0_330750]
+      - [0x3308B0, gfx, D_09000450_3308B0]
+      - [0x330908]
   - name: effect_snowflake
     dir: effects
     type: code
@@ -2578,7 +2696,26 @@ segments:
     subsegments:
     - [0x330910, c, snowflake]
     - [0x330EF0]
-  - [0x330F00, bin] # snowflake gfx
+  - name: effect_gfx_snowflake
+    dir: effects/gfx
+    type: code
+    start: 0x330F00
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x330F00, c, snowflake]
+    - start: 0x330F00
+      type: .data
+      name: snowflake
+      subsegments:
+      - [0x330F00, i4, D_09000000_330F00, 16, 16]
+      - [0x330F80, i4, D_09000080_330F80, 64, 64]
+      - [0x331780, vtx, D_09000880_331780]
+      - [0x3317C0, vtx, D_090008C0_3317C0]
+      - [0x331800, gfx, D_09000900_331800]
+      - [0x3318E8, gfx, D_090009E8_3318E8]
+      - [0x331910, gfx, D_09000A10_331910]
+      - [0x331938]
   - name: effect_star
     dir: effects
     type: code
@@ -2721,7 +2858,62 @@ segments:
     - [0x34F4C0, c, damage_indicator]
     - [0x350160, .data, damage_indicator]
     - [0x350200, .rodata, damage_indicator]
-  - [0x350220, bin] # damage_indicator gfx
+  - name: effect_gfx_damage_indicator
+    dir: effects/gfx
+    type: code
+    start: 0x350220
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x350220, c, damage_indicator]
+    - start: 0x350220
+      type: .data
+      name: damage_indicator
+      subsegments:
+      - [0x350220, i4, D_09000000_350220, 32, 32]
+      - [0x350420, i4, D_09000200_350420, 32, 32]
+      - [0x350620, i4, D_09000400_350620, 32, 32]
+      - [0x350820, i4, D_09000600_350820, 32, 32]
+      - [0x350A20, i4, D_09000800_350A20, 32, 32]
+      - [0x350C20, i4, D_09000A00_350C20, 32, 32]
+      - [0x350E20, i4, D_09000C00_350E20, 32, 32]
+      - [0x351020, i4, D_09000E00_351020, 32, 32]
+      - [0x351220, i4, D_09001000_351220, 32, 32]
+      - [0x351420, i4, D_09001200_351420, 32, 32]
+      - [0x351620, i4, D_09001400_351620, 32, 32]
+      - [0x351820, i4, D_09001600_351820, 32, 32]
+      - [0x351A20, i4, D_09001800_351A20, 32, 32]
+      - [0x351C20, i4, D_09001A00_351C20, 32, 32]
+      - [0x351E20, vtx, D_09001C00_351E20]
+      - [0x351E30, vtx, D_09001C10_351E30]
+      - [0x351E50, vtx, D_09001C30_351E50]
+      - [0x351E60, vtx, D_09001C40_351E60]
+      - [0x351EA0, vtx, D_09001C80_351EA0]
+      - [0x351EE0, vtx, D_09001CC0_351EE0]
+      - [0x351F20, vtx, D_09001D00_351F20]
+      - [0x351F60, gfx, D_09001D40_351F60]
+      - [0x352000, gfx, D_09001DE0_352000]
+      - [0x352070, gfx, D_09001E50_352070]
+      - [0x3520B0, gfx, D_09001E90_3520B0]
+      - [0x3520F0, gfx, D_09001ED0_3520F0]
+      - [0x352130, gfx, D_09001F10_352130]
+      - [0x352170, gfx, D_09001F50_352170]
+      - [0x3521B0, gfx, D_09001F90_3521B0]
+      - [0x3521F0, gfx, D_09001FD0_3521F0]
+      - [0x352230, gfx, D_09002010_352230]
+      - [0x352270, gfx, D_09002050_352270]
+      - [0x3522B0, gfx, D_09002090_3522B0]
+      - [0x3522F0, gfx, D_090020D0_3522F0]
+      - [0x352330, gfx, D_09002110_352330]
+      - [0x352370, gfx, D_09002150_352370]
+      - [0x352380, gfx, D_09002160_352380]
+      - [0x352390, gfx, D_09002170_352390]
+      - [0x3523A0, gfx, D_09002180_3523A0]
+      - [0x3523B0, gfx, D_09002190_3523B0]
+      - [0x3523C8, gfx, D_090021A8_3523C8]
+      - [0x3523E0, gfx, D_090021C0_3523E0]
+      - [0x352400, gfx, D_090021E0_352400]
+      - [0x352420, gfx, D_09002200_352420]
   - name: effect_purple_ring
     dir: effects
     type: code
@@ -2870,7 +3062,26 @@ segments:
     subsegments:
     - [0x363160, c, big_snowflakes]
     - [0x363890]
-  - [0x3638C0, bin] # big_snowflakes gfx
+  - name: effect_gfx_big_snowflakes
+    dir: effects/gfx
+    type: code
+    start: 0x3638C0
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x3638C0, c, big_snowflakes]
+    - start: 0x3638C0
+      type: .data
+      name: big_snowflakes
+      subsegments:
+      - [0x3638C0, i4, D_09000000_3638C0, 16, 16]
+      - [0x363940, i4, D_09000080_363940, 64, 64]
+      - [0x364140, vtx, D_09000880_364140]
+      - [0x364180, vtx, D_090008C0_364180]
+      - [0x3641C0, gfx, D_09000900_3641C0]
+      - [0x3642A8, gfx, D_090009E8_3642A8]
+      - [0x3642D0, gfx, D_09000A10_3642D0]
+      - [0x3642F8]
   - name: effect_debuff
     dir: effects
     type: code
@@ -2879,7 +3090,23 @@ segments:
     subsegments:
     - [0x364300, c, debuff]
     - [0x364BC0]
-  - [0x364C00, bin] # debuff gfx
+  - name: effect_gfx_debuff
+    dir: effects/gfx
+    type: code
+    start: 0x364C00
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x364C00, c, debuff]
+    - start: 0x364C00
+      type: .data
+      name: debuff
+      subsegments:
+      - [0x364C00, i4, D_09000000_364C00, 32, 32]
+      - [0x364E00, vtx, D_09000200_364E00]
+      - [0x364E40, gfx, D_09000240_364E40]
+      - [0x364EE8, gfx, D_090002E8_364EE8]
+      - [0x364F08]
   - name: effect_green_impact
     dir: effects
     type: code
@@ -3021,7 +3248,54 @@ segments:
     subsegments:
     - [0x385640, c, disable_x]
     - [0x386340]
-  - [0x3863B0, bin] # disable_x gfx
+  - name: effect_gfx_disable_x
+    dir: effects/gfx
+    type: code
+    start: 0x3863B0
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x3863B0, c, disable_x]
+    - start: 0x3863B0
+      type: .data
+      name: disable_x
+      subsegments:
+      - [0x3863B0, i4, D_09000000_3863B0, 32, 32]
+      - [0x3865B0, i4, D_09000200_3865B0, 32, 32]
+      - [0x3867B0, i4, D_09000400_3867B0, 32, 32]
+      - [0x3869B0, i4, D_09000600_3869B0, 32, 32]
+      - [0x386BB0, i4, D_09000800_386BB0, 32, 32]
+      - [0x386DB0, i4, D_09000A00_386DB0, 32, 32]
+      - [0x386FB0, i4, D_09000C00_386FB0, 32, 32]
+      - [0x3871B0, i4, D_09000E00_3871B0, 32, 32]
+      - [0x3873B0, i4, D_09001000_3873B0, 32, 32]
+      - [0x3875B0, i4, D_09001200_3875B0, 32, 32]
+      - [0x3877B0, i4, D_09001400_3877B0, 32, 32]
+      - [0x3879B0, i4, D_09001600_3879B0, 32, 32]
+      - [0x387BB0, rgba16, D_09001800_387BB0, 32, 32]
+      - [0x3883B0, vtx, D_09002000_3883B0]
+      - [0x3883F0, vtx, D_09002040_3883F0]
+      - [0x388430, vtx, D_09002080_388430]
+      - [0x388470, vtx, D_090020C0_388470]
+      - [0x3884B0, gfx, D_09002100_3884B0]
+      - [0x388548, gfx, D_09002198_388548]
+      - [0x3885E0, gfx, D_09002230_3885E0]
+      - [0x388600, gfx, D_09002250_388600]
+      - [0x388620, gfx, D_09002270_388620]
+      - [0x388640, gfx, D_09002290_388640]
+      - [0x388660, gfx, D_090022B0_388660]
+      - [0x3886D0, gfx, D_09002320_3886D0]
+      - [0x388710, gfx, D_09002360_388710]
+      - [0x388750, gfx, D_090023A0_388750]
+      - [0x388790, gfx, D_090023E0_388790]
+      - [0x3887D0, gfx, D_09002420_3887D0]
+      - [0x388810, gfx, D_09002460_388810]
+      - [0x388850, gfx, D_090024A0_388850]
+      - [0x388890, gfx, D_090024E0_388890]
+      - [0x3888D0, gfx, D_09002520_3888D0]
+      - [0x388910, gfx, D_09002560_388910]
+      - [0x388950, gfx, D_090025A0_388950]
+      - [0x388990, gfx, D_090025E0_388990]
   - name: effect_bombette_breaking
     dir: effects
     type: code
@@ -3100,7 +3374,31 @@ segments:
     subsegments:
     - [0x391D30, c, small_gold_sparkle]
     - [0x3923C0]
-  - [0x392440, bin] # small_gold_sparkle gfx
+  - name: effect_gfx_small_gold_sparkle
+    dir: effects/gfx
+    type: code
+    start: 0x392440
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x392440, c, small_gold_sparkle]
+    - start: 0x392440
+      type: .data
+      name: small_gold_sparkle
+      subsegments:
+      - [0x392440, i4, D_09000000_392440, 16, 16]
+      - [0x3924C0, i4, D_09000080_3924C0, 16, 16]
+      - [0x392540, i4, D_09000100_392540, 16, 16]
+      - [0x3925C0, i4, D_09000180_3925C0, 16, 16]
+      - [0x392640, i4, D_09000200_392640, 16, 16]
+      - [0x3926C0, vtx, D_09000280_3926C0]
+      - [0x392700, gfx, D_090002C0_392700]
+      - [0x392770, gfx, D_09000330_392770]
+      - [0x3927B0, gfx, D_09000370_3927B0]
+      - [0x3927F0, gfx, D_090003B0_3927F0]
+      - [0x392830, gfx, D_090003F0_392830]
+      - [0x392870, gfx, D_09000430_392870]
+      - [0x3928B0, gfx, D_09000470_3928B0]
   - name: effect_flashing_box_shockwave
     dir: effects
     type: code
@@ -3205,7 +3503,55 @@ segments:
     subsegments:
     - [0x3AA920, c, butterflies]
     - [0x3AAFE0]
-  - [0x3AB030, bin] # butterflies gfx
+  - name: effect_gfx_butterflies
+    dir: effects/gfx
+    type: code
+    start: 0x3AB030
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x3AB030, c, butterflies]
+    - start: 0x3AB030
+      type: .data
+      name: butterflies
+      subsegments:
+      - [0x3AB030, ci4, D_09000000_3AB030, 32, 64]
+      - [0x3AB430, palette, D_09000000_3AB030]
+      - [0x3AB450, ci4, D_09000420_3AB450, 32, 64]
+      - [0x3AB850, palette, D_09000420_3AB450]
+      - [0x3AB870, ci4, D_09000840_3AB870, 32, 64]
+      - [0x3ABC70, palette, D_09000840_3AB870]
+      - [0x3ABC80, ci4, D_09000C50_3ABC80, 32, 64]
+      - [0x3AC080, palette, D_09000C50_3ABC80]
+      - [0x3AC0A0, ci4, D_09001070_3AC0A0, 32, 64]
+      - [0x3AC4A0, palette, D_09001070_3AC0A0]
+      - [0x3AC4B0, ci4, D_09001480_3AC4B0, 32, 64]
+      - [0x3AC8B0, palette, D_09001480_3AC4B0]
+      - [0x3AC8D0, ci4, D_090018A0_3AC8D0, 32, 64]
+      - [0x3ACCD0, palette, D_090018A0_3AC8D0]
+      - [0x3ACCF0, ci4, D_09001CC0_3ACCF0, 32, 64]
+      - [0x3AD0F0, palette, D_09001CC0_3ACCF0]
+      - [0x3AD110, ci4, D_090020E0_3AD110, 32, 64]
+      - [0x3AD510, palette, D_090020E0_3AD110]
+      - [0x3AD530, ci4, D_09002500_3AD530, 32, 64]
+      - [0x3AD930, palette, D_09002500_3AD530]
+      - [0x3AD950, ci4, D_09002920_3AD950, 32, 64]
+      - [0x3ADD50, palette, D_09002920_3AD950]
+      - [0x3ADD70, vtx, D_09002D40_3ADD70]
+      - [0x3AE8B0, gfx, D_09003880_3AE8B0]
+      - [0x3AE928, gfx, D_090038F8_3AE928]
+      - [0x3AE998, gfx, D_09003968_3AE998]
+      - [0x3AEA08, gfx, D_090039D8_3AEA08]
+      - [0x3AEA78, gfx, D_09003A48_3AEA78]
+      - [0x3AEAE8, gfx, D_09003AB8_3AEAE8]
+      - [0x3AEB58, gfx, D_09003B28_3AEB58]
+      - [0x3AEBC8, gfx, D_09003B98_3AEBC8]
+      - [0x3AEC38, gfx, D_09003C08_3AEC38]
+      - [0x3AECA8, gfx, D_09003C78_3AECA8]
+      - [0x3AED18, gfx, D_09003CE8_3AED18]
+      - [0x3AED88, gfx, D_09003D58_3AED88]
+      - [0x3AEDF8, gfx, D_09003DC8_3AEDF8]
+      - [0x3AEE18]
   - name: effect_stat_change
     dir: effects
     type: code
@@ -3339,7 +3685,28 @@ segments:
     subsegments:
     - [0x3CF3A0, c, throw_spiny]
     - [0x3CFAB0]
-  - [0x3CFAF0, bin] # throw_spiny gfx
+  - name: effect_gfx_throw_spiny
+    dir: effects/gfx
+    type: code
+    start: 0x3CFAF0
+    vram: 0x09000000
+    symbol_name_format: $VRAM_$ROM
+    subsegments:
+    - [0x3CFAF0, c, throw_spiny]
+    - start: 0x3CFAF0
+      type: .data
+      name: throw_spiny
+      subsegments:
+      - [0x3CFAF0, ci4, D_09000000_3CFAF0, 32, 32]
+      - [0x3CFCF0, palette, D_09000000_3CFAF0]
+      - [0x3CFD10] # padding
+      - [0x3CFEF0, ci4, D_09000400_3CFEF0, 32, 32]
+      - [0x3D00F0, palette, D_09000400_3CFEF0]
+      - [0x3D0110] # padding
+      - [0x3D02F0, gfx, D_09000800_3D02F0]
+      - [0x3D03C8, gfx, D_090008D8_3D03C8]
+      - [0x3D04A0, vtx, D_090009B0_3D04A0]
+      - [0x3D04E0, gfx, D_090009F0_3D04E0]
   - name: effect_effect_65
     dir: effects
     type: code
@@ -3808,7 +4175,6 @@ segments:
       type: .data
       name: whirlwind
       subsegments:
-      - [0x424550, .data, whirlwind]
       - [0x424550, ci4, whirlwind_1, 24, 24]
       - [0x424670, palette, whirlwind_1]
       - [0x424690, ci4, whirlwind_2, 24, 24]
@@ -3929,7 +4295,6 @@ segments:
       type: .data
       name: water_block
       subsegments:
-      - [0x42B650, .data, water_block]
       - [0x42B650, ci4, water_block_1, 24, 24]
       - [0x42B770, palette, water_block_1]
       - [0x42B790, ci4, water_block_2, 24, 24]
@@ -4588,7 +4953,7 @@ segments:
       type: .data
       name: actor/monstar
       subsegments:
-      - [0x63F040, .data, actor/monstar]
+      - [0x63F040]
       - [0x63F278, ci4, actor/img, 32, 32]
       - [0x63F478, palette, actor/img]
       - [0x63F498]
@@ -4813,7 +5178,7 @@ segments:
     vram: 0x802A1000
     overlay: True
     subsegments:
-    - [0x715850, c, mushroom] # TODO fix auto_all for .data
+    - [0x715850, c, mushroom]
     - [0x715E50]
   - name: fire_flower
     dir: battle/item
@@ -4920,7 +5285,7 @@ segments:
       type: .data
       name: sleepy_sheep
       subsegments:
-      - [0x71EFC0, .data, sleepy_sheep]
+      - [0x71EFC0]
       - [0x71F580, ci4, sleepy_sheep1, 56, 48]
       - [0x71FAC0, palette, sleepy_sheep1]
       - [0x71FAE0, ci4, sleepy_sheep2, 56, 48]
@@ -5030,7 +5395,7 @@ segments:
       type: .data
       name: egg_missile
       subsegments:
-      - [0x7291D0, .data, egg_missile]
+      - [0x7291D0]
       - [0x729790, ci4, egg_missile1, 32, 32]
       - [0x729990, palette, egg_missile1]
       - [0x7299B0, ci4, egg_missile2, 32, 32]
@@ -5077,7 +5442,7 @@ segments:
       type: .data
       name: mystery
       subsegments:
-      - [0x72CF00, .data, mystery]
+      - [0x72CF00]
       - [0x72D4C0, ci4, mystery, 32, 32]
       - [0x72D6C0, palette, mystery]
       - [0x72D6E0]
@@ -5111,7 +5476,7 @@ segments:
       type: .data
       name: coconut
       subsegments:
-      - [0x72F960, .data, coconut]
+      - [0x72F960]
       - [0x72FF20, ci4, coconut, 32, 32]
       - [0x730120, palette, coconut]
       - [0x730140]
@@ -5136,7 +5501,7 @@ segments:
       type: .data
       name: strange_cake
       subsegments:
-      - [0x731EA0, .data, strange_cake]
+      - [0x731EA0]
       - [0x732470, ci4, strange_cake1, 32, 32]
       - [0x732670, palette, strange_cake1]
       - [0x732690, ci4, strange_cake2, 32, 32]
@@ -7002,7 +7367,7 @@ segments:
       type: .data
       name: 9694C0
       subsegments:
-      - [0x96CC30,   .data, 9694C0]
+      - [0x96CC30]
       - [0x971F98,     vtx, vtx/971F98]
       - [0x9722B8,     vtx, vtx/9722B8]
       - [0x973578]
diff --git a/ver/us/symbol_addrs.txt b/ver/us/symbol_addrs.txt
index 484649d22b..359fcbe6d4 100644
--- a/ver/us/symbol_addrs.txt
+++ b/ver/us/symbol_addrs.txt
@@ -1206,7 +1206,7 @@ fx_shimmer_burst = 0x80070D90; // type:func rom:0x4C190
 fx_energy_shockwave = 0x80070DF0; // type:func rom:0x4C1F0
 fx_shimmer_wave = 0x80070E50; // type:func rom:0x4C250
 fx_aura = 0x80070EB0; // type:func rom:0x4C2B0
-bulb_glow = 0x80070F10; // type:func rom:0x4C310
+fx_bulb_glow = 0x80070F10; // type:func rom:0x4C310
 fx_3D = 0x80070F70; // type:func rom:0x4C370
 fx_blast = 0x80070FD0; // type:func rom:0x4C3D0
 fx_fire_flower = 0x80071030; // type:func rom:0x4C430
@@ -1383,6 +1383,7 @@ D_8007783C = 0x8007783C; // type:data rom:0x52C3C
 gameModeMap = 0x80077850; // type:data rom:0x52C50
 D_800778A0 = 0x800778A0; // type:data rom:0x52CA0
 D_800778AC = 0x800778AC; // type:data rom:0x52CAC
+D_800778C0 = 0x800778C0; // type:data rom:0x52CC0
 D_800778C8 = 0x800778C8; // type:data rom:0x52CC8
 D_80077908 = 0x80077908; // type:data rom:0x52D08
 D_80077950 = 0x80077950; // type:data rom:0x52D50
@@ -2401,6 +2402,10 @@ end_maps = 0x80093410; // type:data rom:0x6E810
 mgm_maps = 0x80093450; // type:data rom:0x6E850
 gv_maps = 0x800934D0; // type:data rom:0x6E8D0
 gAreas = 0x800934F0; // type:data rom:0x6E8F0 size:0x1D0
+D_800936C0 = 0x800936C0; // type:data rom:0x6EAC0
+D_800936DC = 0x800936DC; // type:data rom:0x6EADC
+D_800939A4 = 0x800939A4; // type:data rom:0x6EDA4
+D_800939B4 = 0x800939B4; // type:data rom:0x6EDB4
 FrameBuf = 0x80093BA8; // rom:0x6EFA8
 nuContPakCompanyCode = 0x80093CA0; // rom:0x6F0A0
 nuContPakGameCode = 0x80093CA4; // rom:0x6F0A4
@@ -2499,6 +2504,11 @@ D_80098710 = 0x80098710; // type:data rom:0x73B10
 D_80098718 = 0x80098718; // type:data rom:0x73B18
 D_80098720 = 0x80098720; // type:data rom:0x73B20
 D_800988C0 = 0x800988C0; // type:data rom:0x73CC0
+D_80098930 = 0x80098930; // type:data rom:0x73D30
+D_80098938 = 0x80098938; // type:data rom:0x73D38
+D_80098968 = 0x80098968; // type:data rom:0x73D68
+D_80098990 = 0x80098990; // type:data rom:0x73D90
+D_800989A0 = 0x800989A0; // type:data rom:0x73DA0
 D_80098A10 = 0x80098A10; // type:data rom:0x73E10
 D_80098A1C = 0x80098A1C; // type:data rom:0x73E1C
 D_80098A24 = 0x80098A24; // type:data rom:0x73E24
@@ -3171,387 +3181,586 @@ wSavedPartnerPosZ = 0x800F8344; // type:data rom:0x917F4
 gPartnerAnimations = 0x800F8348; // rom:0x917F8 size:0x1B0
 D_800B6590 = 0x800B6590; // type:data rom:0x91990
 D_800F84F8 = 0x800F84F8; // type:data rom:0x919A8
-ui_a_button_unpressed_png = 0x800F8500; // type:data rom:0x919B0
-ui_a_button_unpressed_pal = 0x800F88C0; // type:data rom:0x91D70
-ui_a_button_pressed_png = 0x800F88E0; // type:data rom:0x91D90
-ui_a_button_pressed_pal = 0x800F8CA0; // type:data rom:0x92150
-ui_analog_stick_png = 0x800F8CC0; // type:data rom:0x92170
-ui_analog_stick_pal = 0x800F8EC0; // type:data rom:0x92370
-ui_analog_stick_left_png = 0x800F8EE0; // type:data rom:0x92390
-ui_analog_stick_left_pal = 0x800F9160; // type:data rom:0x92610
-ui_analog_stick2_png = 0x800F9180; // type:data rom:0x92630
-ui_analog_stick2_pal = 0x800F9380; // type:data rom:0x92830
-ui_analog_stick_right_png = 0x800F93A0; // type:data rom:0x92850
-ui_analog_stick_right_pal = 0x800F9620; // type:data rom:0x92AD0
-ui_analog_stick3_png = 0x800F9640; // type:data rom:0x92AF0
-ui_analog_stick3_pal = 0x800F9840; // type:data rom:0x92CF0
-ui_analog_stick_down_png = 0x800F9860; // type:data rom:0x92D10
-ui_analog_stick_down_pal = 0x800F9A60; // type:data rom:0x92F10
-ui_analog_stick_up_png = 0x800F9A80; // type:data rom:0x92F30
-ui_analog_stick_up_pal = 0x800F9C80; // type:data rom:0x93130
-ui_unk_bar_png = 0x800F9CA0; // type:data rom:0x93150
-ui_unk_bar_pal = 0x800F9EE0; // type:data rom:0x93390
-ui_ok_png = 0x800F9F00; // type:data rom:0x933B0
-ui_ok_pal = 0x800F9FC0; // type:data rom:0x93470
-ui_start_button_png = 0x800F9FE0; // type:data rom:0x93490
-ui_start_button_pal = 0x800FA3A0; // type:data rom:0x93850
-ui_start_button2_png = 0x800FA3C0; // type:data rom:0x93870
+ui_input_a_button_unpressed_png = 0x800F8500; // rom:0x919B0
+ui_input_a_button_unpressed_pal = 0x800F88C0; // rom:0x91D70
+ui_input_a_button_pressed_png = 0x800F88E0; // rom:0x91D90
+ui_input_a_button_pressed_pal = 0x800F8CA0; // rom:0x92150
+ui_input_analog_stick_png = 0x800F8CC0; // rom:0x92170
+ui_input_analog_stick_pal = 0x800F8EC0; // rom:0x92370
+ui_input_analog_stick_left_png = 0x800F8EE0; // rom:0x92390
+ui_input_analog_stick_left_pal = 0x800F9160; // rom:0x92610
+ui_input_analog_stick2_png = 0x800F9180; // rom:0x92630
+ui_input_analog_stick2_pal = 0x800F9380; // rom:0x92830
+ui_input_analog_stick_right_png = 0x800F93A0; // rom:0x92850
+ui_input_analog_stick_right_pal = 0x800F9620; // rom:0x92AD0
+ui_input_analog_stick3_png = 0x800F9640; // rom:0x92AF0
+ui_input_analog_stick3_pal = 0x800F9840; // rom:0x92CF0
+ui_input_analog_stick_down_png = 0x800F9860; // rom:0x92D10
+ui_input_analog_stick_down_pal = 0x800F9A60; // rom:0x92F10
+ui_input_analog_stick_up_png = 0x800F9A80; // rom:0x92F30
+ui_input_analog_stick_up_pal = 0x800F9C80; // rom:0x93130
+ui_unk_bar_png = 0x800F9CA0; // rom:0x93150
+ui_unk_bar_pal = 0x800F9EE0; // rom:0x93390
+ui_ok_png = 0x800F9F00; // rom:0x933B0
+ui_ok_pal = 0x800F9FC0; // rom:0x93470
+ui_input_start_button_png = 0x800F9FE0; // rom:0x93490
+ui_input_start_button_pal = 0x800FA3A0; // rom:0x93850
+ui_input_start_button2_png = 0x800FA3C0; // rom:0x93870
 nuYieldBuf = 0x800B8590; // type:data rom:0x93990
-ui_start_button2_pal = 0x800FA780; // type:data rom:0x93C30
-ui_start_png = 0x800FA7A0; // type:data rom:0x93C50
-ui_start_pal = 0x800FA800; // type:data rom:0x93CB0
-ui_hammer_png = 0x800FA820; // type:data rom:0x93CD0
-ui_hammer_pal = 0x800FAA20; // type:data rom:0x93ED0
-ui_hammer_disabled_pal = 0x800FAA40; // type:data rom:0x93EF0
-ui_super_hammer_png = 0x800FAA60; // type:data rom:0x93F10
-ui_super_hammer_pal = 0x800FAC60; // type:data rom:0x94110
-ui_super_hammer_disabled_pal = 0x800FAC80; // type:data rom:0x94130
-ui_ultra_hammer_png = 0x800FACA0; // type:data rom:0x94150
-ui_ultra_hammer_pal = 0x800FAEA0; // type:data rom:0x94350
-ui_ultra_hammer_disabled_pal = 0x800FAEC0; // type:data rom:0x94370
-ui_boots_png = 0x800FAEE0; // type:data rom:0x94390
-ui_boots_pal = 0x800FB0E0; // type:data rom:0x94590
+ui_input_start_button2_pal = 0x800FA780; // rom:0x93C30
+ui_input_start_text_png = 0x800FA7A0; // rom:0x93C50
+ui_input_start_text_pal = 0x800FA800; // rom:0x93CB0
+ui_hammer_png = 0x800FA820; // rom:0x93CD0
+ui_hammer_pal = 0x800FAA20; // rom:0x93ED0
+ui_hammer_disabled_pal = 0x800FAA40; // rom:0x93EF0
+ui_super_hammer_png = 0x800FAA60; // rom:0x93F10
+ui_super_hammer_pal = 0x800FAC60; // rom:0x94110
+ui_super_hammer_disabled_pal = 0x800FAC80; // rom:0x94130
+ui_ultra_hammer_png = 0x800FACA0; // rom:0x94150
+ui_ultra_hammer_pal = 0x800FAEA0; // rom:0x94350
+ui_ultra_hammer_disabled_pal = 0x800FAEC0; // rom:0x94370
+ui_boots_png = 0x800FAEE0; // rom:0x94390
+ui_boots_pal = 0x800FB0E0; // rom:0x94590
 D_800B91A0 = 0x800B91A0; // type:data rom:0x945A0
-ui_boots_disabled_pal = 0x800FB100; // type:data rom:0x945B0
-D_800B91D0 = 0x800B91D0; // type:data rom:0x945D0
-ui_super_boots_pal = 0x800FB320; // type:data rom:0x947D0
-ui_super_boots_disabled_pal = 0x800FB340; // type:data rom:0x947F0
-ui_ultra_boots_png = 0x800FB360; // type:data rom:0x94810
-ui_ultra_boots_pal = 0x800FB560; // type:data rom:0x94A10
-ui_ultra_boots_disabled_pal = 0x800FB580; // type:data rom:0x94A30
-ui_item_png = 0x800FB5A0; // type:data rom:0x94A50
-ui_item_pal = 0x800FB7A0; // type:data rom:0x94C50
-ui_item_disabled_pal = 0x800FB7C0; // type:data rom:0x94C70
-ui_star_spirit_png = 0x800FB7E0; // type:data rom:0x94C90
-ui_star_spirit_pal = 0x800FB9E0; // type:data rom:0x94E90
-ui_star_spirit_disabled_pal = 0x800FBA00; // type:data rom:0x94EB0
-ui_arrow_left_png = 0x800FBA20; // type:data rom:0x94ED0
-ui_arrow_left_pal = 0x800FBAA0; // type:data rom:0x94F50
-ui_arrow_right_png = 0x800FBAC0; // type:data rom:0x94F70
-ui_arrow_right_pal = 0x800FBB40; // type:data rom:0x94FF0
-ui_point_right_png = 0x800FBB60; // type:data rom:0x95010
-ui_point_right_pal = 0x800FBBE0; // type:data rom:0x95090
-ui_pip_png = 0x800FBC00; // type:data rom:0x950B0
-ui_pip_pal = 0x800FBC20; // type:data rom:0x950D0
-ui_pip2_png = 0x800FBC40; // type:data rom:0x950F0
-ui_pip2_pal = 0x800FBC60; // type:data rom:0x95110
-ui_coin_sparkle_png = 0x800FBC80; // type:data rom:0x95130
-ui_coin_sparkle_pal = 0x800FBCA0; // type:data rom:0x95150
-ui_coin_sparkle2_png = 0x800FBCC0; // type:data rom:0x95170
-ui_coin_sparkle2_pal = 0x800FBCE0; // type:data rom:0x95190
-ui_coin_sparkle3_png = 0x800FBD00; // type:data rom:0x951B0
-ui_coin_sparkle3_pal = 0x800FBD20; // type:data rom:0x951D0
-ui_coin_sparkle4_png = 0x800FBD40; // type:data rom:0x951F0
-ui_coin_sparkle4_pal = 0x800FBD60; // type:data rom:0x95210
-ui_coin_sparkle5_png = 0x800FBD80; // type:data rom:0x95230
-ui_coin_sparkle5_pal = 0x800FBDA0; // type:data rom:0x95250
-ui_coin_sparkle6_png = 0x800FBDC0; // type:data rom:0x95270
-ui_coin_sparkle6_pal = 0x800FBDE0; // type:data rom:0x95290
-ui_coin_sparkle7_png = 0x800FBE00; // type:data rom:0x952B0
-ui_coin_sparkle7_pal = 0x800FBE20; // type:data rom:0x952D0
-ui_status_sp_shine_png = 0x800FBE40; // type:data rom:0x952F0
-ui_star_piece_sparkle_png = 0x800FC080; // type:data rom:0x95530
-ui_star_piece_sparkle_pal = 0x800FC100; // type:data rom:0x955B0
-ui_star_piece_sparkle2_png = 0x800FC120; // type:data rom:0x955D0
-ui_star_piece_sparkle2_pal = 0x800FC1A0; // type:data rom:0x95650
-ui_star_piece_sparkle3_png = 0x800FC1C0; // type:data rom:0x95670
-ui_star_piece_sparkle3_pal = 0x800FC240; // type:data rom:0x956F0
-ui_menu_times_png = 0x800FC260; // type:data rom:0x95710
-ui_menu_times_pal = 0x800FC280; // type:data rom:0x95730
-ui_fp_cost_png = 0x800FC2A0; // type:data rom:0x95750
-ui_fp_cost_pal = 0x800FC2E0; // type:data rom:0x95790
-ui_fp_cost_reduced_pal = 0x800FC300; // type:data rom:0x957B0
-ui_fp_cost_reduced2x_pal = 0x800FC320; // type:data rom:0x957D0
-ui_fp_cost_notenough_pal = 0x800FC330; // type:data rom:0x957E0
-ui_pow_cost_png = 0x800FC360; // type:data rom:0x95810
-ui_pow_cost_pal = 0x800FC3A0; // type:data rom:0x95850
-ui_pow_cost_reduced_pal = 0x800FC3C0; // type:data rom:0x95870
-ui_pow_cost_reduced2x_pal = 0x800FC3E0; // type:data rom:0x95890
-ui_pow_cost_notenough_pal = 0x800FC400; // type:data rom:0x958B0
-ui_green_arrow_down_png = 0x800FC420; // type:data rom:0x958D0
-ui_green_arrow_down_pal = 0x800FC460; // type:data rom:0x95910
-ui_green_arrow_up_png = 0x800FC480; // type:data rom:0x95930
-ui_green_arrow_up_pal = 0x800FC4C0; // type:data rom:0x95970
-ui_kaime_png = 0x800FC4E0; // type:data rom:0x95990
-ui_kaime_pal = 0x800FC780; // type:data rom:0x95C30
-ui_unused_1_png = 0x800FC7A0; // type:data rom:0x95C50
-ui_unused_1_pal = 0x800FC820; // type:data rom:0x95CD0
-ui_unused_2_png = 0x800FC840; // type:data rom:0x95CF0
-ui_unused_2_pal = 0x800FC8C0; // type:data rom:0x95D70
-ui_unused_3_png = 0x800FC8E0; // type:data rom:0x95D90
-ui_unused_3_pal = 0x800FC960; // type:data rom:0x95E10
-ui_red_bar1_png = 0x800FC980; // type:data rom:0x95E30
-ui_red_bar1_pal = 0x800FCB40; // type:data rom:0x95FF0
-ui_empty_bar_png = 0x800FCB60; // type:data rom:0x96010
-ui_empty_bar_pal = 0x800FCD20; // type:data rom:0x961D0
-ui_red_bar2_png = 0x800FCD40; // type:data rom:0x961F0
-ui_red_bar2_pal = 0x800FCEE0; // type:data rom:0x96390
-ui_eldstar_png = 0x800FCF00; // type:data rom:0x963B0
-ui_eldstar_pal = 0x800FD100; // type:data rom:0x965B0
-ui_eldstar_disabled_pal = 0x800FD120; // type:data rom:0x965D0
-ui_mamar_png = 0x800FD140; // type:data rom:0x965F0
-ui_mamar_pal = 0x800FD340; // type:data rom:0x967F0
-ui_mamar_disabled_pal = 0x800FD360; // type:data rom:0x96810
-ui_skolar_png = 0x800FD380; // type:data rom:0x96830
-ui_skolar_pal = 0x800FD580; // type:data rom:0x96A30
-ui_skolar_disabled_pal = 0x800FD5A0; // type:data rom:0x96A50
-ui_muskular_png = 0x800FD5C0; // type:data rom:0x96A70
-ui_muskular_pal = 0x800FD7C0; // type:data rom:0x96C70
-ui_muskular_disabled_pal = 0x800FD7E0; // type:data rom:0x96C90
-ui_misstar_png = 0x800FD800; // type:data rom:0x96CB0
-ui_misstar_pal = 0x800FDA00; // type:data rom:0x96EB0
-ui_misstar_disabled_pal = 0x800FDA20; // type:data rom:0x96ED0
-ui_klevar_png = 0x800FDA40; // type:data rom:0x96EF0
-ui_klevar_pal = 0x800FDC40; // type:data rom:0x970F0
-ui_klevar_disabled_pal = 0x800FDC60; // type:data rom:0x97110
-ui_kalmar_png = 0x800FDC80; // type:data rom:0x97130
-ui_kalmar_pal = 0x800FDE80; // type:data rom:0x97330
-ui_kalmar_disabled_pal = 0x800FDEA0; // type:data rom:0x97350
-ui_star_beam_png = 0x800FDEC0; // type:data rom:0x97370
-ui_star_beam_pal = 0x800FE0C0; // type:data rom:0x97570
-ui_star_beam_disabled_pal = 0x800FE0E0; // type:data rom:0x97590
-ui_peach_beam_png = 0x800FE100; // type:data rom:0x975B0
-ui_peach_beam_pal = 0x800FE300; // type:data rom:0x977B0
-ui_peach_beam_disabled_pal = 0x800FE320; // type:data rom:0x977D0
-ui_mario_head_png = 0x800FE340; // type:data rom:0x977F0
-ui_mario_head_pal = 0x800FE3C0; // type:data rom:0x97870
-ui_partner0_png = 0x800FE3E0; // type:data rom:0x97890
-ui_partner0_pal = 0x800FE5E0; // type:data rom:0x97A90
-ui_partner0_disabled_pal = 0x800FE600; // type:data rom:0x97AB0
-ui_goombario_png = 0x800FE620; // type:data rom:0x97AD0
-ui_goombario_pal = 0x800FE820; // type:data rom:0x97CD0
-ui_goombario_disabled_pal = 0x800FE840; // type:data rom:0x97CF0
-ui_kooper_png = 0x800FE860; // type:data rom:0x97D10
-ui_kooper_pal = 0x800FEA60; // type:data rom:0x97F10
-ui_kooper_disabled_pal = 0x800FEA80; // type:data rom:0x97F30
-ui_bombette_png = 0x800FEAA0; // type:data rom:0x97F50
-ui_bombette_pal = 0x800FECA0; // type:data rom:0x98150
-ui_bombette_disabled_pal = 0x800FECC0; // type:data rom:0x98170
-ui_parakarry_png = 0x800FECE0; // type:data rom:0x98190
-ui_parakarry_pal = 0x800FEEE0; // type:data rom:0x98390
-ui_parakarry_disabled_pal = 0x800FEF00; // type:data rom:0x983B0
-ui_bow_png = 0x800FEF20; // type:data rom:0x983D0
-ui_bow_pal = 0x800FF120; // type:data rom:0x985D0
-ui_bow_disabled_pal = 0x800FF140; // type:data rom:0x985F0
-ui_watt_png = 0x800FF160; // type:data rom:0x98610
-ui_watt_pal = 0x800FF360; // type:data rom:0x98810
-ui_watt_disabled_pal = 0x800FF380; // type:data rom:0x98830
-ui_sushie_png = 0x800FF3A0; // type:data rom:0x98850
-ui_sushie_pal = 0x800FF5A0; // type:data rom:0x98A50
-ui_sushie_disabled_pal = 0x800FF5C0; // type:data rom:0x98A70
-ui_lakilester_png = 0x800FF5E0; // type:data rom:0x98A90
-ui_lakilester_pal = 0x800FF7E0; // type:data rom:0x98C90
-ui_lakilester_disabled_pal = 0x800FF800; // type:data rom:0x98CB0
-ui_partner9_png = 0x800FF820; // type:data rom:0x98CD0
-ui_partner9_pal = 0x800FFA20; // type:data rom:0x98ED0
-ui_partner9_disabled_pal = 0x800FFA40; // type:data rom:0x98EF0
-ui_partner10_png = 0x800FFA60; // type:data rom:0x98F10
-ui_partner10_pal = 0x800FFC60; // type:data rom:0x99110
-ui_partner10_disabled_pal = 0x800FFC80; // type:data rom:0x99130
-ui_partner11_png = 0x800FFCA0; // type:data rom:0x99150
-ui_partner11_pal = 0x800FFEA0; // type:data rom:0x99350
-ui_partner11_disabled_pal = 0x800FFEC0; // type:data rom:0x99370
-ui_status_times_png = 0x800FFEE0; // type:data rom:0x99390
-ui_status_times_pal = 0x800FFF00; // type:data rom:0x993B0
-ui_status_slash_png = 0x800FFF20; // type:data rom:0x993D0
-ui_status_slash_pal = 0x800FFF60; // type:data rom:0x99410
-ui_0_png = 0x800FFF80; // type:data rom:0x99430
-ui_0_pal = 0x80100000; // type:data rom:0x994B0
-ui_1_png = 0x80100020; // type:data rom:0x994D0
-ui_1_pal = 0x801000A0; // type:data rom:0x99550
-ui_2_png = 0x801000C0; // type:data rom:0x99570
-ui_2_pal = 0x80100140; // type:data rom:0x995F0
-ui_3_png = 0x80100160; // type:data rom:0x99610
-ui_3_pal = 0x801001E0; // type:data rom:0x99690
-ui_4_png = 0x80100200; // type:data rom:0x996B0
-ui_4_pal = 0x80100280; // type:data rom:0x99730
-ui_5_png = 0x801002A0; // type:data rom:0x99750
-ui_5_pal = 0x80100320; // type:data rom:0x997D0
-ui_6_png = 0x80100340; // type:data rom:0x997F0
-ui_6_pal = 0x801003C0; // type:data rom:0x99870
-ui_7_png = 0x801003E0; // type:data rom:0x99890
-ui_7_pal = 0x80100460; // type:data rom:0x99910
-ui_8_png = 0x80100480; // type:data rom:0x99930
-ui_8_pal = 0x80100500; // type:data rom:0x999B0
-ui_9_png = 0x80100520; // type:data rom:0x999D0
-ui_9_pal = 0x801005A0; // type:data rom:0x99A50
-ui_hp_png = 0x801005C0; // type:data rom:0x99A70
-ui_hp_pal = 0x80100640; // type:data rom:0x99AF0
-ui_fp_png = 0x80100660; // type:data rom:0x99B10
-ui_fp_pal = 0x801006E0; // type:data rom:0x99B90
-ui_status_sp_increment_1_png = 0x80100700; // type:data rom:0x99BB0
-ui_status_sp_increment_1_pal = 0x80100720; // type:data rom:0x99BD0
-ui_status_sp_increment_2_png = 0x80100740; // type:data rom:0x99BF0
-ui_status_sp_increment_2_pal = 0x80100760; // type:data rom:0x99C10
-ui_status_sp_increment_3_png = 0x80100780; // type:data rom:0x99C30
-ui_status_sp_increment_3_pal = 0x801007A0; // type:data rom:0x99C50
-ui_status_sp_increment_4_png = 0x801007C0; // type:data rom:0x99C70
-ui_status_sp_increment_4_pal = 0x801007E0; // type:data rom:0x99C90
-ui_status_sp_increment_5_png = 0x80100800; // type:data rom:0x99CB0
-ui_status_sp_increment_5_pal = 0x80100820; // type:data rom:0x99CD0
-ui_status_sp_increment_6_png = 0x80100840; // type:data rom:0x99CF0
-ui_status_sp_increment_6_pal = 0x80100860; // type:data rom:0x99D10
-ui_status_sp_increment_7_png = 0x80100880; // type:data rom:0x99D30
-ui_status_sp_increment_7_pal = 0x801008A0; // type:data rom:0x99D50
-ui_status_sp_empty_increment_png = 0x801008C0; // type:data rom:0x99D70
-ui_status_sp_empty_increment_pal = 0x801008E0; // type:data rom:0x99D90
-ui_status_sp_star_1_png = 0x80100900; // type:data rom:0x99DB0
-ui_status_sp_star_1_pal = 0x80100920; // type:data rom:0x99DD0
-ui_status_sp_star_2_png = 0x80100940; // type:data rom:0x99DF0
-ui_status_sp_star_2_pal = 0x80100960; // type:data rom:0x99E10
-ui_status_sp_star_3_png = 0x80100980; // type:data rom:0x99E30
-ui_status_sp_star_3_pal = 0x801009A0; // type:data rom:0x99E50
-ui_status_sp_star_4_png = 0x801009C0; // type:data rom:0x99E70
-ui_status_sp_star_4_pal = 0x801009E0; // type:data rom:0x99E90
-ui_status_sp_star_5_png = 0x80100A00; // type:data rom:0x99EB0
-ui_status_sp_star_5_pal = 0x80100A20; // type:data rom:0x99ED0
-ui_status_sp_star_6_png = 0x80100A40; // type:data rom:0x99EF0
-ui_status_sp_star_6_pal = 0x80100A60; // type:data rom:0x99F10
-ui_status_sp_star_7_png = 0x80100A80; // type:data rom:0x99F30
-ui_status_sp_star_7_pal = 0x80100AA0; // type:data rom:0x99F50
-ui_status_sp_star_empty_png = 0x80100AC0; // type:data rom:0x99F70
-ui_status_sp_star_empty_pal = 0x80100AE0; // type:data rom:0x99F90
-ui_coins0_png = 0x80100B00; // type:data rom:0x99FB0
-ui_coins0_pal = 0x80100B80; // type:data rom:0x9A030
-ui_coins1_png = 0x80100BA0; // type:data rom:0x9A050
-ui_coins1_pal = 0x80100C20; // type:data rom:0x9A0D0
-ui_coins2_png = 0x80100C40; // type:data rom:0x9A0F0
-ui_coins2_pal = 0x80100CC0; // type:data rom:0x9A170
-ui_coins3_png = 0x80100CE0; // type:data rom:0x9A190
-ui_coins3_pal = 0x80100D60; // type:data rom:0x9A210
-ui_coins4_png = 0x80100D80; // type:data rom:0x9A230
-ui_coins4_pal = 0x80100E00; // type:data rom:0x9A2B0
-ui_coins5_png = 0x80100E20; // type:data rom:0x9A2D0
-ui_coins5_pal = 0x80100EA0; // type:data rom:0x9A350
-ui_coins6_png = 0x80100EC0; // type:data rom:0x9A370
-ui_coins6_pal = 0x80100F40; // type:data rom:0x9A3F0
-ui_coins7_png = 0x80100F60; // type:data rom:0x9A410
-ui_coins7_pal = 0x80100FE0; // type:data rom:0x9A490
-ui_coins8_png = 0x80101000; // type:data rom:0x9A4B0
-ui_coins8_pal = 0x80101080; // type:data rom:0x9A530
-ui_coins9_png = 0x801010A0; // type:data rom:0x9A550
-ui_coins9_pal = 0x80101120; // type:data rom:0x9A5D0
-ui_star_points0_png = 0x80101140; // type:data rom:0x9A5F0
-ui_star_points0_pal = 0x801011C0; // type:data rom:0x9A670
-ui_star_points1_png = 0x801011E0; // type:data rom:0x9A690
-ui_star_points1_pal = 0x80101260; // type:data rom:0x9A710
-ui_star_points2_png = 0x80101280; // type:data rom:0x9A730
-ui_star_points2_pal = 0x80101300; // type:data rom:0x9A7B0
-ui_star_points3_png = 0x80101320; // type:data rom:0x9A7D0
-ui_star_points3_pal = 0x801013A0; // type:data rom:0x9A850
-ui_star_points4_png = 0x801013C0; // type:data rom:0x9A870
-ui_star_points4_pal = 0x80101440; // type:data rom:0x9A8F0
-ui_star_points5_png = 0x80101460; // type:data rom:0x9A910
-ui_star_points5_pal = 0x801014E0; // type:data rom:0x9A990
-ui_star_points6_png = 0x80101500; // type:data rom:0x9A9B0
-ui_star_points6_pal = 0x80101580; // type:data rom:0x9AA30
-ui_star_points7_png = 0x801015A0; // type:data rom:0x9AA50
-ui_star_points7_pal = 0x80101620; // type:data rom:0x9AAD0
-ui_bluepip_png = 0x80101640; // type:data rom:0x9AAF0
-ui_bluepip_pal = 0x801016C0; // type:data rom:0x9AB70
-ui_bluepip2_png = 0x801016E0; // type:data rom:0x9AB90
-ui_bluepip2_pal = 0x80101760; // type:data rom:0x9AC10
-ui_charge_jump_png = 0x80101780; // type:data rom:0x9AC30
-ui_charge_jump_pal = 0x801018A0; // type:data rom:0x9AD50
-ui_charge_hammer_png = 0x801018C0; // type:data rom:0x9AD70
-ui_charge_hammer_pal = 0x801019E0; // type:data rom:0x9AE90
-ui_charge_goombario_png = 0x80101A00; // type:data rom:0x9AEB0
-ui_charge_goombario_pal = 0x80101B20; // type:data rom:0x9AFD0
-ui_exclamation_png = 0x80101B40; // type:data rom:0x9AFF0
-ui_exclamation_pal = 0x80101C60; // type:data rom:0x9B110
-ui_sleeping_png = 0x80101C80; // type:data rom:0x9B130
-ui_sleeping_pal = 0x80101D00; // type:data rom:0x9B1B0
-ui_sleeping2_png = 0x80101D20; // type:data rom:0x9B1D0
-ui_sleeping2_pal = 0x80101DA0; // type:data rom:0x9B250
-ui_sleeping3_png = 0x80101DC0; // type:data rom:0x9B270
-ui_sleeping3_pal = 0x80101E40; // type:data rom:0x9B2F0
-ui_shocked_png = 0x80101E60; // type:data rom:0x9B310
-ui_shocked_pal = 0x80101EE0; // type:data rom:0x9B390
-ui_shocked2_png = 0x80101F00; // type:data rom:0x9B3B0
-ui_shocked2_pal = 0x80101F80; // type:data rom:0x9B430
-ui_shocked3_png = 0x80101FA0; // type:data rom:0x9B450
-ui_shocked3_pal = 0x80102020; // type:data rom:0x9B4D0
-ui_shocked4_png = 0x80102040; // type:data rom:0x9B4F0
-ui_shocked4_pal = 0x801020C0; // type:data rom:0x9B570
-ui_dizzy_png = 0x801020E0; // type:data rom:0x9B590
-ui_dizzy_pal = 0x80102160; // type:data rom:0x9B610
-ui_dizzy2_png = 0x80102180; // type:data rom:0x9B630
-ui_dizzy2_pal = 0x80102200; // type:data rom:0x9B6B0
-ui_dizzy3_png = 0x80102220; // type:data rom:0x9B6D0
-ui_dizzy3_pal = 0x801022A0; // type:data rom:0x9B750
-ui_dizzy4_png = 0x801022C0; // type:data rom:0x9B770
-ui_dizzy4_pal = 0x80102340; // type:data rom:0x9B7F0
-ui_poisoned_png = 0x80102360; // type:data rom:0x9B810
-ui_poisoned_pal = 0x801023E0; // type:data rom:0x9B890
-ui_poisoned2_png = 0x80102400; // type:data rom:0x9B8B0
-ui_poisoned2_pal = 0x80102480; // type:data rom:0x9B930
-ui_frozen_png = 0x801024A0; // type:data rom:0x9B950
-ui_frozen_pal = 0x80102520; // type:data rom:0x9B9D0
-ui_frozen2_png = 0x80102540; // type:data rom:0x9B9F0
-ui_frozen2_pal = 0x801025C0; // type:data rom:0x9BA70
-ui_frozen3_png = 0x801025E0; // type:data rom:0x9BA90
-ui_frozen3_pal = 0x80102660; // type:data rom:0x9BB10
-ui_frozen4_png = 0x80102680; // type:data rom:0x9BB30
-ui_frozen4_pal = 0x80102700; // type:data rom:0x9BBB0
-ui_timed_png = 0x80102720; // type:data rom:0x9BBD0
-ui_timed_pal = 0x801027A0; // type:data rom:0x9BC50
-ui_timed2_png = 0x801027C0; // type:data rom:0x9BC70
-ui_timed2_pal = 0x80102840; // type:data rom:0x9BCF0
-ui_timed3_png = 0x80102860; // type:data rom:0x9BD10
-ui_timed3_pal = 0x801028E0; // type:data rom:0x9BD90
-ui_timed4_png = 0x80102900; // type:data rom:0x9BDB0
-ui_timed4_pal = 0x80102980; // type:data rom:0x9BE30
-ui_downed_png = 0x801029A0; // type:data rom:0x9BE50
-ui_downed_pal = 0x80102A20; // type:data rom:0x9BED0
-ui_downed2_png = 0x80102A40; // type:data rom:0x9BEF0
-ui_downed2_pal = 0x80102AC0; // type:data rom:0x9BF70
-ui_shrink_png = 0x80102AE0; // type:data rom:0x9BF90
-ui_shrink_pal = 0x80102B60; // type:data rom:0x9C010
-ui_shrink2_png = 0x80102B80; // type:data rom:0x9C030
-ui_shrink2_pal = 0x80102C00; // type:data rom:0x9C0B0
-ui_shrink3_png = 0x80102C20; // type:data rom:0x9C0D0
-ui_shrink3_pal = 0x80102CA0; // type:data rom:0x9C150
-ui_shrink4_png = 0x80102CC0; // type:data rom:0x9C170
-ui_shrink4_pal = 0x80102D40; // type:data rom:0x9C1F0
-ui_transparent_png = 0x80102D60; // type:data rom:0x9C210
-ui_transparent_pal = 0x80102DE0; // type:data rom:0x9C290
-ui_transparent2_png = 0x80102E00; // type:data rom:0x9C2B0
-ui_transparent2_pal = 0x80102E80; // type:data rom:0x9C330
-ui_transparent3_png = 0x80102EA0; // type:data rom:0x9C350
-ui_transparent3_pal = 0x80102F20; // type:data rom:0x9C3D0
-ui_transparent4_png = 0x80102F40; // type:data rom:0x9C3F0
-ui_transparent4_pal = 0x80102FC0; // type:data rom:0x9C470
-ui_transparent5_png = 0x80102FE0; // type:data rom:0x9C490
-ui_transparent5_pal = 0x80103060; // type:data rom:0x9C510
-ui_transparent6_png = 0x80103080; // type:data rom:0x9C530
-ui_transparent6_pal = 0x80103100; // type:data rom:0x9C5B0
-ui_peril_png = 0x80103120; // type:data rom:0x9C5D0
-ui_peril_pal = 0x80103260; // type:data rom:0x9C710
-ui_danger_png = 0x80103280; // type:data rom:0x9C730
-ui_danger_pal = 0x801033C0; // type:data rom:0x9C870
-ui_refund_png = 0x801033E0; // type:data rom:0x9C890
-ui_refund_pal = 0x801035C0; // type:data rom:0x9CA70
-ui_happy_png = 0x801035E0; // type:data rom:0x9CA90
-ui_happy_pal = 0x80103720; // type:data rom:0x9CBD0
-ui_hp_drain_png = 0x80103740; // type:data rom:0x9CBF0
-ui_hp_drain_pal = 0x80103880; // type:data rom:0x9CD30
-ui_diamond_png = 0x801038A0; // type:data rom:0x9CD50
-ui_diamond_pal = 0x80103AA0; // type:data rom:0x9CF50
-ui_diamond_disabled_pal = 0x80103AC0; // type:data rom:0x9CF70
-ui_orb_blue_png = 0x80103AE0; // type:data rom:0x9CF90
-ui_orb_blue_pal = 0x80103CE0; // type:data rom:0x9D190
-ui_orb_blue_disabled_pal = 0x80103D00; // type:data rom:0x9D1B0
-ui_orb_green_png = 0x80103D20; // type:data rom:0x9D1D0
-ui_orb_green_pal = 0x80103F20; // type:data rom:0x9D3D0
-ui_orb_green_disabled_pal = 0x80103F40; // type:data rom:0x9D3F0
-ui_orb_red_png = 0x80103F60; // type:data rom:0x9D410
-ui_orb_red_pal = 0x80104160; // type:data rom:0x9D610
-ui_orb_red_disabled_pal = 0x80104180; // type:data rom:0x9D630
+ui_boots_disabled_pal = 0x800FB100; // rom:0x945B0
+ui_super_boots_png = 0x800FB120; // rom:0x945D0
+ui_super_boots_pal = 0x800FB320; // rom:0x947D0
+ui_super_boots_disabled_pal = 0x800FB340; // rom:0x947F0
+ui_ultra_boots_png = 0x800FB360; // rom:0x94810
+ui_ultra_boots_pal = 0x800FB560; // rom:0x94A10
+ui_ultra_boots_disabled_pal = 0x800FB580; // rom:0x94A30
+ui_item_png = 0x800FB5A0; // rom:0x94A50
+ui_item_pal = 0x800FB7A0; // rom:0x94C50
+ui_item_disabled_pal = 0x800FB7C0; // rom:0x94C70
+ui_star_spirit_png = 0x800FB7E0; // rom:0x94C90
+ui_star_spirit_pal = 0x800FB9E0; // rom:0x94E90
+ui_star_spirit_disabled_pal = 0x800FBA00; // rom:0x94EB0
+ui_arrow_left_png = 0x800FBA20; // rom:0x94ED0
+ui_arrow_left_pal = 0x800FBAA0; // rom:0x94F50
+ui_arrow_right_png = 0x800FBAC0; // rom:0x94F70
+ui_arrow_right_pal = 0x800FBB40; // rom:0x94FF0
+ui_point_right_png = 0x800FBB60; // rom:0x95010
+ui_point_right_pal = 0x800FBBE0; // rom:0x95090
+ui_pip_png = 0x800FBC00; // rom:0x950B0
+ui_pip_pal = 0x800FBC20; // rom:0x950D0
+ui_pip2_png = 0x800FBC40; // rom:0x950F0
+ui_pip2_pal = 0x800FBC60; // rom:0x95110
+ui_coin_sparkle_0_png = 0x800FBC80; // rom:0x95130
+ui_coin_sparkle_0_pal = 0x800FBCA0; // rom:0x95150
+ui_coin_sparkle_1_png = 0x800FBCC0; // rom:0x95170
+ui_coin_sparkle_1_pal = 0x800FBCE0; // rom:0x95190
+ui_coin_sparkle_2_png = 0x800FBD00; // rom:0x951B0
+ui_coin_sparkle_2_pal = 0x800FBD20; // rom:0x951D0
+ui_coin_sparkle_3_png = 0x800FBD40; // rom:0x951F0
+ui_coin_sparkle_3_pal = 0x800FBD60; // rom:0x95210
+ui_coin_sparkle_4_png = 0x800FBD80; // rom:0x95230
+ui_coin_sparkle_4_pal = 0x800FBDA0; // rom:0x95250
+ui_coin_sparkle_5_png = 0x800FBDC0; // rom:0x95270
+ui_coin_sparkle_5_pal = 0x800FBDE0; // rom:0x95290
+ui_coin_sparkle_none_png = 0x800FBE00; // rom:0x952B0
+ui_coin_sparkle_none_pal = 0x800FBE20; // rom:0x952D0
+ui_status_star_point_shine_png = 0x800FBE40; // rom:0x952F0
+ui_status_star_piece_0_png = 0x800FC080; // rom:0x95530
+ui_status_star_piece_0_pal = 0x800FC100; // rom:0x955B0
+ui_status_star_piece_1_png = 0x800FC120; // rom:0x955D0
+ui_status_star_piece_1_pal = 0x800FC1A0; // rom:0x95650
+ui_status_star_piece_2_png = 0x800FC1C0; // rom:0x95670
+ui_status_star_piece_2_pal = 0x800FC240; // rom:0x956F0
+ui_menu_times_png = 0x800FC260; // rom:0x95710
+ui_menu_times_pal = 0x800FC280; // rom:0x95730
+ui_fp_cost_png = 0x800FC2A0; // rom:0x95750
+ui_fp_cost_pal = 0x800FC2E0; // rom:0x95790
+ui_fp_cost_reduced_pal = 0x800FC300; // rom:0x957B0
+ui_fp_cost_reduced_twice_pal = 0x800FC320; // rom:0x957D0
+ui_fp_cost_notenough_pal = 0x800FC340; // rom:0x957F0
+ui_pow_cost_png = 0x800FC360; // rom:0x95810
+ui_pow_cost_pal = 0x800FC3A0; // rom:0x95850
+ui_pow_cost_reduced_pal = 0x800FC3C0; // rom:0x95870
+ui_pow_cost_reduced_twice_pal = 0x800FC3E0; // rom:0x95890
+ui_pow_cost_notenough_pal = 0x800FC400; // rom:0x958B0
+ui_green_arrow_down_png = 0x800FC420; // rom:0x958D0
+ui_green_arrow_down_pal = 0x800FC460; // rom:0x95910
+ui_green_arrow_up_png = 0x800FC480; // rom:0x95930
+ui_green_arrow_up_pal = 0x800FC4C0; // rom:0x95970
+ui_kaime_png = 0x800FC4E0; // rom:0x95990
+ui_kaime_pal = 0x800FC780; // rom:0x95C30
+ui_unused_1_png = 0x800FC7A0; // rom:0x95C50
+ui_unused_1_pal = 0x800FC820; // rom:0x95CD0
+ui_unused_2_png = 0x800FC840; // rom:0x95CF0
+ui_unused_2_pal = 0x800FC8C0; // rom:0x95D70
+ui_unused_3_png = 0x800FC8E0; // rom:0x95D90
+ui_unused_3_pal = 0x800FC960; // rom:0x95E10
+ui_red_bar1_png = 0x800FC980; // rom:0x95E30
+ui_red_bar1_pal = 0x800FCB40; // rom:0x95FF0
+ui_empty_bar_png = 0x800FCB60; // rom:0x96010
+ui_empty_bar_pal = 0x800FCD20; // rom:0x961D0
+ui_red_bar2_png = 0x800FCD40; // rom:0x961F0
+ui_red_bar2_pal = 0x800FCEE0; // rom:0x96390
+ui_eldstar_png = 0x800FCF00; // rom:0x963B0
+ui_eldstar_pal = 0x800FD100; // rom:0x965B0
+ui_eldstar_disabled_pal = 0x800FD120; // rom:0x965D0
+ui_mamar_png = 0x800FD140; // rom:0x965F0
+ui_mamar_pal = 0x800FD340; // rom:0x967F0
+ui_mamar_disabled_pal = 0x800FD360; // rom:0x96810
+ui_skolar_png = 0x800FD380; // rom:0x96830
+ui_skolar_pal = 0x800FD580; // rom:0x96A30
+ui_skolar_disabled_pal = 0x800FD5A0; // rom:0x96A50
+ui_muskular_png = 0x800FD5C0; // rom:0x96A70
+ui_muskular_pal = 0x800FD7C0; // rom:0x96C70
+ui_muskular_disabled_pal = 0x800FD7E0; // rom:0x96C90
+ui_misstar_png = 0x800FD800; // rom:0x96CB0
+ui_misstar_pal = 0x800FDA00; // rom:0x96EB0
+ui_misstar_disabled_pal = 0x800FDA20; // rom:0x96ED0
+ui_klevar_png = 0x800FDA40; // rom:0x96EF0
+ui_klevar_pal = 0x800FDC40; // rom:0x970F0
+ui_klevar_disabled_pal = 0x800FDC60; // rom:0x97110
+ui_kalmar_png = 0x800FDC80; // rom:0x97130
+ui_kalmar_pal = 0x800FDE80; // rom:0x97330
+ui_kalmar_disabled_pal = 0x800FDEA0; // rom:0x97350
+ui_star_beam_png = 0x800FDEC0; // rom:0x97370
+ui_star_beam_pal = 0x800FE0C0; // rom:0x97570
+ui_star_beam_disabled_pal = 0x800FE0E0; // rom:0x97590
+ui_peach_beam_png = 0x800FE100; // rom:0x975B0
+ui_peach_beam_pal = 0x800FE300; // rom:0x977B0
+ui_peach_beam_disabled_pal = 0x800FE320; // rom:0x977D0
+ui_mario_head_png = 0x800FE340; // rom:0x977F0
+ui_mario_head_pal = 0x800FE3C0; // rom:0x97870
+ui_partner0_png = 0x800FE3E0; // rom:0x97890
+ui_partner0_pal = 0x800FE5E0; // rom:0x97A90
+ui_partner0_disabled_pal = 0x800FE600; // rom:0x97AB0
+ui_goombario_png = 0x800FE620; // rom:0x97AD0
+ui_goombario_pal = 0x800FE820; // rom:0x97CD0
+ui_goombario_disabled_pal = 0x800FE840; // rom:0x97CF0
+ui_kooper_png = 0x800FE860; // rom:0x97D10
+ui_kooper_pal = 0x800FEA60; // rom:0x97F10
+ui_kooper_disabled_pal = 0x800FEA80; // rom:0x97F30
+ui_bombette_png = 0x800FEAA0; // rom:0x97F50
+ui_bombette_pal = 0x800FECA0; // rom:0x98150
+ui_bombette_disabled_pal = 0x800FECC0; // rom:0x98170
+ui_parakarry_png = 0x800FECE0; // rom:0x98190
+ui_parakarry_pal = 0x800FEEE0; // rom:0x98390
+ui_parakarry_disabled_pal = 0x800FEF00; // rom:0x983B0
+ui_bow_png = 0x800FEF20; // rom:0x983D0
+ui_bow_pal = 0x800FF120; // rom:0x985D0
+ui_bow_disabled_pal = 0x800FF140; // rom:0x985F0
+ui_watt_png = 0x800FF160; // rom:0x98610
+ui_watt_pal = 0x800FF360; // rom:0x98810
+ui_watt_disabled_pal = 0x800FF380; // rom:0x98830
+ui_sushie_png = 0x800FF3A0; // rom:0x98850
+ui_sushie_pal = 0x800FF5A0; // rom:0x98A50
+ui_sushie_disabled_pal = 0x800FF5C0; // rom:0x98A70
+ui_lakilester_png = 0x800FF5E0; // rom:0x98A90
+ui_lakilester_pal = 0x800FF7E0; // rom:0x98C90
+ui_lakilester_disabled_pal = 0x800FF800; // rom:0x98CB0
+ui_partner9_png = 0x800FF820; // rom:0x98CD0
+ui_partner9_pal = 0x800FFA20; // rom:0x98ED0
+ui_partner9_disabled_pal = 0x800FFA40; // rom:0x98EF0
+ui_partner10_png = 0x800FFA60; // rom:0x98F10
+ui_partner10_pal = 0x800FFC60; // rom:0x99110
+ui_partner10_disabled_pal = 0x800FFC80; // rom:0x99130
+ui_partner11_png = 0x800FFCA0; // rom:0x99150
+ui_partner11_pal = 0x800FFEA0; // rom:0x99350
+ui_partner11_disabled_pal = 0x800FFEC0; // rom:0x99370
+ui_status_text_times_png = 0x800FFEE0; // rom:0x99390
+ui_status_text_times_pal = 0x800FFF00; // rom:0x993B0
+ui_status_text_slash_png = 0x800FFF20; // rom:0x993D0
+ui_status_text_slash_pal = 0x800FFF60; // rom:0x99410
+ui_status_text_0_png = 0x800FFF80; // rom:0x99430
+ui_status_text_0_pal = 0x80100000; // rom:0x994B0
+ui_status_text_1_png = 0x80100020; // rom:0x994D0
+ui_status_text_1_pal = 0x801000A0; // rom:0x99550
+ui_status_text_2_png = 0x801000C0; // rom:0x99570
+ui_status_text_2_pal = 0x80100140; // rom:0x995F0
+ui_status_text_3_png = 0x80100160; // rom:0x99610
+ui_status_text_3_pal = 0x801001E0; // rom:0x99690
+ui_status_text_4_png = 0x80100200; // rom:0x996B0
+ui_status_text_4_pal = 0x80100280; // rom:0x99730
+ui_status_text_5_png = 0x801002A0; // rom:0x99750
+ui_status_text_5_pal = 0x80100320; // rom:0x997D0
+ui_status_text_6_png = 0x80100340; // rom:0x997F0
+ui_status_text_6_pal = 0x801003C0; // rom:0x99870
+ui_status_text_7_png = 0x801003E0; // rom:0x99890
+ui_status_text_7_pal = 0x80100460; // rom:0x99910
+ui_status_text_8_png = 0x80100480; // rom:0x99930
+ui_status_text_8_pal = 0x80100500; // rom:0x999B0
+ui_status_text_9_png = 0x80100520; // rom:0x999D0
+ui_status_text_9_pal = 0x801005A0; // rom:0x99A50
+ui_status_text_hp_png = 0x801005C0; // rom:0x99A70
+ui_status_text_hp_pal = 0x80100640; // rom:0x99AF0
+ui_status_text_fp_png = 0x80100660; // rom:0x99B10
+ui_status_text_fp_pal = 0x801006E0; // rom:0x99B90
+ui_status_pow_unit_1_png = 0x80100700; // rom:0x99BB0
+ui_status_pow_unit_1_pal = 0x80100720; // rom:0x99BD0
+ui_status_pow_unit_2_png = 0x80100740; // rom:0x99BF0
+ui_status_pow_unit_2_pal = 0x80100760; // rom:0x99C10
+ui_status_pow_unit_3_png = 0x80100780; // rom:0x99C30
+ui_status_pow_unit_3_pal = 0x801007A0; // rom:0x99C50
+ui_status_pow_unit_4_png = 0x801007C0; // rom:0x99C70
+ui_status_pow_unit_4_pal = 0x801007E0; // rom:0x99C90
+ui_status_pow_unit_5_png = 0x80100800; // rom:0x99CB0
+ui_status_pow_unit_5_pal = 0x80100820; // rom:0x99CD0
+ui_status_pow_unit_6_png = 0x80100840; // rom:0x99CF0
+ui_status_pow_unit_6_pal = 0x80100860; // rom:0x99D10
+ui_status_pow_unit_7_png = 0x80100880; // rom:0x99D30
+ui_status_pow_unit_7_pal = 0x801008A0; // rom:0x99D50
+ui_status_pow_unit_empty_png = 0x801008C0; // rom:0x99D70
+ui_status_pow_unit_empty_pal = 0x801008E0; // rom:0x99D90
+ui_status_pow_star_1_png = 0x80100900; // rom:0x99DB0
+ui_status_pow_star_1_pal = 0x80100920; // rom:0x99DD0
+ui_status_pow_star_2_png = 0x80100940; // rom:0x99DF0
+ui_status_pow_star_2_pal = 0x80100960; // rom:0x99E10
+ui_status_pow_star_3_png = 0x80100980; // rom:0x99E30
+ui_status_pow_star_3_pal = 0x801009A0; // rom:0x99E50
+ui_status_pow_star_4_png = 0x801009C0; // rom:0x99E70
+ui_status_pow_star_4_pal = 0x801009E0; // rom:0x99E90
+ui_status_pow_star_5_png = 0x80100A00; // rom:0x99EB0
+ui_status_pow_star_5_pal = 0x80100A20; // rom:0x99ED0
+ui_status_pow_star_6_png = 0x80100A40; // rom:0x99EF0
+ui_status_pow_star_6_pal = 0x80100A60; // rom:0x99F10
+ui_status_pow_star_7_png = 0x80100A80; // rom:0x99F30
+ui_status_pow_star_7_pal = 0x80100AA0; // rom:0x99F50
+ui_status_pow_star_empty_png = 0x80100AC0; // rom:0x99F70
+ui_status_pow_star_empty_pal = 0x80100AE0; // rom:0x99F90
+ui_status_coin_0_png = 0x80100B00; // rom:0x99FB0
+ui_status_coin_0_pal = 0x80100B80; // rom:0x9A030
+ui_status_coin_1_png = 0x80100BA0; // rom:0x9A050
+ui_status_coin_1_pal = 0x80100C20; // rom:0x9A0D0
+ui_status_coin_2_png = 0x80100C40; // rom:0x9A0F0
+ui_status_coin_2_pal = 0x80100CC0; // rom:0x9A170
+ui_status_coin_3_png = 0x80100CE0; // rom:0x9A190
+ui_status_coin_3_pal = 0x80100D60; // rom:0x9A210
+ui_status_coin_4_png = 0x80100D80; // rom:0x9A230
+ui_status_coin_4_pal = 0x80100E00; // rom:0x9A2B0
+ui_status_coin_5_png = 0x80100E20; // rom:0x9A2D0
+ui_status_coin_5_pal = 0x80100EA0; // rom:0x9A350
+ui_status_coin_6_png = 0x80100EC0; // rom:0x9A370
+ui_status_coin_6_pal = 0x80100F40; // rom:0x9A3F0
+ui_status_coin_7_png = 0x80100F60; // rom:0x9A410
+ui_status_coin_7_pal = 0x80100FE0; // rom:0x9A490
+ui_status_coin_8_png = 0x80101000; // rom:0x9A4B0
+ui_status_coin_8_pal = 0x80101080; // rom:0x9A530
+ui_status_coin_9_png = 0x801010A0; // rom:0x9A550
+ui_status_coin_9_pal = 0x80101120; // rom:0x9A5D0
+ui_status_star_point_0_png = 0x80101140; // rom:0x9A5F0
+ui_status_star_point_0_pal = 0x801011C0; // rom:0x9A670
+ui_status_star_point_1_png = 0x801011E0; // rom:0x9A690
+ui_status_star_point_1_pal = 0x80101260; // rom:0x9A710
+ui_status_star_point_2_png = 0x80101280; // rom:0x9A730
+ui_status_star_point_2_pal = 0x80101300; // rom:0x9A7B0
+ui_status_star_point_3_png = 0x80101320; // rom:0x9A7D0
+ui_status_star_point_3_pal = 0x801013A0; // rom:0x9A850
+ui_status_star_point_4_png = 0x801013C0; // rom:0x9A870
+ui_status_star_point_4_pal = 0x80101440; // rom:0x9A8F0
+ui_status_star_point_5_png = 0x80101460; // rom:0x9A910
+ui_status_star_point_5_pal = 0x801014E0; // rom:0x9A990
+ui_status_star_point_6_png = 0x80101500; // rom:0x9A9B0
+ui_status_star_point_6_pal = 0x80101580; // rom:0x9AA30
+ui_status_star_point_7_png = 0x801015A0; // rom:0x9AA50
+ui_status_star_point_7_pal = 0x80101620; // rom:0x9AAD0
+ui_bluepip_png = 0x80101640; // rom:0x9AAF0
+ui_bluepip_pal = 0x801016C0; // rom:0x9AB70
+ui_bluepip2_png = 0x801016E0; // rom:0x9AB90
+ui_bluepip2_pal = 0x80101760; // rom:0x9AC10
+ui_battle_status_charge_jump_png = 0x80101780; // rom:0x9AC30
+ui_battle_status_charge_jump_pal = 0x801018A0; // rom:0x9AD50
+ui_battle_status_charge_hammer_png = 0x801018C0; // rom:0x9AD70
+ui_battle_status_charge_hammer_pal = 0x801019E0; // rom:0x9AE90
+ui_battle_status_charge_goombario_png = 0x80101A00; // rom:0x9AEB0
+ui_battle_status_charge_goombario_pal = 0x80101B20; // rom:0x9AFD0
+ui_battle_status_exclamation_png = 0x80101B40; // rom:0x9AFF0
+ui_battle_status_exclamation_pal = 0x80101C60; // rom:0x9B110
+ui_battle_status_sleep_0_png = 0x80101C80; // rom:0x9B130
+ui_battle_status_sleep_0_pal = 0x80101D00; // rom:0x9B1B0
+ui_battle_status_sleep_1_png = 0x80101D20; // rom:0x9B1D0
+ui_battle_status_sleep_1_pal = 0x80101DA0; // rom:0x9B250
+ui_battle_status_sleep_2_png = 0x80101DC0; // rom:0x9B270
+ui_battle_status_sleep_2_pal = 0x80101E40; // rom:0x9B2F0
+ui_battle_status_static_0_png = 0x80101E60; // rom:0x9B310
+ui_battle_status_static_0_pal = 0x80101EE0; // rom:0x9B390
+ui_battle_status_static_1_png = 0x80101F00; // rom:0x9B3B0
+ui_battle_status_static_1_pal = 0x80101F80; // rom:0x9B430
+ui_battle_status_paralyze_0_png = 0x80101FA0; // rom:0x9B450
+ui_battle_status_paralyze_0_pal = 0x80102020; // rom:0x9B4D0
+ui_battle_status_paralyze_1_png = 0x80102040; // rom:0x9B4F0
+ui_battle_status_paralyze_1_pal = 0x801020C0; // rom:0x9B570
+ui_battle_status_dizzy_0_png = 0x801020E0; // rom:0x9B590
+ui_battle_status_dizzy_0_pal = 0x80102160; // rom:0x9B610
+ui_battle_status_dizzy_1_png = 0x80102180; // rom:0x9B630
+ui_battle_status_dizzy_1_pal = 0x80102200; // rom:0x9B6B0
+ui_battle_status_dizzy_2_png = 0x80102220; // rom:0x9B6D0
+ui_battle_status_dizzy_2_pal = 0x801022A0; // rom:0x9B750
+ui_battle_status_dizzy_3_png = 0x801022C0; // rom:0x9B770
+ui_battle_status_dizzy_3_pal = 0x80102340; // rom:0x9B7F0
+ui_battle_status_poison_0_png = 0x80102360; // rom:0x9B810
+ui_battle_status_poison_0_pal = 0x801023E0; // rom:0x9B890
+ui_battle_status_poison_1_png = 0x80102400; // rom:0x9B8B0
+ui_battle_status_poison_1_pal = 0x80102480; // rom:0x9B930
+ui_battle_status_frozen_0_png = 0x801024A0; // rom:0x9B950
+ui_battle_status_frozen_0_pal = 0x80102520; // rom:0x9B9D0
+ui_battle_status_frozen_1_png = 0x80102540; // rom:0x9B9F0
+ui_battle_status_frozen_1_pal = 0x801025C0; // rom:0x9BA70
+ui_battle_status_frozen_2_png = 0x801025E0; // rom:0x9BA90
+ui_battle_status_frozen_2_pal = 0x80102660; // rom:0x9BB10
+ui_battle_status_frozen_3_png = 0x80102680; // rom:0x9BB30
+ui_battle_status_frozen_3_pal = 0x80102700; // rom:0x9BBB0
+ui_battle_status_stop_0_png = 0x80102720; // rom:0x9BBD0
+ui_battle_status_stop_0_pal = 0x801027A0; // rom:0x9BC50
+ui_battle_status_stop_1_png = 0x801027C0; // rom:0x9BC70
+ui_battle_status_stop_1_pal = 0x80102840; // rom:0x9BCF0
+ui_battle_status_stop_2_png = 0x80102860; // rom:0x9BD10
+ui_battle_status_stop_2_pal = 0x801028E0; // rom:0x9BD90
+ui_battle_status_stop_3_png = 0x80102900; // rom:0x9BDB0
+ui_battle_status_stop_3_pal = 0x80102980; // rom:0x9BE30
+ui_battle_status_pdown_0_png = 0x801029A0; // rom:0x9BE50
+ui_battle_status_pdown_0_pal = 0x80102A20; // rom:0x9BED0
+ui_battle_status_pdown_1_png = 0x80102A40; // rom:0x9BEF0
+ui_battle_status_pdown_1_pal = 0x80102AC0; // rom:0x9BF70
+ui_battle_status_shrink_0_png = 0x80102AE0; // rom:0x9BF90
+ui_battle_status_shrink_0_pal = 0x80102B60; // rom:0x9C010
+ui_battle_status_shrink_1_png = 0x80102B80; // rom:0x9C030
+ui_battle_status_shrink_1_pal = 0x80102C00; // rom:0x9C0B0
+ui_battle_status_shrink_2_png = 0x80102C20; // rom:0x9C0D0
+ui_battle_status_shrink_2_pal = 0x80102CA0; // rom:0x9C150
+ui_battle_status_shrink_3_png = 0x80102CC0; // rom:0x9C170
+ui_battle_status_shrink_3_pal = 0x80102D40; // rom:0x9C1F0
+ui_battle_status_transparent_0_png = 0x80102D60; // rom:0x9C210
+ui_battle_status_transparent_0_pal = 0x80102DE0; // rom:0x9C290
+ui_battle_status_transparent_1_png = 0x80102E00; // rom:0x9C2B0
+ui_battle_status_transparent_1_pal = 0x80102E80; // rom:0x9C330
+ui_battle_status_transparent_2_png = 0x80102EA0; // rom:0x9C350
+ui_battle_status_transparent_2_pal = 0x80102F20; // rom:0x9C3D0
+ui_battle_status_transparent_3_png = 0x80102F40; // rom:0x9C3F0
+ui_battle_status_transparent_3_pal = 0x80102FC0; // rom:0x9C470
+ui_battle_status_transparent_4_png = 0x80102FE0; // rom:0x9C490
+ui_battle_status_transparent_4_pal = 0x80103060; // rom:0x9C510
+ui_battle_status_transparent_5_png = 0x80103080; // rom:0x9C530
+ui_battle_status_transparent_5_pal = 0x80103100; // rom:0x9C5B0
+ui_battle_status_peril_png = 0x80103120; // rom:0x9C5D0
+ui_battle_status_peril_pal = 0x80103260; // rom:0x9C710
+ui_battle_status_danger_png = 0x80103280; // rom:0x9C730
+ui_battle_status_danger_pal = 0x801033C0; // rom:0x9C870
+ui_battle_status_refund_png = 0x801033E0; // rom:0x9C890
+ui_battle_status_refund_pal = 0x801035C0; // rom:0x9CA70
+ui_battle_status_happy_png = 0x801035E0; // rom:0x9CA90
+ui_battle_status_happy_pal = 0x80103720; // rom:0x9CBD0
+ui_battle_status_hp_drain_png = 0x80103740; // rom:0x9CBF0
+ui_battle_status_hp_drain_pal = 0x80103880; // rom:0x9CD30
+ui_move_basic_png = 0x801038A0; // rom:0x9CD50
+ui_move_basic_pal = 0x80103AA0; // rom:0x9CF50
+ui_move_basic_disabled_pal = 0x80103AC0; // rom:0x9CF70
+ui_move_partner_1_png = 0x80103AE0; // rom:0x9CF90
+ui_move_partner_1_pal = 0x80103CE0; // rom:0x9D190
+ui_move_partner_1_disabled_pal = 0x80103D00; // rom:0x9D1B0
+ui_move_partner_2_png = 0x80103D20; // rom:0x9D1D0
+ui_move_partner_2_pal = 0x80103F20; // rom:0x9D3D0
+ui_move_partner_2_disabled_pal = 0x80103F40; // rom:0x9D3F0
+ui_move_partner_3_png = 0x80103F60; // rom:0x9D410
+ui_move_partner_3_pal = 0x80104160; // rom:0x9D610
+ui_move_partner_3_disabled_pal = 0x80104180; // rom:0x9D630
 D_801041A0 = 0x801041A0; // type:data rom:0x9D650
 ui_stat_heart_png = 0x801041A8; // type:data rom:0x9D658
 D_801045A8 = 0x801045A8; // type:data rom:0x9DA58
 ui_stat_flower_png = 0x801045B0; // type:data rom:0x9DA60
+HES_ArrowLeft = 0x801049B0; // type:data rom:0x9DE60
+HES_ArrowRight = 0x801049D8; // type:data rom:0x9DE88
+HES_HandPointer = 0x80104A00; // type:data rom:0x9DEB0
+HES_AnimatedHandPointer = 0x80104A28; // type:data rom:0x9DED8
+HES_FilledCircle = 0x80104A70; // type:data rom:0x9DF20
+HES_EmptyCircle = 0x80104A98; // type:data rom:0x9DF48
+SparkleScript_Coin = 0x80104AC0; // type:data rom:0x9DF70
+HES_StatusSPShine = 0x80104BEC; // type:data rom:0x9E09C
+HES_StatusStarPiece = 0x80104C10; // type:data rom:0x9E0C0
+HES_AsleepLoop = 0x80104C68; // type:data rom:0x9E118
+HES_AsleepBegin = 0x80104CC4; // type:data rom:0x9E174
+HES_AsleepEnd = 0x80104E64; // type:data rom:0x9E314
+HES_ElectrifiedLoop = 0x80104FBC; // type:data rom:0x9E46C
+HES_ElectrifiedBegin = 0x801050A8; // type:data rom:0x9E558
+HES_ElectrifiedEnd = 0x801052D8; // type:data rom:0x9E788
+HES_ParalyzedLoop = 0x80105430; // type:data rom:0x9E8E0
+HES_ParalyzedBegin = 0x8010551C; // type:data rom:0x9E9CC
+HES_ParalyzedEnd = 0x8010574C; // type:data rom:0x9EBFC
+HES_DizzyLoop = 0x801058A4; // type:data rom:0x9ED54
+HES_DizzyBegin = 0x80105900; // type:data rom:0x9EDB0
+HES_DizzyEnd = 0x80105AA0; // type:data rom:0x9EF50
+HES_PoisonedLoop = 0x80105BF8; // type:data rom:0x9F0A8
+HES_PoisonedBegin = 0x80105C54; // type:data rom:0x9F104
+HES_PoisonedEnd = 0x80105DF4; // type:data rom:0x9F2A4
+HES_FrozenLoop = 0x80105F4C; // type:data rom:0x9F3FC
+HES_FrozenBegin = 0x80105FA8; // type:data rom:0x9F458
+HES_FrozenEnd = 0x80106148; // type:data rom:0x9F5F8
+HES_WeakenedLoop = 0x801062A0; // type:data rom:0x9F750
+HES_WeakenedBegin = 0x801062DC; // type:data rom:0x9F78C
+HES_WeakenedEnd = 0x8010645C; // type:data rom:0x9F90C
+HES_Stopped = 0x801065B4; // type:data rom:0x9FA64
+HES_StoppedBegin = 0x80106610; // type:data rom:0x9FAC0
+HES_StoppedEnd = 0x801067B0; // type:data rom:0x9FC60
+HES_ShrunkLoop = 0x80106908; // type:data rom:0x9FDB8
+HES_ShrunkBegin = 0x80106964; // type:data rom:0x9FE14
+HES_ShrunkEnd = 0x80106B04; // type:data rom:0x9FFB4
+HES_TransparentLoop = 0x80106C5C; // type:data rom:0xA010C
+HES_TransparentBegin = 0x80106CD8; // type:data rom:0xA0188
+HES_TransparentEnd = 0x80106E98; // type:data rom:0xA0348
+HES_BoostJumpLoop = 0x80106FF0; // type:data rom:0xA04A0
+HES_BoostJumpBegin = 0x8010701C; // type:data rom:0xA04CC
+HES_BoostJumpEnd = 0x8010717C; // type:data rom:0xA062C
+HES_BoostHammerLoop = 0x801072E8; // type:data rom:0xA0798
+HES_BoostHammerBegin = 0x80107314; // type:data rom:0xA07C4
+HES_BoostHammerEnd = 0x80107474; // type:data rom:0xA0924
+HES_BoostPartner = 0x801075E0; // type:data rom:0xA0A90
+HES_Surprise = 0x8010760C; // type:data rom:0xA0ABC
+HES_FPCost = 0x80107638; // type:data rom:0xA0AE8
+HES_FPCostReduced = 0x80107664; // type:data rom:0xA0B14
+HES_FPCostReducedTwice = 0x80107690; // type:data rom:0xA0B40
+HES_NotEnoughFP = 0x801076BC; // type:data rom:0xA0B6C
+HES_POWCost = 0x801076E8; // type:data rom:0xA0B98
+HES_POWCostReduced = 0x80107714; // type:data rom:0xA0BC4
+HES_POWCostReducedTwice = 0x80107740; // type:data rom:0xA0BF0
+HES_NotEnoughPOW = 0x8010776C; // type:data rom:0xA0C1C
+HES_GreenArrowDown = 0x80107798; // type:data rom:0xA0C48
+HES_GreenArrowUp = 0x801077E4; // type:data rom:0xA0C94
+HES_UnusedPinkFrame = 0x80107830; // type:data rom:0xA0CE0
+HES_UnusedDigit1 = 0x8010785C; // type:data rom:0xA0D0C
+HES_UnusedDigit2 = 0x80107888; // type:data rom:0xA0D38
+HES_UnusedDigit3 = 0x801078B4; // type:data rom:0xA0D64
+HES_RedBar1 = 0x801078E0; // type:data rom:0xA0D90
+HES_EmptyBar = 0x8010790C; // type:data rom:0xA0DBC
+HES_RedBar2 = 0x80107938; // type:data rom:0xA0DE8
+HES_MarioHead = 0x80107964; // type:data rom:0xA0E14
+HES_Eldstar = 0x80107990; // type:data rom:0xA0E40
+HES_EldstarDisabled = 0x801079BC; // type:data rom:0xA0E6C
+HES_Mamar = 0x801079E8; // type:data rom:0xA0E98
+HES_MamarDisabled = 0x80107A14; // type:data rom:0xA0EC4
+HES_Skolar = 0x80107A40; // type:data rom:0xA0EF0
+HES_SkolarDisabled = 0x80107A6C; // type:data rom:0xA0F1C
+HES_Muskular = 0x80107A98; // type:data rom:0xA0F48
+HES_MuskularDisabled = 0x80107AC4; // type:data rom:0xA0F74
+HES_Misstar = 0x80107AF0; // type:data rom:0xA0FA0
+HES_MisstarDisabled = 0x80107B1C; // type:data rom:0xA0FCC
+HES_Klevar = 0x80107B48; // type:data rom:0xA0FF8
+HES_KlevarDisabled = 0x80107B74; // type:data rom:0xA1024
+HES_Kalmar = 0x80107BA0; // type:data rom:0xA1050
+HES_KalmarDisabled = 0x80107BCC; // type:data rom:0xA107C
+HES_StarBeam = 0x80107BF8; // type:data rom:0xA10A8
+HES_StarBeamDisabled = 0x80107C24; // type:data rom:0xA10D4
+HES_PeachBeam = 0x80107C50; // type:data rom:0xA1100
+HES_PeachBeamDisabled = 0x80107C7C; // type:data rom:0xA112C
+HES_Partner0 = 0x80107CA8; // type:data rom:0xA1158
+HES_Partner0Disabled = 0x80107CD0; // type:data rom:0xA1180
+HES_Goombario = 0x80107CF8; // type:data rom:0xA11A8
+HES_GoombarioDisabled = 0x80107D20; // type:data rom:0xA11D0
+HES_Kooper = 0x80107D48; // type:data rom:0xA11F8
+HES_KooperDisabled = 0x80107D70; // type:data rom:0xA1220
+HES_Bombette = 0x80107D98; // type:data rom:0xA1248
+HES_BombetteDisabled = 0x80107DC0; // type:data rom:0xA1270
+HES_Parakarry = 0x80107DE8; // type:data rom:0xA1298
+HES_ParakarryDisabled = 0x80107E10; // type:data rom:0xA12C0
+HES_Bow = 0x80107E38; // type:data rom:0xA12E8
+HES_BowDisabled = 0x80107E60; // type:data rom:0xA1310
+HES_Watt = 0x80107E88; // type:data rom:0xA1338
+HES_WattDisabled = 0x80107EB0; // type:data rom:0xA1360
+HES_Sushie = 0x80107ED8; // type:data rom:0xA1388
+HES_SushieDisabled = 0x80107F00; // type:data rom:0xA13B0
+HES_Lakilester = 0x80107F28; // type:data rom:0xA13D8
+HES_LakilesterDisabled = 0x80107F50; // type:data rom:0xA1400
+HES_Partner9 = 0x80107F78; // type:data rom:0xA1428
+HES_Partner9Disabled = 0x80107FA0; // type:data rom:0xA1450
+HES_PartnerA = 0x80107FC8; // type:data rom:0xA1478
+HES_PartnerADisabled = 0x80107FF0; // type:data rom:0xA14A0
+HES_PartnerB = 0x80108018; // type:data rom:0xA14C8
+HES_PartnerBDisabled = 0x80108040; // type:data rom:0xA14F0
+HES_StatusTimes = 0x80108068; // type:data rom:0xA1518
+HES_StatusSlash = 0x80108090; // type:data rom:0xA1540
+HES_StatusDigit0 = 0x801080B8; // type:data rom:0xA1568
+HES_StatusDigit1 = 0x801080E0; // type:data rom:0xA1590
+HES_StatusDigit2 = 0x80108108; // type:data rom:0xA15B8
+HES_StatusDigit3 = 0x80108130; // type:data rom:0xA15E0
+HES_StatusDigit4 = 0x80108158; // type:data rom:0xA1608
+HES_StatusDigit5 = 0x80108180; // type:data rom:0xA1630
+HES_StatusDigit6 = 0x801081A8; // type:data rom:0xA1658
+HES_StatusDigit7 = 0x801081D0; // type:data rom:0xA1680
+HES_StatusDigit8 = 0x801081F8; // type:data rom:0xA16A8
+HES_StatusDigit9 = 0x80108220; // type:data rom:0xA16D0
+HES_StatusHP = 0x80108248; // type:data rom:0xA16F8
+HES_StatusFP = 0x80108270; // type:data rom:0xA1720
+HES_StatusSPIncrement1 = 0x80108298; // type:data rom:0xA1748
+HES_StatusSPIncrement2 = 0x801082C0; // type:data rom:0xA1770
+HES_StatusSPIncrement3 = 0x801082E8; // type:data rom:0xA1798
+HES_StatusSPIncrement4 = 0x80108310; // type:data rom:0xA17C0
+HES_StatusSPIncrement5 = 0x80108338; // type:data rom:0xA17E8
+HES_StatusSPIncrement6 = 0x80108360; // type:data rom:0xA1810
+HES_StatusSPIncrement7 = 0x80108388; // type:data rom:0xA1838
+HES_StatusSPEmptyIncrement = 0x801083B0; // type:data rom:0xA1860
+HES_StatusStar1 = 0x801083D8; // type:data rom:0xA1888
+HES_StatusStar2 = 0x80108400; // type:data rom:0xA18B0
+HES_StatusStar3 = 0x80108428; // type:data rom:0xA18D8
+HES_StatusStar4 = 0x80108450; // type:data rom:0xA1900
+HES_StatusStar5 = 0x80108478; // type:data rom:0xA1928
+HES_StatusStar6 = 0x801084A0; // type:data rom:0xA1950
+HES_StatusStar7 = 0x801084C8; // type:data rom:0xA1978
+HES_StatusStarEmpty = 0x801084F0; // type:data rom:0xA19A0
+HES_StatusHeart = 0x80108518; // type:data rom:0xA19C8
+HES_StatusFlower = 0x80108538; // type:data rom:0xA19E8
+HES_StatusCoin = 0x80108558; // type:data rom:0xA1A08
+HES_StatusStarPoint = 0x801086AC; // type:data rom:0xA1B5C
+HES_MenuBoots1 = 0x80108744; // type:data rom:0xA1BF4
+HES_MenuBoots1Disabled = 0x8010876C; // type:data rom:0xA1C1C
+HES_MenuBoots2 = 0x80108794; // type:data rom:0xA1C44
+HES_MenuBoots2Disabled = 0x801087BC; // type:data rom:0xA1C6C
+HES_MenuBoots3 = 0x801087E4; // type:data rom:0xA1C94
+HES_MenuBoots3Disabled = 0x8010880C; // type:data rom:0xA1CBC
+HES_MenuHammer1 = 0x80108834; // type:data rom:0xA1CE4
+HES_MenuHammer1Disabled = 0x8010885C; // type:data rom:0xA1D0C
+HES_MenuHammer2 = 0x80108884; // type:data rom:0xA1D34
+HES_MenuHammer2Disabled = 0x801088AC; // type:data rom:0xA1D5C
+HES_MenuHammer3 = 0x801088D4; // type:data rom:0xA1D84
+HES_MenuHammer3Disabled = 0x801088FC; // type:data rom:0xA1DAC
+HES_MenuItem = 0x80108924; // type:data rom:0xA1DD4
+HES_MenuItemDisabled = 0x8010894C; // type:data rom:0xA1DFC
+HES_MenuStarPower = 0x80108974; // type:data rom:0xA1E24
+HES_MenuStarPowerDisabled = 0x8010899C; // type:data rom:0xA1E4C
+HES_Peril = 0x801089C4; // type:data rom:0xA1E74
+HES_Danger = 0x80108A14; // type:data rom:0xA1EC4
 HES_Refund = 0x80108A64; // type:data rom:0xA1F14
+HES_Happy = 0x80108AAC; // type:data rom:0xA1F5C
+HES_HPDrain = 0x80108AD4; // type:data rom:0xA1F84
+HES_BlueMeter = 0x80108AFC; // type:data rom:0xA1FAC
+HES_AButton = 0x80108B28; // type:data rom:0xA1FD8
+HES_AButtonDown = 0x80108B54; // type:data rom:0xA2004
+HES_MashAButton = 0x80108B80; // type:data rom:0xA2030
+HES_PressAButton = 0x80108BBC; // type:data rom:0xA206C
+HES_SlowlyPressAButton = 0x80108BF8; // type:data rom:0xA20A8
+HES_SlowlyMashAButton = 0x80108C34; // type:data rom:0xA20E4
+HES_StartButton = 0x80108C70; // type:data rom:0xA2120
+HES_StartButtonDown = 0x80108C9C; // type:data rom:0xA214C
+HES_MashStartButton = 0x80108CC8; // type:data rom:0xA2178
+HES_PressStartButton = 0x80108D04; // type:data rom:0xA21B4
+HES_StartButtonText = 0x80108D40; // type:data rom:0xA21F0
+HES_RotateStickCW = 0x80108D6C; // type:data rom:0xA221C
+HES_StickNeutral = 0x80108E1C; // type:data rom:0xA22CC
+HES_StickHoldLeft = 0x80108E48; // type:data rom:0xA22F8
+HES_StickBackAndForth = 0x80108E80; // type:data rom:0xA2330
+HES_StickMashLeft = 0x80108F30; // type:data rom:0xA23E0
+HES_StickTapLeft = 0x80108F90; // type:data rom:0xA2440
+HES_StickTapNeutral = 0x80108FF0; // type:data rom:0xA24A0
+HES_StickHoldDown = 0x8010908C; // type:data rom:0xA253C
+HES_StickMashDown = 0x801090C4; // type:data rom:0xA2574
+HES_StickTapDown = 0x80109124; // type:data rom:0xA25D4
+HES_StickSlowlyTapDown = 0x80109184; // type:data rom:0xA2634
+HES_StickTapRight = 0x801091E4; // type:data rom:0xA2694
+HES_RunAwayOK = 0x80109244; // type:data rom:0xA26F4
+HES_MenuTimes = 0x80109270; // type:data rom:0xA2720
+HES_PartnerRank1A = 0x80109298; // type:data rom:0xA2748
+HES_PartnerRank1B = 0x801092C0; // type:data rom:0xA2770
+HES_PartnerRank2A = 0x801092E8; // type:data rom:0xA2798
+HES_PartnerRank2B = 0x80109310; // type:data rom:0xA27C0
+HES_MoveDiamond = 0x80109338; // type:data rom:0xA27E8
+HES_MoveBlueOrb = 0x80109360; // type:data rom:0xA2810
+HES_MoveGreenOrb = 0x80109388; // type:data rom:0xA2838
+HES_MoveRedOrb = 0x801093B0; // type:data rom:0xA2860
+HES_MoveDiamondDisabled = 0x801093D8; // type:data rom:0xA2888
+HES_MoveBlueOrbDisabled = 0x80109400; // type:data rom:0xA28B0
+HES_MoveGreenOrbDisabled = 0x80109428; // type:data rom:0xA28D8
+HES_MoveRedOrbDisabled = 0x80109450; // type:data rom:0xA2900
 D_80109890 = 0x80109890; // type:data rom:0xA2D40
 D_80109898 = 0x80109898; // type:data rom:0xA2D48
 D_801098A0 = 0x801098A0; // type:data rom:0xA2D50
@@ -3567,7 +3776,7 @@ ui_box_corners4_png = 0x8010B360; // type:data rom:0xA4810
 ui_box_bg_tile_png = 0x8010B460; // type:data rom:0xA4910
 ui_box_corners1_png = 0x8010B4E0; // type:data rom:0xA4990
 ui_box_corners2_png = 0x8010B8E0; // type:data rom:0xA4D90
-ui_background2_png = 0x8010BAE0; // type:data rom:0xA4F90
+ui_box_bg_flat_png = 0x8010BAE0; // type:data rom:0xA4F90
 D_8010BAE8 = 0x8010BAE8; // type:data rom:0xA4F98
 D_8010BB00 = 0x8010BB00; // type:data rom:0xA4FB0
 D_8010BB90 = 0x8010BB90; // type:data rom:0xA5040
@@ -4408,12 +4617,20 @@ gMsgUnkQuad = 0x8014C4C0; // type:data rom:0xE2BC0
 D_8014C500 = 0x8014C500; // type:data rom:0xE2C00
 D_8014C580 = 0x8014C580; // type:data rom:0xE2C80
 D_8014C588 = 0x8014C588; // type:data rom:0xE2C88
+D_8014C5A0 = 0x8014C5A0; // type:data rom:0xE2CA0
+D_8014C5E0 = 0x8014C5E0; // type:data rom:0xE2CE0
+D_8014C620 = 0x8014C620; // type:data rom:0xE2D20
+D_8014C678 = 0x8014C678; // type:data rom:0xE2D78
+D_8014C6A0 = 0x8014C6A0; // type:data rom:0xE2DA0
+D_8014C6C8 = 0x8014C6C8; // type:data rom:0xE2DC8
+D_8014C6E0 = 0x8014C6E0; // type:data rom:0xE2DE0
+D_8014C6E4 = 0x8014C6E4; // type:data rom:0xE2DE4
 D_8014C6F0 = 0x8014C6F0; // type:data rom:0xE2DF0
 D_8014C6F4 = 0x8014C6F4; // type:data rom:0xE2DF4
-ui_battle_menu_spirits_png = 0x8028A460; // type:data rom:0x1B8D40
-ui_battle_menu_spirits_pal = 0x8028A660; // type:data rom:0x1B8F40
-ui_battle_unk_star_png = 0x8028F640; // type:data rom:0x1BDF20
-ui_battle_unk_star_pal = 0x8028F840; // type:data rom:0x1BE120
+ui_stencil_star_png = 0x8014C700; // rom:0xE2E00
+ui_stencil_mario_png = 0x8014CB00; // rom:0xE3200
+ui_stencil_sharp_circle_png = 0x8014D300; // rom:0xE3A00
+ui_stencil_blurry_circle_png = 0x8014D500; // rom:0xE3C00
 vtx_stencil1 = 0x8014E500; // type:data rom:0xE4C00
 Gfx_LoadStencilTex_CommonParams = 0x8014E5A0; // type:data rom:0xE4CA0
 Gfx_LoadStencilTex_SharpCircle = 0x8014E618; // type:data rom:0xE4D18
@@ -4793,6 +5010,7 @@ D_80153A57 = 0x80153A57; // type:data rom:0xEA157
 gAnimModelFogStart = 0x80153A58; // type:data rom:0xEA158
 gAnimModelFogEnd = 0x80153A5C; // type:data rom:0xEA15C
 gAnimVtxSegment = 0x80153A60; // type:data rom:0xEA160
+D_80153A64 = 0x80153A64; // type:data rom:0xEA164
 evt_handle_set_float = 0x802C57B8; // type:func rom:0xEA168
 gAnimScaleMtx = 0x80153AA8; // type:data rom:0xEA1A8
 evt_handle_add = 0x802C5804; // type:func rom:0xEA1B4
@@ -5365,7 +5583,7 @@ RemoveEffect = 0x802D7AE4; // type:func rom:0xFC494
 func_802D7B10 = 0x802D7B10; // type:func rom:0xFC4C0
 func_802D7B44 = 0x802D7B44; // type:func rom:0xFC4F4
 func_802D7B74 = 0x802D7B74; // type:func rom:0xFC524
-func_802D7BA4 = 0x802D7BA4; // type:func rom:0xFC554
+InterpMotionBlurParams = 0x802D7BA4; // type:func rom:0xFC554
 SetMotionBlurParams = 0x802D7CF8; // type:func rom:0xFC6A8
 ShowSweat = 0x802D7E08; // type:func rom:0xFC7B8
 ShowSleepBubble = 0x802D8028; // type:func rom:0xFC9D8
@@ -5387,7 +5605,7 @@ ShakeCamX = 0x802D9CE8; // rom:0xFE698
 playerNpc = 0x802D9D20; // rom:0xFE6D0
 D_802D9D30 = 0x802D9D30; // type:data rom:0xFE6E0
 D_802D9D34 = 0x802D9D34; // type:data rom:0xFE6E4
-D_802D9D50 = 0x802D9D50; // rom:0xFE700
+EVS_UpdateMotionBlurParams = 0x802D9D50; // rom:0xFE700
 D_802D9D70 = 0x802D9D70; // type:data rom:0xFE720
 D_802D9D71 = 0x802D9D71; // type:data rom:0xFE721
 D_802D9D72 = 0x802D9D72; // type:data rom:0xFE722
@@ -7035,6 +7253,252 @@ PeachScriptDispatcher = 0x80285010; // rom:0x1B38F0
 HandleEvent_Player = 0x802852D4; // rom:0x1B3BB4
 DoDizzyAttack = 0x8028907C; // rom:0x1B795C
 RegainAbility = 0x80289110; // rom:0x1B79F0
+ui_battle_menu_unused_png = 0x80289400; // rom:0x1B7CE0
+ui_battle_menu_unused_pal = 0x80289600; // rom:0x1B7EE0
+ui_battle_menu_unused_disabled_pal = 0x80289620; // rom:0x1B7F00
+ui_battle_menu_flee_png = 0x80289640; // rom:0x1B7F20
+ui_battle_menu_flee_pal = 0x80289840; // rom:0x1B8120
+ui_battle_menu_flee_disabled_pal = 0x80289860; // rom:0x1B8140
+ui_battle_menu_defend_png = 0x80289880; // rom:0x1B8160
+ui_battle_menu_defend_pal = 0x80289A80; // rom:0x1B8360
+ui_battle_menu_defend_disabled_pal = 0x80289AA0; // rom:0x1B8380
+ui_battle_menu_strategies_png = 0x80289AC0; // rom:0x1B83A0
+ui_battle_menu_strategies_pal = 0x80289CC0; // rom:0x1B85A0
+ui_battle_menu_strategies_disabled_pal = 0x80289CE0; // rom:0x1B85C0
+ui_battle_menu_nothing_png = 0x80289D00; // rom:0x1B85E0
+ui_battle_menu_nothing_pal = 0x80289F00; // rom:0x1B87E0
+ui_battle_menu_nothing_disabled_pal = 0x80289F20; // rom:0x1B8800
+ui_battle_menu_pouch_png = 0x80289F40; // rom:0x1B8820
+ui_battle_menu_pouch_pal = 0x8028A140; // rom:0x1B8A20
+ui_battle_menu_pouch_disabled_pal = 0x8028A160; // rom:0x1B8A40
+ui_battle_swap_Z_png = 0x8028A180; // rom:0x1B8A60
+ui_battle_swap_Z_pal = 0x8028A200; // rom:0x1B8AE0
+ui_battle_swap_arrow_left_png = 0x8028A220; // rom:0x1B8B00
+ui_battle_swap_arrow_left_pal = 0x8028A260; // rom:0x1B8B40
+ui_battle_swap_arrow_right_png = 0x8028A280; // rom:0x1B8B60
+ui_battle_swap_arrow_right_pal = 0x8028A2C0; // rom:0x1B8BA0
+ui_battle_menu_spirits_png = 0x8028A460; // rom:0x1B8D40
+ui_battle_menu_spirits_png = 0x8028A460; // type:data rom:0x1B8D40
+ui_battle_menu_spirits_pal = 0x8028A660; // type:data rom:0x1B8F40
+ui_battle_menu_spirits_pal = 0x8028A660; // rom:0x1B8F40
+ui_battle_yellow_arrow_png = 0x8028A680; // rom:0x1B8F60
+ui_battle_yellow_arrow_pal = 0x8028A700; // rom:0x1B8FE0
+ui_battle_hp_bar_png = 0x8028A840; // rom:0x1B9120
+ui_battle_hp_bar_pal = 0x8028A940; // rom:0x1B9220
+ui_battle_hp_0_png = 0x8028A960; // rom:0x1B9240
+ui_battle_hp_0_pal = 0x8028A980; // rom:0x1B9260
+ui_battle_hp_1_png = 0x8028A9A0; // rom:0x1B9280
+ui_battle_hp_1_pal = 0x8028A9C0; // rom:0x1B92A0
+ui_battle_hp_2_png = 0x8028A9E0; // rom:0x1B92C0
+ui_battle_hp_2_pal = 0x8028AA00; // rom:0x1B92E0
+ui_battle_hp_3_png = 0x8028AA20; // rom:0x1B9300
+ui_battle_hp_3_pal = 0x8028AA40; // rom:0x1B9320
+ui_battle_hp_4_png = 0x8028AA60; // rom:0x1B9340
+ui_battle_hp_4_pal = 0x8028AA80; // rom:0x1B9360
+ui_battle_hp_5_png = 0x8028AAA0; // rom:0x1B9380
+ui_battle_hp_5_pal = 0x8028AAC0; // rom:0x1B93A0
+ui_battle_hp_6_png = 0x8028AAE0; // rom:0x1B93C0
+ui_battle_hp_6_pal = 0x8028AB00; // rom:0x1B93E0
+ui_battle_hp_7_png = 0x8028AB20; // rom:0x1B9400
+ui_battle_hp_7_pal = 0x8028AB40; // rom:0x1B9420
+ui_battle_hp_8_png = 0x8028AB60; // rom:0x1B9440
+ui_battle_hp_8_pal = 0x8028AB80; // rom:0x1B9460
+ui_battle_hp_9_png = 0x8028ABA0; // rom:0x1B9480
+ui_battle_hp_9_pal = 0x8028ABC0; // rom:0x1B94A0
+ui_battle_cont_b_up_png = 0x8028ABE0; // rom:0x1B94C0
+ui_battle_cont_b_up_pal = 0x8028AFA0; // rom:0x1B9880
+ui_battle_cont_b_down_png = 0x8028AFC0; // rom:0x1B98A0
+ui_battle_cont_b_down_pal = 0x8028B380; // rom:0x1B9C60
+ui_battle_cont_c_left_up_png = 0x8028B3A0; // rom:0x1B9C80
+ui_battle_cont_c_left_up_pal = 0x8028B648; // rom:0x1B9F28
+ui_battle_cont_c_left_down_png = 0x8028B668; // rom:0x1B9F48
+ui_battle_cont_c_left_down_pal = 0x8028B910; // rom:0x1BA1F0
+ui_battle_cont_c_right_up_png = 0x8028B930; // rom:0x1BA210
+ui_battle_cont_c_right_up_pal = 0x8028BBD8; // rom:0x1BA4B8
+ui_battle_cont_c_right_down_png = 0x8028BBF8; // rom:0x1BA4D8
+ui_battle_cont_c_right_down_pal = 0x8028BEA0; // rom:0x1BA780
+ui_battle_cont_c_up_up_png = 0x8028BEC0; // rom:0x1BA7A0
+ui_battle_cont_c_up_up_pal = 0x8028C168; // rom:0x1BAA48
+ui_battle_cont_c_up_down_png = 0x8028C188; // rom:0x1BAA68
+ui_battle_cont_c_up_down_pal = 0x8028C430; // rom:0x1BAD10
+ui_battle_cont_c_down_up_png = 0x8028C450; // rom:0x1BAD30
+ui_battle_cont_c_down_up_pal = 0x8028C6F8; // rom:0x1BAFD8
+ui_battle_cont_c_down_down_png = 0x8028C718; // rom:0x1BAFF8
+ui_battle_cont_c_down_down_pal = 0x8028C9C0; // rom:0x1BB2A0
+ui_battle_cmd_timing_1_chance_png = 0x8028C9E0; // rom:0x1BB2C0
+ui_battle_cmd_timing_1_chance_pal = 0x8028CD40; // rom:0x1BB620
+ui_battle_cmd_timing_ready_png = 0x8028CD60; // rom:0x1BB640
+ui_battle_cmd_timing_ready_pal = 0x8028CDE0; // rom:0x1BB6C0
+ui_battle_cmd_timing_wait_png = 0x8028CE00; // rom:0x1BB6E0
+ui_battle_cmd_timing_wait_pal = 0x8028CE80; // rom:0x1BB760
+ui_battle_cmd_charge_1_png = 0x8028CEA0; // rom:0x1BB780
+ui_battle_cmd_charge_1_pal = 0x8028CEC0; // rom:0x1BB7A0
+ui_battle_cmd_charge_2_png = 0x8028CEE0; // rom:0x1BB7C0
+ui_battle_cmd_charge_2_pal = 0x8028CF00; // rom:0x1BB7E0
+ui_battle_cmd_charge_3_png = 0x8028CF20; // rom:0x1BB800
+ui_battle_cmd_charge_3_pal = 0x8028CF40; // rom:0x1BB820
+ui_battle_cmd_charge_4_png = 0x8028CF60; // rom:0x1BB840
+ui_battle_cmd_charge_4_pal = 0x8028CF80; // rom:0x1BB860
+ui_battle_cmd_timing_3_chances_png = 0x8028CFA0; // rom:0x1BB880
+ui_battle_cmd_timing_3_chances_pal = 0x8028D420; // rom:0x1BBD00
+ui_battle_cmd_gauge_result_png = 0x8028D440; // rom:0x1BBD20
+ui_battle_cmd_gauge_result_pal = 0x8028D5C0; // rom:0x1BBEA0
+ui_battle_cmd_timing_ok_png = 0x8028D5E0; // rom:0x1BBEC0
+ui_battle_cmd_timing_ok_pal = 0x8028D700; // rom:0x1BBFE0
+ui_battle_cmd_timing_miss_png = 0x8028D720; // rom:0x1BC000
+ui_battle_cmd_timing_miss_pal = 0x8028D840; // rom:0x1BC120
+ui_battle_cmd_flee_0_png = 0x8028D860; // rom:0x1BC140
+ui_battle_cmd_flee_0_pal = 0x8028D920; // rom:0x1BC200
+ui_battle_cmd_flee_1_png = 0x8028D940; // rom:0x1BC220
+ui_battle_cmd_flee_1_pal = 0x8028DA00; // rom:0x1BC2E0
+ui_battle_cmd_flee_2_png = 0x8028DA20; // rom:0x1BC300
+ui_battle_cmd_flee_2_pal = 0x8028DAE0; // rom:0x1BC3C0
+ui_battle_cmd_100pct_png = 0x8028DB00; // rom:0x1BC3E0
+ui_battle_cmd_100pct_pal = 0x8028E100; // rom:0x1BC9E0
+ui_battle_cmd_right_on_png = 0x8028E120; // rom:0x1BCA00
+ui_battle_cmd_right_on_pal = 0x8028E3C0; // rom:0x1BCCA0
+ui_battle_cmd_fill_result_png = 0x8028E3E0; // rom:0x1BCCC0
+ui_battle_cmd_fill_result_pal = 0x8028E560; // rom:0x1BCE40
+ui_battle_cmd_aim_marker_0_png = 0x8028E580; // rom:0x1BCE60
+ui_battle_cmd_aim_marker_0_pal = 0x8028E600; // rom:0x1BCEE0
+ui_battle_cmd_aim_marker_1_png = 0x8028E620; // rom:0x1BCF00
+ui_battle_cmd_aim_marker_1_pal = 0x8028E6A0; // rom:0x1BCF80
+ui_battle_cmd_aim_marker_2_png = 0x8028E6C0; // rom:0x1BCFA0
+ui_battle_cmd_aim_marker_2_pal = 0x8028E740; // rom:0x1BD020
+ui_battle_cmd_aim_marker_3_png = 0x8028E760; // rom:0x1BD040
+ui_battle_cmd_aim_marker_3_pal = 0x8028E7E0; // rom:0x1BD0C0
+ui_battle_cmd_aim_marker_4_png = 0x8028E800; // rom:0x1BD0E0
+ui_battle_cmd_aim_marker_4_pal = 0x8028E880; // rom:0x1BD160
+ui_battle_cmd_aim_marker_5_png = 0x8028E8A0; // rom:0x1BD180
+ui_battle_cmd_aim_marker_5_pal = 0x8028E920; // rom:0x1BD200
+ui_battle_cmd_aim_marker_6_png = 0x8028E940; // rom:0x1BD220
+ui_battle_cmd_aim_marker_6_pal = 0x8028E9C0; // rom:0x1BD2A0
+ui_battle_cmd_aim_marker_7_png = 0x8028E9E0; // rom:0x1BD2C0
+ui_battle_cmd_aim_marker_7_pal = 0x8028EA60; // rom:0x1BD340
+ui_battle_cmd_aim_shimmer_0_png = 0x8028EA80; // rom:0x1BD360
+ui_battle_cmd_aim_shimmer_0_pal = 0x8028EB00; // rom:0x1BD3E0
+ui_battle_cmd_aim_shimmer_1_png = 0x8028EB20; // rom:0x1BD400
+ui_battle_cmd_aim_shimmer_1_pal = 0x8028EBA0; // rom:0x1BD480
+ui_battle_cmd_aim_shimmer_2_png = 0x8028EBC0; // rom:0x1BD4A0
+ui_battle_cmd_aim_shimmer_2_pal = 0x8028EC40; // rom:0x1BD520
+ui_battle_cmd_aim_shimmer_3_png = 0x8028EC60; // rom:0x1BD540
+ui_battle_cmd_aim_shimmer_3_pal = 0x8028ECE0; // rom:0x1BD5C0
+ui_battle_cmd_aim_shimmer_4_png = 0x8028ED00; // rom:0x1BD5E0
+ui_battle_cmd_aim_shimmer_4_pal = 0x8028ED80; // rom:0x1BD660
+ui_battle_cmd_aim_shimmer_5_png = 0x8028EDA0; // rom:0x1BD680
+ui_battle_cmd_aim_shimmer_5_pal = 0x8028EE20; // rom:0x1BD700
+ui_battle_cmd_aim_shimmer_6_png = 0x8028EE40; // rom:0x1BD720
+ui_battle_cmd_aim_shimmer_6_pal = 0x8028EEC0; // rom:0x1BD7A0
+ui_battle_cmd_aim_shimmer_7_png = 0x8028EEE0; // rom:0x1BD7C0
+ui_battle_cmd_aim_shimmer_7_pal = 0x8028EF60; // rom:0x1BD840
+ui_battle_cmd_aim_reticle_0_png = 0x8028EF80; // rom:0x1BD860
+ui_battle_cmd_aim_reticle_0_pal = 0x8028F180; // rom:0x1BDA60
+ui_battle_cmd_aim_reticle_1_png = 0x8028F1A0; // rom:0x1BDA80
+ui_battle_cmd_aim_reticle_1_pal = 0x8028F3A0; // rom:0x1BDC80
+ui_battle_cmd_aim_target_0_png = 0x8028F3C0; // rom:0x1BDCA0
+ui_battle_cmd_aim_target_0_pal = 0x8028F4E0; // rom:0x1BDDC0
+ui_battle_cmd_aim_target_1_png = 0x8028F500; // rom:0x1BDDE0
+ui_battle_cmd_aim_target_1_pal = 0x8028F620; // rom:0x1BDF00
+ui_battle_unk_star_png = 0x8028F640; // rom:0x1BDF20
+ui_battle_unk_star_png = 0x8028F640; // type:data rom:0x1BDF20
+ui_battle_unk_star_pal = 0x8028F840; // rom:0x1BE120
+ui_battle_unk_star_pal = 0x8028F840; // type:data rom:0x1BE120
+D_8028F860 = 0x8028F860; // type:data rom:0x1BE140
+ui_battle_projector_spot_png = 0x8028F868; // rom:0x1BE148
+D_8028FC68 = 0x8028FC68; // type:data rom:0x1BE548
+ui_battle_projector_beam_png = 0x8028FC70; // rom:0x1BE550
+D_80290C70 = 0x80290C70; // type:data rom:0x1BF550
+ui_battle_projector_reel_png = 0x80290C78; // rom:0x1BF558
+D_80291C78 = 0x80291C78; // type:data rom:0x1C0558
+ui_battle_swap_background_png = 0x80291C80; // rom:0x1C0560
+HES_HPBar = 0x80291F80; // type:data rom:0x1C0860
+HES_HPDigit0 = 0x80291FA8; // type:data rom:0x1C0888
+HES_HPDigit1 = 0x80291FD0; // type:data rom:0x1C08B0
+HES_HPDigit2 = 0x80291FF8; // type:data rom:0x1C08D8
+HES_HPDigit3 = 0x80292020; // type:data rom:0x1C0900
+HES_HPDigit4 = 0x80292048; // type:data rom:0x1C0928
+HES_HPDigit5 = 0x80292070; // type:data rom:0x1C0950
+HES_HPDigit6 = 0x80292098; // type:data rom:0x1C0978
+HES_HPDigit7 = 0x802920C0; // type:data rom:0x1C09A0
+HES_HPDigit8 = 0x802920E8; // type:data rom:0x1C09C8
+HES_HPDigit9 = 0x80292110; // type:data rom:0x1C09F0
+HES_YellowArrow = 0x80292138; // type:data rom:0x1C0A18
+HES_MenuFlee = 0x80292160; // type:data rom:0x1C0A40
+HES_MenuFleeDisabled = 0x80292188; // type:data rom:0x1C0A68
+HES_MenuDefend = 0x802921B0; // type:data rom:0x1C0A90
+HES_MenuDefendDisabled = 0x802921D8; // type:data rom:0x1C0AB8
+HES_MenuStrategies = 0x80292200; // type:data rom:0x1C0AE0
+HES_MenuStrategiesDisabled = 0x80292228; // type:data rom:0x1C0B08
+HES_MenuPouch = 0x80292250; // type:data rom:0x1C0B30
+HES_MenuPouchDisabled = 0x80292278; // type:data rom:0x1C0B58
+HES_MenuDoNothing = 0x802922A0; // type:data rom:0x1C0B80
+HES_MenuDoNothingDisabled = 0x802922C8; // type:data rom:0x1C0BA8
+HES_TimingBar1Chance = 0x802922F0; // type:data rom:0x1C0BD0
+HES_BButton = 0x8029231C; // type:data rom:0x1C0BFC
+HES_BButtonHeld = 0x80292348; // type:data rom:0x1C0C28
+HES_MashBButton1 = 0x80292374; // type:data rom:0x1C0C54
+HES_PressBButton = 0x802923B0; // type:data rom:0x1C0C90
+HES_MashBButton2 = 0x802923FC; // type:data rom:0x1C0CDC
+HES_CLeftButton = 0x80292438; // type:data rom:0x1C0D18
+HES_CLeftButtonHeld = 0x80292464; // type:data rom:0x1C0D44
+HES_MashCLeftButton = 0x80292490; // type:data rom:0x1C0D70
+HES_CRightButton = 0x802924CC; // type:data rom:0x1C0DAC
+HES_CRightButtonHeld = 0x802924F8; // type:data rom:0x1C0DD8
+HES_MashCRightButton1 = 0x80292524; // type:data rom:0x1C0E04
+HES_MashCRightButton2 = 0x80292560; // type:data rom:0x1C0E40
+HES_CUpButton = 0x8029259C; // type:data rom:0x1C0E7C
+HES_CUpButtonHeld = 0x802925C8; // type:data rom:0x1C0EA8
+HES_MashCUpButton = 0x802925F4; // type:data rom:0x1C0ED4
+HES_CDownButton = 0x80292630; // type:data rom:0x1C0F10
+HES_CDownButtonHeld = 0x8029265C; // type:data rom:0x1C0F3C
+HES_MashCDownButton1 = 0x80292688; // type:data rom:0x1C0F68
+HES_PressCDownButton = 0x802926C4; // type:data rom:0x1C0FA4
+HES_MashCDownButton2 = 0x80292710; // type:data rom:0x1C0FF0
+HES_TimingWait = 0x8029275C; // type:data rom:0x1C103C
+HES_TimingReady = 0x80292788; // type:data rom:0x1C1068
+HES_TimingBlink = 0x802927B4; // type:data rom:0x1C1094
+HES_TimingCharge4a = 0x802927F0; // type:data rom:0x1C10D0
+HES_TimingCharge1 = 0x8029281C; // type:data rom:0x1C10FC
+HES_TimingCharge4b = 0x80292848; // type:data rom:0x1C1128
+HES_TimingCharge2 = 0x80292874; // type:data rom:0x1C1154
+HES_TimingCharge4c = 0x802928A0; // type:data rom:0x1C1180
+HES_TimingCharge3 = 0x802928CC; // type:data rom:0x1C11AC
+HES_RunningAway = 0x802928F8; // type:data rom:0x1C11D8
+HES_100pct = 0x80292974; // type:data rom:0x1C1254
+HES_RightOn = 0x80292A2C; // type:data rom:0x1C130C
+HES_TimingBar3Chances = 0x80292AFC; // type:data rom:0x1C13DC
+HES_TimingGaugeResult = 0x80292B28; // type:data rom:0x1C1408
+HES_TimingOK = 0x80292B54; // type:data rom:0x1C1434
+HES_TimingMiss = 0x80292B80; // type:data rom:0x1C1460
+HES_FillGaugeResult = 0x80292BAC; // type:data rom:0x1C148C
+HES_ProjectorReel = 0x80292BD8; // type:data rom:0x1C14B8
+HES_ProjectorSpot = 0x80292C00; // type:data rom:0x1C14E0
+HES_ProjectorBeam = 0x80292C28; // type:data rom:0x1C1508
+HES_SwapZ = 0x80292C50; // type:data rom:0x1C1530
+HES_SwapArrowLeft = 0x80292C7C; // type:data rom:0x1C155C
+HES_SwapArrowRight = 0x80292CB8; // type:data rom:0x1C1598
+HES_SwapBackground = 0x80292CF4; // type:data rom:0x1C15D4
+HES_AimMarkerA = 0x80292D1C; // type:data rom:0x1C15FC
+HES_AimMarkerB = 0x80292DB4; // type:data rom:0x1C1694
+HES_AimMarkerC = 0x80292E4C; // type:data rom:0x1C172C
+HES_AimMarkerD = 0x80292EE4; // type:data rom:0x1C17C4
+HES_AimMarkerE = 0x80292F7C; // type:data rom:0x1C185C
+HES_AimMarkerF = 0x80293014; // type:data rom:0x1C18F4
+HES_AimMarkerG = 0x802930AC; // type:data rom:0x1C198C
+HES_AimMarkerH = 0x80293144; // type:data rom:0x1C1A24
+HES_AimShimmerA = 0x802931DC; // type:data rom:0x1C1ABC
+HES_AimShimmerB = 0x80293274; // type:data rom:0x1C1B54
+HES_AimShimmerC = 0x8029330C; // type:data rom:0x1C1BEC
+HES_AimShimmerD = 0x802933A4; // type:data rom:0x1C1C84
+HES_AimShimmerE = 0x8029343C; // type:data rom:0x1C1D1C
+HES_AimShimmerF = 0x802934D4; // type:data rom:0x1C1DB4
+HES_AimShimmerG = 0x8029356C; // type:data rom:0x1C1E4C
+HES_AimShimmerH = 0x80293604; // type:data rom:0x1C1EE4
+HES_AimReticle = 0x8029369C; // type:data rom:0x1C1F7C
+HES_AimTarget = 0x802936D4; // type:data rom:0x1C1FB4
+HES_AimBlinkA = 0x8029370C; // type:data rom:0x1C1FEC
+HES_AimBlinkB = 0x80293764; // type:data rom:0x1C2044
+HES_AimBlinkC = 0x802937C4; // type:data rom:0x1C20A4
 gMoveScriptTable = 0x80293E80; // rom:0x1C2760
 DoSleepHit = 0x802945E0; // rom:0x1C2EC0
 DoDizzyHit = 0x802945FC; // rom:0x1C2EDC
@@ -7504,6 +7968,30 @@ shim_sfx_play_sound_at_position = 0xE0200680; // type:func rom:0x326150
 D_E0200690 = 0xE0200690; // type:data rom:0x326160
 effectFuncs = 0xE0200694; // type:data rom:0x326164
 D_E0200734 = 0xE0200734; // type:data rom:0x326204
+D_09000000_326410 = 0x9000000; // type:data rom:0x326410
+D_09000200_326610 = 0x9000200; // type:data rom:0x326610
+D_09000220_326630 = 0x9000220; // type:data rom:0x326630
+D_09000420_326830 = 0x9000420; // type:data rom:0x326830
+D_09000440_326850 = 0x9000440; // type:data rom:0x326850
+D_09000640_326A50 = 0x9000640; // type:data rom:0x326A50
+D_09000660_326A70 = 0x9000660; // type:data rom:0x326A70
+D_09000860_326C70 = 0x9000860; // type:data rom:0x326C70
+D_09000880_326C90 = 0x9000880; // type:data rom:0x326C90
+D_09000A80_326E90 = 0x9000A80; // type:data rom:0x326E90
+D_09000AA0_326EB0 = 0x9000AA0; // type:data rom:0x326EB0
+D_09000CA0_3270B0 = 0x9000CA0; // type:data rom:0x3270B0
+D_09000CC0_3270D0 = 0x9000CC0; // type:data rom:0x3270D0
+D_09000EC0_3272D0 = 0x9000EC0; // type:data rom:0x3272D0
+D_09000EE0_3272F0 = 0x9000EE0; // type:data rom:0x3272F0
+D_09000F20_327330 = 0x9000F20; // type:data rom:0x327330
+D_09000F88_327398 = 0x9000F88; // type:data rom:0x327398
+D_09000FA0_3273B0 = 0x9000FA0; // type:data rom:0x3273B0
+D_09001060_327470 = 0x9001060; // type:data rom:0x327470
+D_09001120_327530 = 0x9001120; // type:data rom:0x327530
+D_090011E0_3275F0 = 0x90011E0; // type:data rom:0x3275F0
+D_090012A0_3276B0 = 0x90012A0; // type:data rom:0x3276B0
+D_09001360_327770 = 0x9001360; // type:data rom:0x327770
+D_09001420_327830 = 0x9001420; // type:data rom:0x327830
 big_smoke_puff_main = 0xE0002000; // type:func rom:0x3278F0
 big_smoke_puff_init = 0xE00021B4; // type:func rom:0x327AA4
 big_smoke_puff_update = 0xE00021BC; // type:func rom:0x327AAC
@@ -7534,6 +8022,25 @@ flower_splash_update = 0xE00103F4; // type:func rom:0x32CB94
 flower_splash_render = 0xE00104B0; // type:func rom:0x32CC50
 func_E00104F4 = 0xE00104F4; // type:func rom:0x32CC94
 flower_splash_appendGfx = 0xE0010510; // type:func rom:0x32CCB0
+D_09000000_32CEC0 = 0x9000000; // type:data rom:0x32CEC0
+D_09000080_32CF40 = 0x9000080; // type:data rom:0x32CF40
+D_090000A0_32CF60 = 0x90000A0; // type:data rom:0x32CF60
+D_090000C0_32CF80 = 0x90000C0; // type:data rom:0x32CF80
+D_090008C0_32D780 = 0x90008C0; // type:data rom:0x32D780
+D_09000A30_32D8F0 = 0x9000A30; // type:data rom:0x32D8F0
+D_09000A40_32D900 = 0x9000A40; // type:data rom:0x32D900
+D_09000A50_32D910 = 0x9000A50; // type:data rom:0x32D910
+D_09000A90_32D950 = 0x9000A90; // type:data rom:0x32D950
+D_09000AB0_32D970 = 0x9000AB0; // type:data rom:0x32D970
+D_09000AF0_32D9B0 = 0x9000AF0; // type:data rom:0x32D9B0
+D_09000B50_32DA10 = 0x9000B50; // type:data rom:0x32DA10
+D_09000C10_32DAD0 = 0x9000C10; // type:data rom:0x32DAD0
+D_09000CD0_32DB90 = 0x9000CD0; // type:data rom:0x32DB90
+D_09000D58_32DC18 = 0x9000D58; // type:data rom:0x32DC18
+D_09000D90_32DC50 = 0x9000D90; // type:data rom:0x32DC50
+D_09000E08_32DCC8 = 0x9000E08; // type:data rom:0x32DCC8
+D_09000E20_32DCE0 = 0x9000E20; // type:data rom:0x32DCE0
+D_09000E38_32DCF8 = 0x9000E38; // type:data rom:0x32DCF8
 func_E0012000 = 0xE0012000; // type:func rom:0x32DD10
 func_E0012104 = 0xE0012104; // type:func rom:0x32DE14
 flower_trail_main = 0xE0012204; // type:func rom:0x32DF14
@@ -7547,6 +8054,11 @@ cloud_puff_init = 0xE0014258; // type:func rom:0x32E6E8
 cloud_puff_update = 0xE0014260; // type:func rom:0x32E6F0
 cloud_puff_render = 0xE001449C; // type:func rom:0x32E92C
 cloud_puff_appendGfx = 0xE00144E0; // type:func rom:0x32E970
+D_09000000_32EC50 = 0x9000000; // type:data rom:0x32EC50
+D_09000080_32ECD0 = 0x9000080; // type:data rom:0x32ECD0
+D_090000A0_32ECF0 = 0x90000A0; // type:data rom:0x32ECF0
+D_090000E0_32ED30 = 0x90000E0; // type:data rom:0x32ED30
+D_090001B8_32EE08 = 0x90001B8; // type:data rom:0x32EE08
 cloud_trail_main = 0xE0016000; // type:func rom:0x32EE30
 cloud_trail_init = 0xE0016220; // type:func rom:0x32F050
 cloud_trail_update = 0xE0016228; // type:func rom:0x32F058
@@ -7559,18 +8071,35 @@ footprint_update = 0xE00182B4; // type:func rom:0x32F834
 footprint_render = 0xE0018378; // type:func rom:0x32F8F8
 func_E00183BC = 0xE00183BC; // type:func rom:0x32F93C
 footprint_appendGfx = 0xE00183D8; // type:func rom:0x32F958
+D_09000000_32FB50 = 0x9000000; // type:data rom:0x32FB50
+D_09000200_32FD50 = 0x9000200; // type:data rom:0x32FD50
+D_09000240_32FD90 = 0x9000240; // type:data rom:0x32FD90
 floating_flower_main = 0xE001A000; // type:func rom:0x32FE30
 floating_flower_init = 0xE001A21C; // type:func rom:0x33004C
 floating_flower_update = 0xE001A224; // type:func rom:0x330054
 floating_flower_render = 0xE001A3FC; // type:func rom:0x33022C
 floating_flower_appendGfx = 0xE001A440; // type:func rom:0x330270
 D_E001A610 = 0xE001A610; // type:data rom:0x330440
+D_09000000_330460 = 0x9000000; // type:data rom:0x330460
+D_09000080_3304E0 = 0x9000080; // type:data rom:0x3304E0
+D_090000A0_330500 = 0x90000A0; // type:data rom:0x330500
+D_09000170_3305D0 = 0x9000170; // type:data rom:0x3305D0
+D_09000230_330690 = 0x9000230; // type:data rom:0x330690
+D_090002F0_330750 = 0x90002F0; // type:data rom:0x330750
+D_09000450_3308B0 = 0x9000450; // type:data rom:0x3308B0
 snowflake_main = 0xE001C000; // type:func rom:0x330910
 snowflake_init = 0xE001C120; // type:func rom:0x330A30
 snowflake_update = 0xE001C128; // type:func rom:0x330A38
 snowflake_render = 0xE001C200; // type:func rom:0x330B10
 snowflake_appendGfx = 0xE001C30C; // type:func rom:0x330C1C
 D_E001C5E0 = 0xE001C5E0; // type:data rom:0x330EF0
+D_09000000_330F00 = 0x9000000; // type:data rom:0x330F00
+D_09000080_330F80 = 0x9000080; // type:data rom:0x330F80
+D_09000880_331780 = 0x9000880; // type:data rom:0x331780
+D_090008C0_3317C0 = 0x90008C0; // type:data rom:0x3317C0
+D_09000900_331800 = 0x9000900; // type:data rom:0x331800
+D_090009E8_3318E8 = 0x90009E8; // type:data rom:0x3318E8
+D_09000A10_331910 = 0x9000A10; // type:data rom:0x331910
 star_main = 0xE001E000; // type:func rom:0x331940
 star_init = 0xE001E370; // type:func rom:0x331CB0
 star_update = 0xE001E378; // type:func rom:0x331CB8
@@ -7671,6 +8200,50 @@ D_E003CCA0 = 0xE003CCA0; // type:data rom:0x350160
 D_E003CCD0 = 0xE003CCD0; // type:data rom:0x350190
 D_E003CCF8 = 0xE003CCF8; // type:data rom:0x3501B8
 D_E003CD1C = 0xE003CD1C; // type:data rom:0x3501DC
+D_09000000_350220 = 0x9000000; // type:data rom:0x350220
+D_09000200_350420 = 0x9000200; // type:data rom:0x350420
+D_09000400_350620 = 0x9000400; // type:data rom:0x350620
+D_09000600_350820 = 0x9000600; // type:data rom:0x350820
+D_09000800_350A20 = 0x9000800; // type:data rom:0x350A20
+D_09000A00_350C20 = 0x9000A00; // type:data rom:0x350C20
+D_09000C00_350E20 = 0x9000C00; // type:data rom:0x350E20
+D_09000E00_351020 = 0x9000E00; // type:data rom:0x351020
+D_09001000_351220 = 0x9001000; // type:data rom:0x351220
+D_09001200_351420 = 0x9001200; // type:data rom:0x351420
+D_09001400_351620 = 0x9001400; // type:data rom:0x351620
+D_09001600_351820 = 0x9001600; // type:data rom:0x351820
+D_09001800_351A20 = 0x9001800; // type:data rom:0x351A20
+D_09001A00_351C20 = 0x9001A00; // type:data rom:0x351C20
+D_09001C00_351E20 = 0x9001C00; // type:data rom:0x351E20
+D_09001C10_351E30 = 0x9001C10; // type:data rom:0x351E30
+D_09001C30_351E50 = 0x9001C30; // type:data rom:0x351E50
+D_09001C40_351E60 = 0x9001C40; // type:data rom:0x351E60
+D_09001C80_351EA0 = 0x9001C80; // type:data rom:0x351EA0
+D_09001CC0_351EE0 = 0x9001CC0; // type:data rom:0x351EE0
+D_09001D00_351F20 = 0x9001D00; // type:data rom:0x351F20
+D_09001D40_351F60 = 0x9001D40; // type:data rom:0x351F60
+D_09001DE0_352000 = 0x9001DE0; // type:data rom:0x352000
+D_09001E50_352070 = 0x9001E50; // type:data rom:0x352070
+D_09001E90_3520B0 = 0x9001E90; // type:data rom:0x3520B0
+D_09001ED0_3520F0 = 0x9001ED0; // type:data rom:0x3520F0
+D_09001F10_352130 = 0x9001F10; // type:data rom:0x352130
+D_09001F50_352170 = 0x9001F50; // type:data rom:0x352170
+D_09001F90_3521B0 = 0x9001F90; // type:data rom:0x3521B0
+D_09001FD0_3521F0 = 0x9001FD0; // type:data rom:0x3521F0
+D_09002010_352230 = 0x9002010; // type:data rom:0x352230
+D_09002050_352270 = 0x9002050; // type:data rom:0x352270
+D_09002090_3522B0 = 0x9002090; // type:data rom:0x3522B0
+D_090020D0_3522F0 = 0x90020D0; // type:data rom:0x3522F0
+D_09002110_352330 = 0x9002110; // type:data rom:0x352330
+D_09002150_352370 = 0x9002150; // type:data rom:0x352370
+D_09002160_352380 = 0x9002160; // type:data rom:0x352380
+D_09002170_352390 = 0x9002170; // type:data rom:0x352390
+D_09002180_3523A0 = 0x9002180; // type:data rom:0x3523A0
+D_09002190_3523B0 = 0x9002190; // type:data rom:0x3523B0
+D_090021A8_3523C8 = 0x90021A8; // type:data rom:0x3523C8
+D_090021C0_3523E0 = 0x90021C0; // type:data rom:0x3523E0
+D_090021E0_352400 = 0x90021E0; // type:data rom:0x352400
+D_09002200_352420 = 0x9002200; // type:data rom:0x352420
 purple_ring_main = 0xE003E000; // type:func rom:0x352440
 purple_ring_init = 0xE003E3F8; // type:func rom:0x352838
 purple_ring_update = 0xE003E400; // type:func rom:0x352840
@@ -7766,6 +8339,13 @@ big_snowflakes_render = 0xE006040C; // type:func rom:0x36356C
 big_snowflakes_appendGfx = 0xE0060450; // type:func rom:0x3635B0
 D_E0060730 = 0xE0060730; // type:data rom:0x363890
 D_E0060738 = 0xE0060738; // type:data rom:0x363898
+D_09000000_3638C0 = 0x9000000; // type:data rom:0x3638C0
+D_09000080_363940 = 0x9000080; // type:data rom:0x363940
+D_09000880_364140 = 0x9000880; // type:data rom:0x364140
+D_090008C0_364180 = 0x90008C0; // type:data rom:0x364180
+D_09000900_3641C0 = 0x9000900; // type:data rom:0x3641C0
+D_090009E8_3642A8 = 0x90009E8; // type:data rom:0x3642A8
+D_09000A10_3642D0 = 0x9000A10; // type:data rom:0x3642D0
 debuff_main = 0xE0062000; // type:func rom:0x364300
 debuff_init = 0xE0062218; // type:func rom:0x364518
 debuff_update = 0xE0062220; // type:func rom:0x364520
@@ -7773,6 +8353,10 @@ debuff_render = 0xE00624A8; // type:func rom:0x3647A8
 debuff_appendGfx = 0xE00624EC; // type:func rom:0x3647EC
 D_E00628C0 = 0xE00628C0; // type:data rom:0x364BC0
 D_E00628C4 = 0xE00628C4; // type:data rom:0x364BC4
+D_09000000_364C00 = 0x9000000; // type:data rom:0x364C00
+D_09000200_364E00 = 0x9000200; // type:data rom:0x364E00
+D_09000240_364E40 = 0x9000240; // type:data rom:0x364E40
+D_090002E8_364EE8 = 0x90002E8; // type:data rom:0x364EE8
 green_impact_main = 0xE0064000; // type:func rom:0x364F10
 green_impact_init = 0xE006419C; // type:func rom:0x3650AC
 green_impact_update = 0xE00641A4; // type:func rom:0x3650B4
@@ -7883,6 +8467,42 @@ func_E00826C4 = 0xE00826C4; // type:func rom:0x385D04
 func_E00828B4 = 0xE00828B4; // type:func rom:0x385EF4
 func_E0082A84 = 0xE0082A84; // type:func rom:0x3860C4
 D_E0082D00 = 0xE0082D00; // type:data rom:0x386340
+D_09000000_3863B0 = 0x9000000; // type:data rom:0x3863B0
+D_09000200_3865B0 = 0x9000200; // type:data rom:0x3865B0
+D_09000400_3867B0 = 0x9000400; // type:data rom:0x3867B0
+D_09000600_3869B0 = 0x9000600; // type:data rom:0x3869B0
+D_09000800_386BB0 = 0x9000800; // type:data rom:0x386BB0
+D_09000A00_386DB0 = 0x9000A00; // type:data rom:0x386DB0
+D_09000C00_386FB0 = 0x9000C00; // type:data rom:0x386FB0
+D_09000E00_3871B0 = 0x9000E00; // type:data rom:0x3871B0
+D_09001000_3873B0 = 0x9001000; // type:data rom:0x3873B0
+D_09001200_3875B0 = 0x9001200; // type:data rom:0x3875B0
+D_09001400_3877B0 = 0x9001400; // type:data rom:0x3877B0
+D_09001600_3879B0 = 0x9001600; // type:data rom:0x3879B0
+D_09001800_387BB0 = 0x9001800; // type:data rom:0x387BB0
+D_09002000_3883B0 = 0x9002000; // type:data rom:0x3883B0
+D_09002040_3883F0 = 0x9002040; // type:data rom:0x3883F0
+D_09002080_388430 = 0x9002080; // type:data rom:0x388430
+D_090020C0_388470 = 0x90020C0; // type:data rom:0x388470
+D_09002100_3884B0 = 0x9002100; // type:data rom:0x3884B0
+D_09002198_388548 = 0x9002198; // type:data rom:0x388548
+D_09002230_3885E0 = 0x9002230; // type:data rom:0x3885E0
+D_09002250_388600 = 0x9002250; // type:data rom:0x388600
+D_09002270_388620 = 0x9002270; // type:data rom:0x388620
+D_09002290_388640 = 0x9002290; // type:data rom:0x388640
+D_090022B0_388660 = 0x90022B0; // type:data rom:0x388660
+D_09002320_3886D0 = 0x9002320; // type:data rom:0x3886D0
+D_09002360_388710 = 0x9002360; // type:data rom:0x388710
+D_090023A0_388750 = 0x90023A0; // type:data rom:0x388750
+D_090023E0_388790 = 0x90023E0; // type:data rom:0x388790
+D_09002420_3887D0 = 0x9002420; // type:data rom:0x3887D0
+D_09002460_388810 = 0x9002460; // type:data rom:0x388810
+D_090024A0_388850 = 0x90024A0; // type:data rom:0x388850
+D_090024E0_388890 = 0x90024E0; // type:data rom:0x388890
+D_09002520_3888D0 = 0x9002520; // type:data rom:0x3888D0
+D_09002560_388910 = 0x9002560; // type:data rom:0x388910
+D_090025A0_388950 = 0x90025A0; // type:data rom:0x388950
+D_090025E0_388990 = 0x90025E0; // type:data rom:0x388990
 func_E0084000 = 0xE0084000; // type:func rom:0x3889D0
 func_E008403C = 0xE008403C; // type:func rom:0x388A0C
 func_E0084060 = 0xE0084060; // type:func rom:0x388A30
@@ -7950,6 +8570,19 @@ small_gold_sparkle_init = 0xE00921AC; // type:func rom:0x391EDC
 small_gold_sparkle_update = 0xE00921B4; // type:func rom:0x391EE4
 small_gold_sparkle_render = 0xE0092258; // type:func rom:0x391F88
 small_gold_sparkle_appendGfx = 0xE00922A0; // type:func rom:0x391FD0
+D_09000000_392440 = 0x9000000; // type:data rom:0x392440
+D_09000080_3924C0 = 0x9000080; // type:data rom:0x3924C0
+D_09000100_392540 = 0x9000100; // type:data rom:0x392540
+D_09000180_3925C0 = 0x9000180; // type:data rom:0x3925C0
+D_09000200_392640 = 0x9000200; // type:data rom:0x392640
+D_09000280_3926C0 = 0x9000280; // type:data rom:0x3926C0
+D_090002C0_392700 = 0x90002C0; // type:data rom:0x392700
+D_09000330_392770 = 0x9000330; // type:data rom:0x392770
+D_09000370_3927B0 = 0x9000370; // type:data rom:0x3927B0
+D_090003B0_3927F0 = 0x90003B0; // type:data rom:0x3927F0
+D_090003F0_392830 = 0x90003F0; // type:data rom:0x392830
+D_09000430_392870 = 0x9000430; // type:data rom:0x392870
+D_09000470_3928B0 = 0x9000470; // type:data rom:0x3928B0
 flashing_box_shockwave_main = 0xE0094000; // type:func rom:0x3928D0
 flashing_box_shockwave_init = 0xE0094190; // type:func rom:0x392A60
 flashing_box_shockwave_update = 0xE0094198; // type:func rom:0x392A68
@@ -8038,6 +8671,42 @@ butterflies_render = 0xE00AA3C0; // type:func rom:0x3AACE0
 butterflies_appendGfx = 0xE00AA404; // type:func rom:0x3AAD24
 D_E00AA6C0 = 0xE00AA6C0; // type:data rom:0x3AAFE0
 D_E00AA6EC = 0xE00AA6EC; // type:data rom:0x3AB00C
+D_09000000_3AB030 = 0x9000000; // type:data rom:0x3AB030
+D_09000400_3AB430 = 0x9000400; // type:data rom:0x3AB430
+D_09000420_3AB450 = 0x9000420; // type:data rom:0x3AB450
+D_09000820_3AB850 = 0x9000820; // type:data rom:0x3AB850
+D_09000840_3AB870 = 0x9000840; // type:data rom:0x3AB870
+D_09000C40_3ABC70 = 0x9000C40; // type:data rom:0x3ABC70
+D_09000C50_3ABC80 = 0x9000C50; // type:data rom:0x3ABC80
+D_09001050_3AC080 = 0x9001050; // type:data rom:0x3AC080
+D_09001070_3AC0A0 = 0x9001070; // type:data rom:0x3AC0A0
+D_09001470_3AC4A0 = 0x9001470; // type:data rom:0x3AC4A0
+D_09001480_3AC4B0 = 0x9001480; // type:data rom:0x3AC4B0
+D_09001880_3AC8B0 = 0x9001880; // type:data rom:0x3AC8B0
+D_090018A0_3AC8D0 = 0x90018A0; // type:data rom:0x3AC8D0
+D_09001CA0_3ACCD0 = 0x9001CA0; // type:data rom:0x3ACCD0
+D_09001CC0_3ACCF0 = 0x9001CC0; // type:data rom:0x3ACCF0
+D_090020C0_3AD0F0 = 0x90020C0; // type:data rom:0x3AD0F0
+D_090020E0_3AD110 = 0x90020E0; // type:data rom:0x3AD110
+D_090024E0_3AD510 = 0x90024E0; // type:data rom:0x3AD510
+D_09002500_3AD530 = 0x9002500; // type:data rom:0x3AD530
+D_09002900_3AD930 = 0x9002900; // type:data rom:0x3AD930
+D_09002920_3AD950 = 0x9002920; // type:data rom:0x3AD950
+D_09002D20_3ADD50 = 0x9002D20; // type:data rom:0x3ADD50
+D_09002D40_3ADD70 = 0x9002D40; // type:data rom:0x3ADD70
+D_09003880_3AE8B0 = 0x9003880; // type:data rom:0x3AE8B0
+D_090038F8_3AE928 = 0x90038F8; // type:data rom:0x3AE928
+D_09003968_3AE998 = 0x9003968; // type:data rom:0x3AE998
+D_090039D8_3AEA08 = 0x90039D8; // type:data rom:0x3AEA08
+D_09003A48_3AEA78 = 0x9003A48; // type:data rom:0x3AEA78
+D_09003AB8_3AEAE8 = 0x9003AB8; // type:data rom:0x3AEAE8
+D_09003B28_3AEB58 = 0x9003B28; // type:data rom:0x3AEB58
+D_09003B98_3AEBC8 = 0x9003B98; // type:data rom:0x3AEBC8
+D_09003C08_3AEC38 = 0x9003C08; // type:data rom:0x3AEC38
+D_09003C78_3AECA8 = 0x9003C78; // type:data rom:0x3AECA8
+D_09003CE8_3AED18 = 0x9003CE8; // type:data rom:0x3AED18
+D_09003D58_3AED88 = 0x9003D58; // type:data rom:0x3AED88
+D_09003DC8_3AEDF8 = 0x9003DC8; // type:data rom:0x3AEDF8
 stat_change_main = 0xE00AC000; // type:func rom:0x3AEE20
 stat_change_init = 0xE00AC11C; // type:func rom:0x3AEF3C
 stat_change_update = 0xE00AC124; // type:func rom:0x3AEF44
@@ -8167,6 +8836,16 @@ throw_spiny_appendGfx = 0xE00C8454; // type:func rom:0x3CF7F4
 D_E00C8710 = 0xE00C8710; // type:data rom:0x3CFAB0
 D_E00C8718 = 0xE00C8718; // type:data rom:0x3CFAB8
 D_E00C8720 = 0xE00C8720; // type:data rom:0x3CFAC0
+D_09000000_3CFAF0 = 0x9000000; // type:data rom:0x3CFAF0
+D_09000200_3CFCF0 = 0x9000200; // type:data rom:0x3CFCF0
+D_09000220_3CFD10 = 0x9000220; // type:data rom:0x3CFD10
+D_09000400_3CFEF0 = 0x9000400; // type:data rom:0x3CFEF0
+D_09000600_3D00F0 = 0x9000600; // type:data rom:0x3D00F0
+D_09000620_3D0110 = 0x9000620; // type:data rom:0x3D0110
+D_09000800_3D02F0 = 0x9000800; // type:data rom:0x3D02F0
+D_090008D8_3D03C8 = 0x90008D8; // type:data rom:0x3D03C8
+D_090009B0_3D04A0 = 0x90009B0; // type:data rom:0x3D04A0
+D_090009F0_3D04E0 = 0x90009F0; // type:data rom:0x3D04E0
 fx_65_main = 0xE00CA000; // type:func rom:0x3D0500
 fx_65_init = 0xE00CA240; // type:func rom:0x3D0740
 fx_65_update = 0xE00CA248; // type:func rom:0x3D0748
@@ -8916,7 +9595,7 @@ b_area_kmr_part_3_kmr_05_UnkAngleFunc2 = 0x802194C0; // type:func rom:0x448900
 b_area_kmr_part_3_kmr_06_UnkAngleFunc2 = 0x80219730; // type:func rom:0x448B70
 b_area_kmr_part_3_kmr_06_UnkFogFunc = 0x80219998; // type:func rom:0x448DD8
 b_area_kmr_part_3_mim_01_UnkFogFunc2 = 0x802199E0; // type:func rom:0x448E20
-func_80219A40_448E80 = 0x80219A40; // type:func rom:0x448E80
+b_area_kmr_part_3_sam_01_UnkModelStuff_func1 = 0x80219A40; // type:func rom:0x448E80
 b_area_kmr_part_3_sam_01_Set80071270_0_16 = 0x80219C38; // type:func rom:0x449078
 b_area_kmr_part_3_sam_01_UnkFloatFunc2 = 0x80219C5C; // type:func rom:0x44909C
 func_80219D60_4491A0 = 0x80219D60; // type:func rom:0x4491A0
@@ -9168,11 +9847,11 @@ b_area_kmr_part_3_nok_01 = 0x80233640; // type:data rom:0x462A80
 b_area_kmr_part_3_mim_01_beforeBattle_80233670 = 0x80233670; // type:data rom:0x462AB0
 b_area_kmr_part_3_mim_01_afterBattle_8023369C = 0x8023369C; // type:data rom:0x462ADC
 b_area_kmr_part_3_mim_01 = 0x802336AC; // type:data rom:0x462AEC
-b_area_kmr_part_3_sam_01_D_802336E0_43AB20 = 0x802336E0; // type:data rom:0x462B20
-b_area_kmr_part_3_sam_01_802336F0 = 0x802336F0; // type:data rom:0x462B30
-b_area_kmr_part_3_sam_01_8023372C = 0x8023372C; // type:data rom:0x462B6C
-b_area_kmr_part_3_sam_01_802337F4 = 0x802337F4; // type:data rom:0x462C34
-b_area_kmr_part_3_sam_01_802338D4 = 0x802338D4; // type:data rom:0x462D14
+b_area_kmr_part_3_sam_01_UnkModelStuff_array = 0x802336E0; // type:data rom:0x462B20
+b_area_kmr_part_3_sam_01_UnkModelStuffScript1 = 0x802336F0; // type:data rom:0x462B30
+b_area_kmr_part_3_sam_01_UnkModelStuffScript2 = 0x8023372C; // type:data rom:0x462B6C
+b_area_kmr_part_3_sam_01_UnkModelStuffScript3 = 0x802337F4; // type:data rom:0x462C34
+b_area_kmr_part_3_sam_01_UnkModelStuffScript4 = 0x802338D4; // type:data rom:0x462D14
 b_area_kmr_part_3_sam_01_beforeBattle_80233998 = 0x80233998; // type:data rom:0x462DD8
 b_area_kmr_part_3_sam_01_afterBattle_80233AA8 = 0x80233AA8; // type:data rom:0x462EE8
 b_area_kmr_part_3_sam_01_foregroundModelList_80233AB8 = 0x80233AB8; // type:data rom:0x462EF8
@@ -11195,17 +11874,231 @@ b_area_omo_formation_2B = 0x802306C0; // type:data rom:0x52AC90
 b_area_omo_formation_2C = 0x80230714; // type:data rom:0x52ACE4
 b_area_omo_formationTable = 0x80230730; // type:data rom:0x52AD00
 b_area_omo_stageTable = 0x80230AC8; // type:data rom:0x52B098
-b_area_omo2_FadeBackgroundToBlack = 0x80218000; // type:func rom:0x52B6A0
-D_80231360 = 0x80231110; // type:data rom:0x52B6E0
-b_area_omo2_UnfadeBackgroundToBlack = 0x80218098; // type:func rom:0x52B738
-func_80218120_52B7C0 = 0x80218120; // type:func rom:0x52B7C0
+b_area_omo2_general_guy_FadeBackgroundToBlack = 0x80218000; // type:func rom:0x52B6A0
+D_80231110 = 0x80231110; // type:data rom:0x52B6E0
+b_area_omo2_general_guy_UnfadeBackgroundToBlack = 0x80218098; // type:func rom:0x52B738
+b_area_omo2_toy_tank_UpdateBulbGlow = 0x80218120; // type:func rom:0x52B7C0
 func_802181F4_52B894 = 0x802181F4; // type:func rom:0x52B894
 func_80218250_52B8F0 = 0x80218250; // type:func rom:0x52B8F0
+b_area_omo2_general_guy_defenseTable = 0x80218330; // type:data rom:0x52B9D0
+b_area_omo2_general_guy_statusTable = 0x8021833C; // type:data rom:0x52B9DC
+b_area_omo2_general_guy_parts = 0x802183E8; // type:data rom:0x52BA88
+b_area_omo2_general_guy = 0x80218430; // type:data rom:0x52BAD0
+b_area_omo2_general_guy_idleAnimations = 0x80218458; // type:data rom:0x52BAF8
+b_area_omo2_general_guy_idleAnimations_bomb = 0x802184B4; // type:data rom:0x52BB54
+b_area_omo2_general_guy_idleAnimations3 = 0x802184C0; // type:data rom:0x52BB60
+b_area_omo2_general_guy_nextTurn = 0x802184FC; // type:data rom:0x52BB9C
+b_area_omo2_general_guy_init = 0x8021858C; // type:data rom:0x52BC2C
+b_area_omo2_general_guy_idle = 0x802186B8; // type:data rom:0x52BD58
+b_area_omo2_general_guy_handleEvent = 0x802186EC; // type:data rom:0x52BD8C
+b_area_omo2_general_guy_takeTurn = 0x80218BA0; // type:data rom:0x52C240
+b_area_omo2_general_guy_attack_throw_bomb = 0x80218C8C; // type:data rom:0x52C32C
+b_area_omo2_general_guy_attack_lightning_shot = 0x8021963C; // type:data rom:0x52CCDC
+b_area_omo2_general_guy_summon_pos = 0x8021A278; // type:data rom:0x52D918
+b_area_omo2_general_guy_formation_shy_squad = 0x8021A284; // type:data rom:0x52D924
+b_area_omo2_toy_tank_8021A2A0 = 0x8021A2A0; // type:data rom:0x52D940
+b_area_omo2_toy_tank_8021A2CC = 0x8021A2CC; // type:data rom:0x52D96C
+b_area_omo2_toy_tank_8021A2F8 = 0x8021A2F8; // type:data rom:0x52D998
+b_area_omo2_toy_tank_8021A324 = 0x8021A324; // type:data rom:0x52D9C4
+b_area_omo2_toy_tank_8021A350 = 0x8021A350; // type:data rom:0x52D9F0
+b_area_omo2_toy_tank_8021A37C = 0x8021A37C; // type:data rom:0x52DA1C
+b_area_omo2_toy_tank_8021A3A8 = 0x8021A3A8; // type:data rom:0x52DA48
+b_area_omo2_toy_tank_8021A3D4 = 0x8021A3D4; // type:data rom:0x52DA74
+b_area_omo2_toy_tank_8021A400 = 0x8021A400; // type:data rom:0x52DAA0
+b_area_omo2_toy_tank_8021A42C = 0x8021A42C; // type:data rom:0x52DACC
+b_area_omo2_toy_tank_8021A458 = 0x8021A458; // type:data rom:0x52DAF8
+b_area_omo2_toy_tank_8021A484 = 0x8021A484; // type:data rom:0x52DB24
+b_area_omo2_toy_tank_8021A4B0 = 0x8021A4B0; // type:data rom:0x52DB50
+b_area_omo2_toy_tank_8021A4DC = 0x8021A4DC; // type:data rom:0x52DB7C
+b_area_omo2_toy_tank_8021A508 = 0x8021A508; // type:data rom:0x52DBA8
+b_area_omo2_toy_tank_8021A534 = 0x8021A534; // type:data rom:0x52DBD4
+b_area_omo2_toy_tank_8021A560 = 0x8021A560; // type:data rom:0x52DC00
+b_area_omo2_toy_tank_8021A58C = 0x8021A58C; // type:data rom:0x52DC2C
+b_area_omo2_toy_tank_8021A5B8 = 0x8021A5B8; // type:data rom:0x52DC58
+b_area_omo2_toy_tank_8021A5E4 = 0x8021A5E4; // type:data rom:0x52DC84
+b_area_omo2_toy_tank_8021A610 = 0x8021A610; // type:data rom:0x52DCB0
+b_area_omo2_toy_tank_8021A63C = 0x8021A63C; // type:data rom:0x52DCDC
+b_area_omo2_toy_tank_8021A668 = 0x8021A668; // type:data rom:0x52DD08
+b_area_omo2_toy_tank_8021A694 = 0x8021A694; // type:data rom:0x52DD34
+toy_tank_model = 0x8021A6C0; // type:data rom:0x52DD60
+toy_tank_as_shake = 0x8021A724; // type:data rom:0x52DDC4
+toy_tank_as_fall_apart = 0x8021D318; // type:data rom:0x5309B8
+toy_tank_as_close_hatch = 0x8021E798; // type:data rom:0x531E38
+toy_tank_as_open_hatch = 0x80220D88; // type:data rom:0x534428
+toy_tank_as_5 = 0x80221384; // type:data rom:0x534A24
+toy_tank_as_move_forward = 0x80222A98; // type:data rom:0x536138
+toy_tank_as_7 = 0x8022AE48; // type:data rom:0x53E4E8
+toy_tank_as_idle = 0x8022C55C; // type:data rom:0x53FBFC
+b_area_omo2_toy_tank_defenseTable = 0x8022C838; // type:data rom:0x53FED8
+b_area_omo2_toy_tank_statusTable = 0x8022C844; // type:data rom:0x53FEE4
+b_area_omo2_toy_tank_parts = 0x8022C8F0; // type:data rom:0x53FF90
+b_area_omo2_toy_tank = 0x8022C95C; // type:data rom:0x53FFFC
+b_area_omo2_toy_tank_init = 0x8022C984; // type:data rom:0x540024
+b_area_omo2_toy_tank_idle = 0x8022CC38; // type:data rom:0x5402D8
+b_area_omo2_toy_tank_handleEvent = 0x8022CE5C; // type:data rom:0x5404FC
+b_area_omo2_toy_tank_takeTurn = 0x8022D228; // type:data rom:0x5408C8
+b_area_omo2_toy_tank_onHit = 0x8022D238; // type:data rom:0x5408D8
+b_area_omo2_toy_tank_shake_tank = 0x8022D5B8; // type:data rom:0x540C58
+b_area_omo2_toy_tank_select_phase = 0x8022D5E8; // type:data rom:0x540C88
+b_area_omo2_toy_tank_update_phase = 0x8022DB10; // type:data rom:0x5411B0
+b_area_omo2_toy_tank_start_stilt_guys_phase = 0x8022DBA0; // type:data rom:0x541240
+b_area_omo2_toy_tank_start_shy_stack_phase = 0x8022DEA8; // type:data rom:0x541548
+b_area_omo2_toy_tank_summon_stilt_guys = 0x8022E3DC; // type:data rom:0x541A7C
+b_area_omo2_toy_tank_summon_tank_squad = 0x8022E734; // type:data rom:0x541DD4
+b_area_omo2_toy_tank_start_battle_with_tank = 0x8022EB80; // type:data rom:0x542220
+b_area_omo2_toy_tank_onDeath = 0x8022ED80; // type:data rom:0x542420
+b_area_omo2_toy_tank_8022F2BC = 0x8022F2BC; // type:data rom:0x54295C
+b_area_omo2_toy_tank_8022F458 = 0x8022F458; // type:data rom:0x542AF8
+b_area_omo2_toy_tank_8022F4D0 = 0x8022F4D0; // type:data rom:0x542B70
+b_area_omo2_toy_tank_summon_pos = 0x8022F548; // type:data rom:0x542BE8
+b_area_omo2_toy_tank_formation_signal_guy = 0x8022F554; // type:data rom:0x542BF4
+b_area_omo2_toy_tank_formation_stilt_guy_1 = 0x8022F570; // type:data rom:0x542C10
+b_area_omo2_toy_tank_formation_stilt_guy_2 = 0x8022F58C; // type:data rom:0x542C2C
+b_area_omo2_toy_tank_formation_shy_stack_1 = 0x8022F5A8; // type:data rom:0x542C48
+b_area_omo2_toy_tank_formation_shy_stack_2 = 0x8022F5C4; // type:data rom:0x542C64
+b_area_omo2_toy_tank_formation_shy_squad_dup = 0x8022F5E0; // type:data rom:0x542C80
+b_area_omo2_light_bulb_defenseTable = 0x8022F600; // type:data rom:0x542CA0
+b_area_omo2_light_bulb_statusTable = 0x8022F614; // type:data rom:0x542CB4
+b_area_omo2_light_bulb_parts = 0x8022F6C0; // type:data rom:0x542D60
+b_area_omo2_light_bulb = 0x8022F6E4; // type:data rom:0x542D84
+b_area_omo2_light_bulb_init = 0x8022F70C; // type:data rom:0x542DAC
+b_area_omo2_light_bulb_idle = 0x8022F774; // type:data rom:0x542E14
+b_area_omo2_light_bulb_handleEvent = 0x8022F7A8; // type:data rom:0x542E48
+b_area_omo2_light_bulb_takeTurn = 0x8022F9C8; // type:data rom:0x543068
+b_area_omo2_light_bulb_onHit = 0x8022F9D8; // type:data rom:0x543078
+b_area_omo2_light_bulb_shake_tank = 0x8022F9F4; // type:data rom:0x543094
+b_area_omo2_light_bulb_onDeath = 0x8022FA54; // type:data rom:0x5430F4
+b_area_omo2_omo_07_beforeBattle = 0x8022FB20; // type:data rom:0x5431C0
+b_area_omo2_omo_07_afterBattle = 0x8022FB5C; // type:data rom:0x5431FC
+b_area_omo2_omo_07 = 0x8022FB6C; // type:data rom:0x54320C
+b_area_omo2_formation_01 = 0x8022FBA0; // type:data rom:0x543240
+b_area_omo2_formationTable = 0x8022FBF4; // type:data rom:0x543294
+b_area_omo2_stageTable = 0x8022FC1C; // type:data rom:0x5432BC
 b_area_omo2_1_shy_squad_GetActorPartSize = 0x80231000; // type:func rom:0x543570
-b_area_omo2_2_GetSelectedMoveID = 0x80231000; // type:func rom:0x5483E0
-func_8023102C_54840C = 0x8023102C; // type:func rom:0x54840C
-b_area_omo2_2_UnkBattleFunc1 = 0x80231054; // type:func rom:0x548434
+b_area_omo2_1_shy_squad_defenseTable = 0x802310B0; // type:data rom:0x543620
+b_area_omo2_1_shy_squad_statusTable = 0x802310BC; // type:data rom:0x54362C
+b_area_omo2_1_shy_squad_parts = 0x80231168; // type:data rom:0x5436D8
+b_area_omo2_1_shy_squad = 0x802313A8; // type:data rom:0x543918
+b_area_omo2_1_shy_squad_idleAnimations = 0x802313D0; // type:data rom:0x543940
+b_area_omo2_1_shy_squad_init = 0x8023142C; // type:data rom:0x54399C
+b_area_omo2_1_shy_squad_nextTurn = 0x80232058; // type:data rom:0x5445C8
+b_area_omo2_1_shy_squad_idle = 0x80232454; // type:data rom:0x5449C4
+b_area_omo2_1_shy_squad_move_guy_to_pos = 0x80232488; // type:data rom:0x5449F8
+b_area_omo2_1_shy_squad_move_squad_to_home = 0x802325EC; // type:data rom:0x544B5C
+b_area_omo2_1_shy_squad_displace_last_guy = 0x802327E4; // type:data rom:0x544D54
+b_area_omo2_1_shy_squad_displace_guy = 0x80232810; // type:data rom:0x544D80
+b_area_omo2_1_shy_squad_onShock = 0x80233494; // type:data rom:0x545A04
+b_area_omo2_1_shy_squad_displace_guy_2 = 0x80233568; // type:data rom:0x545AD8
+b_area_omo2_1_shy_squad_handleEvent = 0x802337D0; // type:data rom:0x545D40
+b_area_omo2_1_shy_squad_onHit = 0x80233F38; // type:data rom:0x5464A8
+b_area_omo2_1_shy_squad_set_alive_guys_animation = 0x802343DC; // type:data rom:0x54694C
+b_area_omo2_1_shy_squad_kill_guy = 0x80234480; // type:data rom:0x5469F0
+b_area_omo2_1_shy_squad_onDeath = 0x8023465C; // type:data rom:0x546BCC
+b_area_omo2_1_shy_squad_attack = 0x802348E0; // type:data rom:0x546E50
+b_area_omo2_1_shy_squad_takeTurn = 0x80235468; // type:data rom:0x5479D8
+b_area_omo2_1_shy_squad_flee = 0x80235484; // type:data rom:0x5479F4
+b_area_omo2_1_shy_squad_next_phase = 0x80235D64; // type:data rom:0x5482D4
+b_area_omo2_1_shy_squad_updateActorSize = 0x80235D9C; // type:data rom:0x54830C
+b_area_omo2_2_stilt_guy_GetSelectedMoveID = 0x80231000; // type:func rom:0x5483E0
+SetActorLevelToZero = 0x8023102C; // type:func rom:0x54840C
+b_area_omo2_2_stilt_guy_UnkBattleFunc1 = 0x80231054; // type:func rom:0x548434
+b_area_omo2_2_stilt_guy_idleAnimations2 = 0x80231120; // type:data rom:0x548500
+b_area_omo2_2_stilt_guy_idleAnimations3 = 0x80231174; // type:data rom:0x548554
+b_area_omo2_2_stilt_guy_defenseTable2 = 0x80231180; // type:data rom:0x548560
+b_area_omo2_2_stilt_guy_defenseTable = 0x8023118C; // type:data rom:0x54856C
+b_area_omo2_2_stilt_guy_statusTable = 0x802311A0; // type:data rom:0x548580
+b_area_omo2_2_stilt_guy_statusTable2 = 0x8023124C; // type:data rom:0x54862C
+b_area_omo2_2_stilt_guy_parts = 0x802312F8; // type:data rom:0x5486D8
+b_area_omo2_2_stilt_guy = 0x80231418; // type:data rom:0x5487F8
+b_area_omo2_2_stilt_guy_init = 0x80231440; // type:data rom:0x548820
+b_area_omo2_2_stilt_guy_idle = 0x802322D0; // type:data rom:0x5496B0
+b_area_omo2_2_stilt_guy_return_home = 0x80232304; // type:data rom:0x5496E4
+b_area_omo2_2_stilt_guy_handleEvent = 0x8023239C; // type:data rom:0x54977C
+b_area_omo2_2_stilt_guy_check_fall_off = 0x80232A78; // type:data rom:0x549E58
+b_area_omo2_2_stilt_guy_check_fall_off_2 = 0x80232B84; // type:data rom:0x549F64
+b_area_omo2_2_stilt_guy_takeTurn = 0x80232C78; // type:data rom:0x54A058
+b_area_omo2_2_stilt_guy_attack = 0x80232C94; // type:data rom:0x54A074
+b_area_omo2_2_stilt_guy_fallOff = 0x802333A4; // type:data rom:0x54A784
+b_area_omo2_2_stilt_guy_onDeath = 0x8023379C; // type:data rom:0x54AB7C
+b_area_omo2_2_stilt_guy_shy_guy_rotate = 0x80233888; // type:data rom:0x54AC68
+b_area_omo2_2_stilt_guy_shy_guy_on_spin_smash = 0x80233918; // type:data rom:0x54ACF8
+b_area_omo2_2_stilt_guy_idleAnimations = 0x80233E98; // type:data rom:0x54B278
+b_area_omo2_2_stilt_guy_shy_guy_init = 0x80233EE4; // type:data rom:0x54B2C4
+b_area_omo2_2_stilt_guy_shy_guy_idle = 0x80233F30; // type:data rom:0x54B310
+b_area_omo2_2_stilt_guy_shy_guy_return_home = 0x80234040; // type:data rom:0x54B420
+b_area_omo2_2_stilt_guy_shy_guy_handleEvent = 0x802340A4; // type:data rom:0x54B484
+b_area_omo2_2_stilt_guy_shy_guy_attack1 = 0x80234580; // type:data rom:0x54B960
+b_area_omo2_2_stilt_guy_shy_guy_attack2 = 0x80234CA8; // type:data rom:0x54C088
+b_area_omo2_2_stilt_guy_shy_guy_takeTurn = 0x80235830; // type:data rom:0x54CC10
 func_80231000_54CC70 = 0x80231000; // type:func rom:0x54CC70
+b_area_omo2_3_shy_stack_defenseTable = 0x80231030; // type:data rom:0x54CCA0
+b_area_omo2_3_shy_stack_statusTable = 0x8023103C; // type:data rom:0x54CCAC
+b_area_omo2_3_shy_stack_parts = 0x802310E8; // type:data rom:0x54CD58
+b_area_omo2_3_shy_stack = 0x802312E0; // type:data rom:0x54CF50
+b_area_omo2_3_shy_stack_idleAnimations = 0x80231308; // type:data rom:0x54CF78
+b_area_omo2_3_shy_stack_idleAnimations2 = 0x80231364; // type:data rom:0x54CFD4
+b_area_omo2_3_shy_stack_idleAnimations3 = 0x802313C0; // type:data rom:0x54D030
+b_area_omo2_3_shy_stack_idleAnimations4 = 0x8023141C; // type:data rom:0x54D08C
+b_area_omo2_3_shy_stack_idleAnimations_rock = 0x80231478; // type:data rom:0x54D0E8
+b_area_omo2_3_shy_stack_idleAnimations_damage = 0x80231484; // type:data rom:0x54D0F4
+b_area_omo2_3_shy_stack_idleAnimations_shy_guy = 0x80231490; // type:data rom:0x54D100
+b_area_omo2_3_shy_stack_init = 0x8023149C; // type:data rom:0x54D10C
+b_area_omo2_3_shy_stack_idle = 0x80232FA0; // type:data rom:0x54EC10
+b_area_omo2_3_shy_stack_handleEvent = 0x80232FD4; // type:data rom:0x54EC44
+b_area_omo2_3_shy_stack_rotate = 0x80233BBC; // type:data rom:0x54F82C
+b_area_omo2_3_shy_stack_onSpinSmash = 0x80233C4C; // type:data rom:0x54F8BC
+b_area_omo2_3_shy_stack_doSpinSmashHitLastGuy = 0x80233D10; // type:data rom:0x54F980
+b_area_omo2_3_shy_stack_fall_apart = 0x80234280; // type:data rom:0x54FEF0
+b_area_omo2_3_shy_stack_lower_actor_pos = 0x8023476C; // type:data rom:0x5503DC
+b_area_omo2_3_shy_stack_doSpinSmashHit = 0x80234A90; // type:data rom:0x550700
+b_area_omo2_3_shy_stack_80235168 = 0x80235168; // type:data rom:0x550DD8
+b_area_omo2_3_shy_stack_takeTurn = 0x802357B4; // type:data rom:0x551424
+b_area_omo2_3_shy_stack_launch_rock = 0x80235D60; // type:data rom:0x5519D0
+b_area_omo2_3_shy_stack_onDeath = 0x80236468; // type:data rom:0x5520D8
+b_area_omo2_3_shy_stack_onSpinSmashLaunchDeath = 0x80236518; // type:data rom:0x552188
+b_area_omo2_4_signal_guy_defenseTable = 0x80231000; // type:data rom:0x552440
+b_area_omo2_4_signal_guy_statusTable = 0x8023100C; // type:data rom:0x55244C
+b_area_omo2_4_signal_guy_parts = 0x802310B8; // type:data rom:0x5524F8
+b_area_omo2_4_signal_guy = 0x802310DC; // type:data rom:0x55251C
+b_area_omo2_4_signal_guy_idleAnimations = 0x80231104; // type:data rom:0x552544
+b_area_omo2_4_signal_guy_init = 0x80231110; // type:data rom:0x552550
+b_area_omo2_4_signal_guy_idle = 0x8023129C; // type:data rom:0x5526DC
+b_area_omo2_4_signal_guy_handleEvent = 0x802312D0; // type:data rom:0x552710
+b_area_omo2_4_signal_guy_takeTurn = 0x80231754; // type:data rom:0x552B94
+b_area_omo2_5_shy_squad_dup_defenseTable = 0x80231000; // type:data rom:0x552BB0
+b_area_omo2_5_shy_squad_dup_statusTable = 0x8023100C; // type:data rom:0x552BBC
+b_area_omo2_5_shy_squad_dup_parts = 0x802310B8; // type:data rom:0x552C68
+b_area_omo2_5_shy_squad_dup = 0x802312F8; // type:data rom:0x552EA8
+b_area_omo2_5_shy_squad_dup_idleAnimations = 0x80231320; // type:data rom:0x552ED0
+b_area_omo2_5_shy_squad_dup_idleAnimations_watt = 0x80231334; // type:data rom:0x552EE4
+b_area_omo2_5_shy_squad_dup_init = 0x80231348; // type:data rom:0x552EF8
+b_area_omo2_5_shy_squad_dup_nextTurn = 0x80231FC8; // type:data rom:0x553B78
+b_area_omo2_5_shy_squad_dup_idle = 0x80231FD8; // type:data rom:0x553B88
+b_area_omo2_5_shy_squad_dup_move_guy_to_pos = 0x80232104; // type:data rom:0x553CB4
+b_area_omo2_5_shy_squad_dup_onSpinSmash = 0x80232268; // type:data rom:0x553E18
+b_area_omo2_5_shy_squad_dup_displace_guy = 0x8023233C; // type:data rom:0x553EEC
+b_area_omo2_5_shy_squad_dup_onShock = 0x80232FC0; // type:data rom:0x554B70
+b_area_omo2_5_shy_squad_dup_displace_guy_2 = 0x80233088; // type:data rom:0x554C38
+b_area_omo2_5_shy_squad_dup_handleEvent = 0x80233384; // type:data rom:0x554F34
+b_area_omo2_5_shy_squad_dup_onHit = 0x8023392C; // type:data rom:0x5554DC
+b_area_omo2_5_shy_squad_dup_set_squad_animation = 0x80233DA4; // type:data rom:0x555954
+b_area_omo2_5_shy_squad_dup_80233E48 = 0x80233E48; // type:data rom:0x5559F8
+b_area_omo2_5_shy_squad_dup_onDeath = 0x80234024; // type:data rom:0x555BD4
+b_area_omo2_5_shy_squad_dup_takeTurn = 0x802342A0; // type:data rom:0x555E50
+b_area_omo2_5_shy_squad_dup_next_phase = 0x80234370; // type:data rom:0x555F20
+b_area_omo2_5_shy_squad_dup_run_away = 0x802343A8; // type:data rom:0x555F58
+b_area_omo2_5_shy_squad_dup_attack = 0x80234624; // type:data rom:0x5561D4
+b_area_omo2_5_shy_squad_dup_run_squad_to_pos = 0x80234EC4; // type:data rom:0x556A74
+b_area_omo2_6_shy_guy_dup_defenseTable = 0x80231000; // type:data rom:0x556C90
+b_area_omo2_6_shy_guy_dup_statusTable = 0x8023100C; // type:data rom:0x556C9C
+b_area_omo2_6_shy_guy_dup_parts = 0x802310B8; // type:data rom:0x556D48
+b_area_omo2_6_shy_guy_dup = 0x802311FC; // type:data rom:0x556E8C
+b_area_omo2_6_shy_guy_dup_idleAnimations = 0x80231224; // type:data rom:0x556EB4
+b_area_omo2_6_shy_guy_dup_init = 0x80231280; // type:data rom:0x556F10
+b_area_omo2_6_shy_guy_dup_idle = 0x802315EC; // type:data rom:0x55727C
+b_area_omo2_6_shy_guy_dup_run_to_pos = 0x80231620; // type:data rom:0x5572B0
+b_area_omo2_6_shy_guy_dup_handleEvent = 0x8023172C; // type:data rom:0x5573BC
+b_area_omo2_6_shy_guy_dup_takeTurn = 0x8023173C; // type:data rom:0x5573CC
 func_80218000_5573E0 = 0x80218000; // type:func rom:0x5573E0
 func_80218038_557418 = 0x80218038; // type:func rom:0x557418
 func_80218070_557450 = 0x80218070; // type:func rom:0x557450
@@ -11592,28 +12485,28 @@ b_area_kzn_medi_guy_flyingAttack = 0x80220210; // type:data rom:0x594500
 b_area_kzn_medi_guy_healOneAlly = 0x802209F8; // type:data rom:0x594CE8
 b_area_kzn_medi_guy_80220CEC = 0x80220CEC; // type:data rom:0x594FDC
 b_area_kzn_medi_guy_takeTurn_80220DCC = 0x80220DCC; // type:data rom:0x5950BC
-b_area_kzn_red_magikoopa_defenseTable_80220E60 = 0x80220E60; // type:data rom:0x595150
-b_area_kzn_red_magikoopa_defenseTable_80220E6C = 0x80220E6C; // type:data rom:0x59515C
-b_area_kzn_red_magikoopa_statusTable_80220E78 = 0x80220E78; // type:data rom:0x595168
-b_area_kzn_red_magikoopa_statusTable_80220F24 = 0x80220F24; // type:data rom:0x595214
-b_area_kzn_red_magikoopa_partsTable_80220FD0 = 0x80220FD0; // type:data rom:0x5952C0
-b_area_kzn_red_magikoopa_partsTable_80220FF4 = 0x80220FF4; // type:data rom:0x5952E4
+b_area_kzn_red_magikoopa_8022C120 = 0x80220E60; // type:data rom:0x595150
+b_area_kzn_red_magikoopa_8022C12C = 0x80220E6C; // type:data rom:0x59515C
+b_area_kzn_red_magikoopa_8022C138 = 0x80220E78; // type:data rom:0x595168
+b_area_kzn_red_magikoopa_8022C1E4 = 0x80220F24; // type:data rom:0x595214
+b_area_kzn_red_magikoopa_parts = 0x80220FD0; // type:data rom:0x5952C0
+b_area_kzn_red_magikoopa_8022C2B4 = 0x80220FF4; // type:data rom:0x5952E4
 b_area_kzn_red_magikoopa = 0x80221060; // type:data rom:0x595350
 b_area_kzn_red_magikoopa_flying = 0x80221088; // type:data rom:0x595378
-b_area_kzn_red_magikoopa_idleAnimations_802210B0 = 0x802210B0; // type:data rom:0x5953A0
-b_area_kzn_red_magikoopa_idleAnimations_802210FC = 0x802210FC; // type:data rom:0x5953EC
-b_area_kzn_red_magikoopa_idleAnimations_80221148 = 0x80221148; // type:data rom:0x595438
-b_area_kzn_red_magikoopa_idle_80221154 = 0x80221154; // type:data rom:0x595444
-b_area_kzn_red_magikoopa_handleEvent_80221164 = 0x80221164; // type:data rom:0x595454
-b_area_kzn_red_magikoopa_8022167C = 0x8022167C; // type:data rom:0x59596C
-b_area_kzn_red_magikoopa_80221788 = 0x80221788; // type:data rom:0x595A78
-b_area_kzn_red_magikoopa_handleEvent_80221D84 = 0x80221D84; // type:data rom:0x596074
-b_area_kzn_red_magikoopa_rMagikoopa_ShapeSpell = 0x802223E8; // type:data rom:0x5966D8
-b_area_kzn_red_magikoopa_rMagikoopa_WandStrike = 0x80222A04; // type:data rom:0x596CF4
-b_area_kzn_red_magikoopa_run_away = 0x80223074; // type:data rom:0x597364
-b_area_kzn_red_magikoopa_init_80223298 = 0x80223298; // type:data rom:0x597588
-b_area_kzn_red_magikoopa_init_8022333C = 0x8022333C; // type:data rom:0x59762C
-b_area_kzn_red_magikoopa_takeTurn_802233E0 = 0x802233E0; // type:data rom:0x5976D0
+b_area_kzn_red_magikoopa_8022C370 = 0x802210B0; // type:data rom:0x5953A0
+b_area_kzn_red_magikoopa_8022C3BC = 0x802210FC; // type:data rom:0x5953EC
+b_area_kzn_red_magikoopa_8022C408 = 0x80221148; // type:data rom:0x595438
+b_area_kzn_red_magikoopa_8022C414 = 0x80221154; // type:data rom:0x595444
+b_area_kzn_red_magikoopa_8022C424 = 0x80221164; // type:data rom:0x595454
+b_area_kzn_red_magikoopa_8022C93C = 0x8022167C; // type:data rom:0x59596C
+b_area_kzn_red_magikoopa_8022CA48 = 0x80221788; // type:data rom:0x595A78
+b_area_kzn_red_magikoopa_8022D044 = 0x80221D84; // type:data rom:0x596074
+b_area_kzn_red_magikoopa_8022D6A8 = 0x802223E8; // type:data rom:0x5966D8
+b_area_kzn_red_magikoopa_8022DCC4 = 0x80222A04; // type:data rom:0x596CF4
+b_area_kzn_red_magikoopa_8022E334 = 0x80223074; // type:data rom:0x597364
+b_area_kzn_red_magikoopa_8022E558 = 0x80223298; // type:data rom:0x597588
+b_area_kzn_red_magikoopa_8022E5FC = 0x8022333C; // type:data rom:0x59762C
+b_area_kzn_red_magikoopa_8022E6A0 = 0x802233E0; // type:data rom:0x5976D0
 b_area_kzn_white_magikoopa_defenseTable_80223B20 = 0x80223B20; // type:data rom:0x597E10
 b_area_kzn_white_magikoopa_defenseTable_80223B2C = 0x80223B2C; // type:data rom:0x597E1C
 b_area_kzn_white_magikoopa_statusTable_80223B38 = 0x80223B38; // type:data rom:0x597E28
@@ -11836,50 +12729,307 @@ dup2_b_area_tik3_UnkFunc56 = 0x80218C50; // type:func rom:0x619340
 func_802190F0_6197E0 = 0x802190F0; // type:func rom:0x6197E0
 b_area_tik3_UpdateTexturePanSmooth = 0x80219540; // type:func rom:0x619C30
 b_area_tik3_UpdateTexturePanStepped = 0x80219664; // type:func rom:0x619D54
-b_area_sam_UnkFunc62 = 0x80218000; // type:func rom:0x623BA0
-b_area_sam_ActorJumpToPos = 0x80218890; // type:func rom:0x624430
-b_area_sam_UnkActorSizeFunc = 0x802189E4; // type:func rom:0x624584
-b_area_sam_UnkEffect6CFunc = 0x80218A90; // type:func rom:0x624630
-func_80218AF4_624694 = 0x80218AF4; // type:func rom:0x624694
-func_80218B2C_6246CC = 0x80218B2C; // type:func rom:0x6246CC
-b_area_sam_UnkBattleFunc1 = 0x80218B74; // type:func rom:0x624714
-b_area_sam_UnkActorPosFunc = 0x80218C40; // type:func rom:0x6247E0
-dup_b_area_sam_UnkActorPosFunc = 0x80218D64; // type:func rom:0x624904
-func_80218E88_624A28 = 0x80218E88; // type:func rom:0x624A28
-func_80219304_624EA4 = 0x80219304; // type:func rom:0x624EA4
-func_80219358_624EF8 = 0x80219358; // type:func rom:0x624EF8
-func_802193A4_624F44 = 0x802193A4; // type:func rom:0x624F44
-func_802193F0_624F90 = 0x802193F0; // type:func rom:0x624F90
-b_area_sam_UnkBackgroundFunc3 = 0x8021943C; // type:func rom:0x624FDC
-b_area_sam_SetBackgroundAlpha = 0x80219480; // type:func rom:0x625020
-func_802194B8_625058 = 0x802194B8; // type:func rom:0x625058
-func_80219524_6250C4 = 0x80219524; // type:func rom:0x6250C4
-dup_b_area_sam_UnkBattleFunc1 = 0x802195F0; // type:func rom:0x625190
-b_area_sam_UnkEffect6FFunc = 0x802196BC; // type:func rom:0x62525C
-b_area_sam_ShrinkActor = 0x80219840; // type:func rom:0x6253E0
-b_area_sam_GetSelectedMoveID = 0x80219998; // type:func rom:0x625538
-dup2_b_area_sam_UnkBattleFunc1 = 0x802199C4; // type:func rom:0x625564
-b_area_sam_StartRumbleWithParams = 0x80219A90; // type:func rom:0x625630
-b_area_sam_UnkFunc52 = 0x80219AE8; // type:func rom:0x625688
-func_80219BB0_625750 = 0x80219BB0; // type:func rom:0x625750
-b_area_sam_Set80071270_0_16 = 0x80219DA8; // type:func rom:0x625948
-b_area_sam_UnkFloatFunc2 = 0x80219DCC; // type:func rom:0x62596C
-func_80219ED0_625A70 = 0x80219ED0; // type:func rom:0x625A70
-dup_b_area_sam_Set80071270_0_16 = 0x8021A0C8; // type:func rom:0x625C68
-dup_b_area_sam_UnkFloatFunc2 = 0x8021A0EC; // type:func rom:0x625C8C
-func_8021A1F0_625D90 = 0x8021A1F0; // type:func rom:0x625D90
-dup2_b_area_sam_Set80071270_0_16 = 0x8021A3E8; // type:func rom:0x625F88
-dup2_b_area_sam_UnkFloatFunc2 = 0x8021A40C; // type:func rom:0x625FAC
-func_8021A510_6260B0 = 0x8021A510; // type:func rom:0x6260B0
-dup3_b_area_sam_Set80071270_0_16 = 0x8021A708; // type:func rom:0x6262A8
-dup3_b_area_sam_UnkFloatFunc2 = 0x8021A72C; // type:func rom:0x6262CC
-func_8021A830_6263D0 = 0x8021A830; // type:func rom:0x6263D0
-dup4_b_area_sam_Set80071270_0_16 = 0x8021AA28; // type:func rom:0x6265C8
-dup4_b_area_sam_UnkFloatFunc2 = 0x8021AA4C; // type:func rom:0x6265EC
-func_8021AB50_6266F0 = 0x8021AB50; // type:func rom:0x6266F0
-dup5_b_area_sam_Set80071270_0_16 = 0x8021AD48; // type:func rom:0x6268E8
-dup5_b_area_sam_UnkFloatFunc2 = 0x8021AD6C; // type:func rom:0x62690C
+b_area_sam_duplighost_UnkFunc62 = 0x80218000; // type:func rom:0x623BA0
+b_area_sam_duplighost_ActorJumpToPos = 0x80218890; // type:func rom:0x624430
+b_area_sam_duplighost_UnkActorSizeFunc = 0x802189E4; // type:func rom:0x624584
+b_area_sam_duplighost_UnkEffect6CFunc = 0x80218A90; // type:func rom:0x624630
+b_area_sam_duplighost_UnkTattleEffectFunc1 = 0x80218AF4; // type:func rom:0x624694
+b_area_sam_duplighost_UnkTattleEffectFunc2 = 0x80218B2C; // type:func rom:0x6246CC
+b_area_sam_duplighost_UnkBattleFunc1 = 0x80218B74; // type:func rom:0x624714
+b_area_sam_duplighost_kooper_UnkActorPosFunc = 0x80218C40; // type:func rom:0x6247E0
+b_area_sam_duplighost_UnkActorPosFunc = 0x80218D64; // type:func rom:0x624904
+b_area_sam_duplighost_UnkWattEffectFunc1 = 0x80218E88; // type:func rom:0x624A28
+b_area_sam_duplighost_UnkWattEffectFunc2 = 0x80219304; // type:func rom:0x624EA4
+b_area_sam_duplighost_UnkWattEffectFunc3 = 0x80219358; // type:func rom:0x624EF8
+b_area_sam_duplighost_UnkWattEffectFunc4 = 0x802193A4; // type:func rom:0x624F44
+b_area_sam_duplighost_UnkWattEffectFunc5 = 0x802193F0; // type:func rom:0x624F90
+b_area_sam_duplighost_UnkBackgroundFunc3 = 0x8021943C; // type:func rom:0x624FDC
+b_area_sam_duplighost_SetBackgroundAlpha = 0x80219480; // type:func rom:0x625020
+b_area_sam_duplighost_GetPartnerAndLevel = 0x802194B8; // type:func rom:0x625058
+b_area_sam_duplighost_CopyPriority = 0x80219524; // type:func rom:0x6250C4
+b_area_sam_frost_piranha_UnkBattleFunc1 = 0x802195F0; // type:func rom:0x625190
+b_area_sam_frost_piranha_UnkEffect6FFunc = 0x802196BC; // type:func rom:0x62525C
+b_area_sam_gray_magikoopa_ShrinkActor = 0x80219840; // type:func rom:0x6253E0
+b_area_sam_gray_magikoopa_GetSelectedMoveID = 0x80219998; // type:func rom:0x625538
+b_area_sam_gray_magikoopa_UnkBattleFunc1 = 0x802199C4; // type:func rom:0x625564
+b_area_sam_gray_magikoopa_StartRumbleWithParams = 0x80219A90; // type:func rom:0x625630
+b_area_sam_gray_magikoopa_UnkFunc52 = 0x80219AE8; // type:func rom:0x625688
+b_area_sam_sam_01_UnkModelStuff_func1 = 0x80219BB0; // type:func rom:0x625750
+b_area_sam_sam_01_Set80071270_0_16 = 0x80219DA8; // type:func rom:0x625948
+b_area_sam_sam_01_UnkFloatFunc2 = 0x80219DCC; // type:func rom:0x62596C
+b_area_sam_sam_02_UnkModelStuff_func1 = 0x80219ED0; // type:func rom:0x625A70
+b_area_sam_sam_02_Set80071270_0_16 = 0x8021A0C8; // type:func rom:0x625C68
+b_area_sam_sam_02_UnkFloatFunc2 = 0x8021A0EC; // type:func rom:0x625C8C
+b_area_sam_sam_02b_UnkModelStuff_func1 = 0x8021A1F0; // type:func rom:0x625D90
+b_area_sam_sam_02b_Set80071270_0_16 = 0x8021A3E8; // type:func rom:0x625F88
+b_area_sam_sam_02b_UnkFloatFunc2 = 0x8021A40C; // type:func rom:0x625FAC
+b_area_sam_sam_02c_UnkModelStuff_func1 = 0x8021A510; // type:func rom:0x6260B0
+b_area_sam_sam_02c_Set80071270_0_16 = 0x8021A708; // type:func rom:0x6262A8
+b_area_sam_sam_02c_UnkFloatFunc2 = 0x8021A72C; // type:func rom:0x6262CC
+b_area_sam_sam_02d_UnkModelStuff_func1 = 0x8021A830; // type:func rom:0x6263D0
+b_area_sam_sam_02d_Set80071270_0_16 = 0x8021AA28; // type:func rom:0x6265C8
+b_area_sam_sam_02d_UnkFloatFunc2 = 0x8021AA4C; // type:func rom:0x6265EC
+b_area_sam_sam_03_UnkModelStuff_func1 = 0x8021AB50; // type:func rom:0x6266F0
+b_area_sam_sam_03_Set80071270_0_16 = 0x8021AD48; // type:func rom:0x6268E8
+b_area_sam_sam_03_UnkFloatFunc2 = 0x8021AD6C; // type:func rom:0x62690C
 func_8021AE70_626A10 = 0x8021AE70; // type:func rom:0x626A10
+b_area_sam_duplighost_idleAnimations = 0x8021AE90; // type:data rom:0x626A30
+b_area_sam_duplighost_idleAnimations2 = 0x8021AEDC; // type:data rom:0x626A7C
+b_area_sam_duplighost_idleAnimations3 = 0x8021AEE8; // type:data rom:0x626A88
+b_area_sam_duplighost_defenseTable = 0x8021AEF4; // type:data rom:0x626A94
+b_area_sam_duplighost_statusTable = 0x8021AF00; // type:data rom:0x626AA0
+b_area_sam_duplighost_parts = 0x8021AFAC; // type:data rom:0x626B4C
+b_area_sam_duplighost = 0x8021AFD0; // type:data rom:0x626B70
+b_area_sam_duplighost_init = 0x8021AFF8; // type:data rom:0x626B98
+b_area_sam_duplighost_nextTurn = 0x8021B070; // type:data rom:0x626C10
+b_area_sam_duplighost_idle = 0x8021B110; // type:data rom:0x626CB0
+b_area_sam_duplighost_returnHome = 0x8021B120; // type:data rom:0x626CC0
+b_area_sam_duplighost_handleEvent = 0x8021B15C; // type:data rom:0x626CFC
+b_area_sam_duplighost_attack = 0x8021B65C; // type:data rom:0x6271FC
+b_area_sam_duplighost_OnDeath = 0x8021BBFC; // type:data rom:0x62779C
+b_area_sam_duplighost_OnHitElectric = 0x8021BC34; // type:data rom:0x6277D4
+b_area_sam_duplighost_OnShockHit = 0x8021C0F8; // type:data rom:0x627C98
+b_area_sam_duplighost_OnShockDeath = 0x8021C784; // type:data rom:0x628324
+b_area_sam_duplighost_pos_summon = 0x8021CAE8; // type:data rom:0x628688
+b_area_sam_duplighost_goombario_idleAnimations = 0x8021CAF4; // type:data rom:0x628694
+b_area_sam_duplighost_goombario_defenseTable = 0x8021CB40; // type:data rom:0x6286E0
+b_area_sam_duplighost_goombario_statusTable = 0x8021CB4C; // type:data rom:0x6286EC
+b_area_sam_duplighost_goombario_parts = 0x8021CBF8; // type:data rom:0x628798
+b_area_sam_duplighost_goombario = 0x8021CC1C; // type:data rom:0x6287BC
+b_area_sam_duplighost_goombario_init = 0x8021CC44; // type:data rom:0x6287E4
+b_area_sam_duplighost_goombario_idle = 0x8021CC90; // type:data rom:0x628830
+b_area_sam_duplighost_goombario_handleEvent = 0x8021CCA0; // type:data rom:0x628840
+b_area_sam_duplighost_goombario_returnBack = 0x8021D210; // type:data rom:0x628DB0
+b_area_sam_duplighost_goombario_runToPlayer = 0x8021D698; // type:data rom:0x629238
+b_area_sam_duplighost_goombario_8021C7FC = 0x8021D77C; // type:data rom:0x62931C
+b_area_sam_duplighost_goombario_attack = 0x8021D864; // type:data rom:0x629404
+b_area_sam_duplighost_goombario_tattle = 0x8021E2F0; // type:data rom:0x629E90
+b_area_sam_duplighost_goombario_takeTurn = 0x8021E604; // type:data rom:0x62A1A4
+b_area_sam_duplighost_formation_goombario = 0x8021E660; // type:data rom:0x62A200
+b_area_sam_duplighost_kooper_idleAnimations = 0x8021E67C; // type:data rom:0x62A21C
+b_area_sam_duplighost_kooper_idleAnimations2 = 0x8021E6C8; // type:data rom:0x62A268
+b_area_sam_duplighost_kooper_defenseTable = 0x8021E714; // type:data rom:0x62A2B4
+b_area_sam_duplighost_kooper_defenseTable2 = 0x8021E720; // type:data rom:0x62A2C0
+b_area_sam_duplighost_kooper_statusTable = 0x8021E72C; // type:data rom:0x62A2CC
+b_area_sam_duplighost_kooper_parts = 0x8021E7D8; // type:data rom:0x62A378
+b_area_sam_duplighost_kooper = 0x8021E7FC; // type:data rom:0x62A39C
+b_area_sam_duplighost_kooper_init = 0x8021E824; // type:data rom:0x62A3C4
+b_area_sam_duplighost_kooper_idle = 0x8021E8A0; // type:data rom:0x62A440
+b_area_sam_duplighost_kooper_dispOffsets = 0x8021E9C0; // type:data rom:0x62A560
+b_area_sam_duplighost_kooper_handleEvent = 0x8021EA18; // type:data rom:0x62A5B8
+b_area_sam_duplighost_kooper_takeTurn = 0x8021F374; // type:data rom:0x62AF14
+b_area_sam_duplighost_formation_kooper = 0x80220314; // type:data rom:0x62BEB4
+b_area_sam_duplighost_bombette_idleAnimations = 0x80220330; // type:data rom:0x62BED0
+b_area_sam_duplighost_bombette_defenseTable = 0x8022037C; // type:data rom:0x62BF1C
+b_area_sam_duplighost_bombette_statusTable = 0x80220388; // type:data rom:0x62BF28
+b_area_sam_duplighost_bombette_parts = 0x80220434; // type:data rom:0x62BFD4
+b_area_sam_duplighost_bombette = 0x80220458; // type:data rom:0x62BFF8
+b_area_sam_duplighost_bombette_init = 0x80220480; // type:data rom:0x62C020
+b_area_sam_duplighost_bombette_idle = 0x802204CC; // type:data rom:0x62C06C
+b_area_sam_duplighost_bombette_playEffects = 0x802204DC; // type:data rom:0x62C07C
+b_area_sam_duplighost_bombette_handleEvent = 0x80220654; // type:data rom:0x62C1F4
+b_area_sam_duplighost_bombette_takeTurn = 0x80220CA0; // type:data rom:0x62C840
+b_area_sam_duplighost_formation_bombette = 0x80221574; // type:data rom:0x62D114
+b_area_sam_duplighost_parakarry_idleAnimations = 0x80221590; // type:data rom:0x62D130
+b_area_sam_duplighost_parakarry_defenseTable = 0x802215DC; // type:data rom:0x62D17C
+b_area_sam_duplighost_parakarry_statusTable = 0x802215E8; // type:data rom:0x62D188
+b_area_sam_duplighost_parakarry_parts = 0x80221694; // type:data rom:0x62D234
+b_area_sam_duplighost_parakarry = 0x802216DC; // type:data rom:0x62D27C
+b_area_sam_duplighost_parakarry_init = 0x80221704; // type:data rom:0x62D2A4
+b_area_sam_duplighost_parakarry_idle = 0x80221750; // type:data rom:0x62D2F0
+b_area_sam_duplighost_parakarry_handleEvent = 0x80221760; // type:data rom:0x62D300
+b_area_sam_duplighost_parakarry_doTakeTurn = 0x80221D54; // type:data rom:0x62D8F4
+b_area_sam_duplighost_parakarry_takeTurn = 0x802224E4; // type:data rom:0x62E084
+b_area_sam_duplighost_formation_parakarry = 0x80222500; // type:data rom:0x62E0A0
+b_area_sam_duplighost_bow_idleAnimations = 0x8022251C; // type:data rom:0x62E0BC
+b_area_sam_duplighost_bow_defenseTable = 0x80222568; // type:data rom:0x62E108
+b_area_sam_duplighost_bow_statusTable = 0x80222574; // type:data rom:0x62E114
+b_area_sam_duplighost_bow_parts = 0x80222620; // type:data rom:0x62E1C0
+b_area_sam_duplighost_bow = 0x80222668; // type:data rom:0x62E208
+b_area_sam_duplighost_bow_init = 0x80222690; // type:data rom:0x62E230
+b_area_sam_duplighost_bow_idle = 0x802226DC; // type:data rom:0x62E27C
+b_area_sam_duplighost_bow_handleEvent = 0x802226EC; // type:data rom:0x62E28C
+b_area_sam_duplighost_bow_takeTurn = 0x80222C7C; // type:data rom:0x62E81C
+b_area_sam_duplighost_formation_bow = 0x802238D0; // type:data rom:0x62F470
+b_area_sam_duplighost_watt_idleAnimations = 0x802238EC; // type:data rom:0x62F48C
+b_area_sam_duplighost_watt_defenseTable = 0x80223938; // type:data rom:0x62F4D8
+b_area_sam_duplighost_watt_statusTable = 0x8022394C; // type:data rom:0x62F4EC
+b_area_sam_duplighost_watt_parts = 0x802239F8; // type:data rom:0x62F598
+b_area_sam_duplighost_watt = 0x80223A40; // type:data rom:0x62F5E0
+b_area_sam_duplighost_watt_init = 0x80223A68; // type:data rom:0x62F608
+b_area_sam_duplighost_watt_idle = 0x80223AB4; // type:data rom:0x62F654
+b_area_sam_duplighost_watt_handleEvent = 0x80223ADC; // type:data rom:0x62F67C
+b_area_sam_duplighost_watt_takeTurn = 0x80223F50; // type:data rom:0x62FAF0
+b_area_sam_duplighost_formation_watt = 0x802247CC; // type:data rom:0x63036C
+b_area_sam_duplighost_sushie_idleAnimations = 0x802247E8; // type:data rom:0x630388
+b_area_sam_duplighost_sushie_defenseTable = 0x80224834; // type:data rom:0x6303D4
+b_area_sam_duplighost_sushie_statusTable = 0x80224840; // type:data rom:0x6303E0
+b_area_sam_duplighost_sushie_parts = 0x802248EC; // type:data rom:0x63048C
+b_area_sam_duplighost_sushie = 0x80224910; // type:data rom:0x6304B0
+b_area_sam_duplighost_sushie_init = 0x80224938; // type:data rom:0x6304D8
+b_area_sam_duplighost_sushie_idle = 0x80224984; // type:data rom:0x630524
+b_area_sam_duplighost_sushie_handleEvent = 0x80224994; // type:data rom:0x630534
+b_area_sam_duplighost_sushie_takeTurn = 0x80224F04; // type:data rom:0x630AA4
+b_area_sam_duplighost_formation_sushie = 0x80226164; // type:data rom:0x631D04
+b_area_sam_duplighost_lakilester_idleAnimations = 0x80226180; // type:data rom:0x631D20
+b_area_sam_duplighost_lakilester_idleAnimations2 = 0x802261CC; // type:data rom:0x631D6C
+b_area_sam_duplighost_lakilester_defenseTable = 0x802261D8; // type:data rom:0x631D78
+b_area_sam_duplighost_lakilester_statusTable = 0x802261E4; // type:data rom:0x631D84
+b_area_sam_duplighost_lakilester_parts = 0x80226290; // type:data rom:0x631E30
+b_area_sam_duplighost_lakilester = 0x802262D8; // type:data rom:0x631E78
+b_area_sam_duplighost_lakilester_init = 0x80226300; // type:data rom:0x631EA0
+b_area_sam_duplighost_lakilester_idle = 0x8022634C; // type:data rom:0x631EEC
+b_area_sam_duplighost_lakilester_handleEvent = 0x8022635C; // type:data rom:0x631EFC
+b_area_sam_duplighost_lakilester_takeTurn = 0x80226924; // type:data rom:0x6324C4
+b_area_sam_duplighost_formation_lakilester = 0x80227404; // type:data rom:0x632FA4
+b_area_sam_duplighost_copyPartner = 0x80227420; // type:data rom:0x632FC0
+b_area_sam_duplighost_takeTurn = 0x80227C40; // type:data rom:0x6337E0
+b_area_sam_gulpit_idleAnimations1 = 0x80227DD0; // type:data rom:0x633970
+b_area_sam_gulpit_idleAnimations2 = 0x80227E1C; // type:data rom:0x6339BC
+b_area_sam_gulpit_idleAnimations3 = 0x80227E28; // type:data rom:0x6339C8
+b_area_sam_gulpit_defenseTable = 0x80227E34; // type:data rom:0x6339D4
+b_area_sam_gulpit_statusTable = 0x80227E40; // type:data rom:0x6339E0
+b_area_sam_gulpit_parts = 0x80227EEC; // type:data rom:0x633A8C
+b_area_sam_gulpit = 0x80227F58; // type:data rom:0x633AF8
+b_area_sam_gulpit_init = 0x80227F80; // type:data rom:0x633B20
+b_area_sam_gulpit_idle = 0x80227FCC; // type:data rom:0x633B6C
+b_area_sam_gulpit_returnHome = 0x80227FDC; // type:data rom:0x633B7C
+b_area_sam_gulpit_handleEvent = 0x80228030; // type:data rom:0x633BD0
+b_area_sam_gulpit_attack_lick = 0x80228518; // type:data rom:0x6340B8
+b_area_sam_gulpit_attack_rock = 0x8022898C; // type:data rom:0x63452C
+b_area_sam_gulpit_takeTurn = 0x802291B4; // type:data rom:0x634D54
+b_area_sam_gulpit_rocks_idleAnimations = 0x802294D0; // type:data rom:0x635070
+b_area_sam_gulpit_rocks_idleAnimations2 = 0x802294DC; // type:data rom:0x63507C
+b_area_sam_gulpit_rocks_defenseTable = 0x802294E8; // type:data rom:0x635088
+b_area_sam_gulpit_rocks_statusTable = 0x802294F4; // type:data rom:0x635094
+b_area_sam_gulpit_rocks_parts = 0x802295A0; // type:data rom:0x635140
+b_area_sam_gulpit_rocks = 0x802295C4; // type:data rom:0x635164
+b_area_sam_gulpit_rocks_init = 0x802295EC; // type:data rom:0x63518C
+b_area_sam_gulpit_rocks_idle = 0x8022973C; // type:data rom:0x6352DC
+b_area_sam_gulpit_rocks_setAnim = 0x8022974C; // type:data rom:0x6352EC
+b_area_sam_gulpit_rocks_handleEvent = 0x802297B0; // type:data rom:0x635350
+b_area_sam_gulpit_rocks_takeTurn = 0x80229AAC; // type:data rom:0x63564C
+b_area_sam_white_clubba_idleAnimations = 0x80229AC0; // type:data rom:0x635660
+b_area_sam_white_clubba_defenseTable = 0x80229B0C; // type:data rom:0x6356AC
+b_area_sam_white_clubba_statusTable = 0x80229B28; // type:data rom:0x6356C8
+b_area_sam_white_clubba_parts = 0x80229BD4; // type:data rom:0x635774
+b_area_sam_white_clubba = 0x80229BF8; // type:data rom:0x635798
+b_area_sam_white_clubba_init = 0x80229C20; // type:data rom:0x6357C0
+b_area_sam_white_clubba_idle = 0x80229C6C; // type:data rom:0x63580C
+b_area_sam_white_clubba_handleEvent = 0x80229C7C; // type:data rom:0x63581C
+b_area_sam_white_clubba_takeTurn = 0x8022A18C; // type:data rom:0x635D2C
+b_area_sam_frost_piranha_idleAnimations = 0x8022AAB0; // type:data rom:0x636650
+b_area_sam_frost_piranha_defenseTable = 0x8022AAFC; // type:data rom:0x63669C
+b_area_sam_frost_piranha_statusTable = 0x8022AB18; // type:data rom:0x6366B8
+b_area_sam_frost_piranha_parts = 0x8022ABC4; // type:data rom:0x636764
+b_area_sam_frost_piranha = 0x8022ABE8; // type:data rom:0x636788
+b_area_sam_frost_piranha_init = 0x8022AC10; // type:data rom:0x6367B0
+b_area_sam_frost_piranha_idle = 0x8022AC5C; // type:data rom:0x6367FC
+b_area_sam_frost_piranha_return_home = 0x8022AD6C; // type:data rom:0x63690C
+b_area_sam_frost_piranha_handleEvent = 0x8022ADFC; // type:data rom:0x63699C
+b_area_sam_frost_piranha_takeTurn = 0x8022B2D4; // type:data rom:0x636E74
+b_area_sam_frost_piranha_attack_bite = 0x8022B3AC; // type:data rom:0x636F4C
+b_area_sam_frost_piranha_attack_icy_breath = 0x8022BD44; // type:data rom:0x6378E4
+b_area_sam_gray_magikoopa_defenseTable = 0x8022C310; // type:data rom:0x637EB0
+b_area_sam_gray_magikoopa_defenseTable_flying = 0x8022C31C; // type:data rom:0x637EBC
+b_area_sam_gray_magikoopa_statusTable = 0x8022C328; // type:data rom:0x637EC8
+b_area_sam_gray_magikoopa_statusTable_flying = 0x8022C3D4; // type:data rom:0x637F74
+b_area_sam_gray_magikoopa_parts = 0x8022C480; // type:data rom:0x638020
+b_area_sam_gray_magikoopa_parts_flying = 0x8022C4A4; // type:data rom:0x638044
+b_area_sam_gray_magikoopa = 0x8022C510; // type:data rom:0x6380B0
+b_area_sam_gray_magikoopa_flying = 0x8022C538; // type:data rom:0x6380D8
+b_area_sam_gray_magikoopa_idleAnimations1 = 0x8022C560; // type:data rom:0x638100
+b_area_sam_gray_magikoopa_idleAnimations2 = 0x8022C5AC; // type:data rom:0x63814C
+b_area_sam_gray_magikoopa_idleAnimations3 = 0x8022C5F8; // type:data rom:0x638198
+b_area_sam_gray_magikoopa_idle = 0x8022C604; // type:data rom:0x6381A4
+b_area_sam_gray_magikoopa_handleEvent = 0x8022C614; // type:data rom:0x6381B4
+b_area_sam_gray_magikoopa_canBeKnockedOff = 0x8022CB2C; // type:data rom:0x6386CC
+b_area_sam_gray_magikoopa_knockOff = 0x8022CC38; // type:data rom:0x6387D8
+b_area_sam_gray_magikoopa_handleEvent_flying = 0x8022D234; // type:data rom:0x638DD4
+b_area_sam_gray_magikoopa_attackMagicBlast = 0x8022D898; // type:data rom:0x639438
+b_area_sam_gray_magikoopa_attackWandStrike = 0x8022DEB4; // type:data rom:0x639A54
+b_area_sam_gray_magikoopa_flee = 0x8022E524; // type:data rom:0x63A0C4
+b_area_sam_gray_magikoopa_init = 0x8022E748; // type:data rom:0x63A2E8
+b_area_sam_gray_magikoopa_init_flying = 0x8022E7EC; // type:data rom:0x63A38C
+b_area_sam_gray_magikoopa_takeTurn = 0x8022E890; // type:data rom:0x63A430
+b_area_sam_sam_01_UnkModelStuff_array = 0x8022EFD0; // type:data rom:0x63AB70
+b_area_sam_sam_01_UnkModelStuffScript1 = 0x8022EFE0; // type:data rom:0x63AB80
+b_area_sam_sam_01_UnkModelStuffScript2 = 0x8022F01C; // type:data rom:0x63ABBC
+b_area_sam_sam_01_UnkModelStuffScript3 = 0x8022F0E4; // type:data rom:0x63AC84
+b_area_sam_sam_01_UnkModelStuffScript4 = 0x8022F1C4; // type:data rom:0x63AD64
+b_area_sam_sam_01_beforeBattle = 0x8022F288; // type:data rom:0x63AE28
+b_area_sam_sam_01_afterBattle = 0x8022F398; // type:data rom:0x63AF38
+b_area_sam_sam_01_foregroundModelList = 0x8022F3A8; // type:data rom:0x63AF48
+b_area_sam_sam_01 = 0x8022F3B4; // type:data rom:0x63AF54
+b_area_sam_sam_02_UnkModelStuff_array = 0x8022F3E0; // type:data rom:0x63AF80
+b_area_sam_sam_02_UnkModelStuffScript1 = 0x8022F3F0; // type:data rom:0x63AF90
+b_area_sam_sam_02_UnkModelStuffScript2 = 0x8022F42C; // type:data rom:0x63AFCC
+b_area_sam_sam_02_UnkModelStuffScript3 = 0x8022F4F4; // type:data rom:0x63B094
+b_area_sam_sam_02_UnkModelStuffScript4 = 0x8022F5D4; // type:data rom:0x63B174
+b_area_sam_sam_02_beforeBattle = 0x8022F698; // type:data rom:0x63B238
+b_area_sam_sam_02_afterBattle = 0x8022F7D0; // type:data rom:0x63B370
+b_area_sam_sam_02_foregroundModelList = 0x8022F7E0; // type:data rom:0x63B380
+b_area_sam_sam_02 = 0x8022F7EC; // type:data rom:0x63B38C
+b_area_sam_sam_02b_UnkModelStuff_array = 0x8022F820; // type:data rom:0x63B3C0
+b_area_sam_sam_02b_UnkModelStuffScript1 = 0x8022F830; // type:data rom:0x63B3D0
+b_area_sam_sam_02b_UnkModelStuffScript2 = 0x8022F86C; // type:data rom:0x63B40C
+b_area_sam_sam_02b_UnkModelStuffScript3 = 0x8022F934; // type:data rom:0x63B4D4
+b_area_sam_sam_02b_UnkModelStuffScript4 = 0x8022FA14; // type:data rom:0x63B5B4
+b_area_sam_sam_02b_beforeBattle = 0x8022FAD8; // type:data rom:0x63B678
+b_area_sam_sam_02b_afterBattle = 0x8022FB2C; // type:data rom:0x63B6CC
+b_area_sam_sam_02b_foregroundModelList = 0x8022FB3C; // type:data rom:0x63B6DC
+b_area_sam_sam_02b = 0x8022FB48; // type:data rom:0x63B6E8
+b_area_sam_sam_02c_UnkModelStuff_array = 0x8022FB70; // type:data rom:0x63B710
+b_area_sam_sam_02c_UnkModelStuffScript1 = 0x8022FB80; // type:data rom:0x63B720
+b_area_sam_sam_02c_UnkModelStuffScript2 = 0x8022FBBC; // type:data rom:0x63B75C
+b_area_sam_sam_02c_UnkModelStuffScript3 = 0x8022FC84; // type:data rom:0x63B824
+b_area_sam_sam_02c_UnkModelStuffScript4 = 0x8022FD64; // type:data rom:0x63B904
+b_area_sam_sam_02c_beforeBattle = 0x8022FE28; // type:data rom:0x63B9C8
+b_area_sam_sam_02c_afterBattle = 0x8022FE90; // type:data rom:0x63BA30
+b_area_sam_sam_02c_foregroundModelList = 0x8022FEA0; // type:data rom:0x63BA40
+b_area_sam_sam_02c = 0x8022FEAC; // type:data rom:0x63BA4C
+b_area_sam_sam_02d_UnkModelStuff_array = 0x8022FEE0; // type:data rom:0x63BA80
+b_area_sam_sam_02d_UnkModelStuffScript1 = 0x8022FEF0; // type:data rom:0x63BA90
+b_area_sam_sam_02d_UnkModelStuffScript2 = 0x8022FF2C; // type:data rom:0x63BACC
+b_area_sam_sam_02d_UnkModelStuffScript3 = 0x8022FFF4; // type:data rom:0x63BB94
+b_area_sam_sam_02d_UnkModelStuffScript4 = 0x802300D4; // type:data rom:0x63BC74
+b_area_sam_sam_02d_beforeBattle = 0x80230198; // type:data rom:0x63BD38
+b_area_sam_sam_02d_afterBattle = 0x80230214; // type:data rom:0x63BDB4
+b_area_sam_sam_02d_foregroundModelList = 0x80230224; // type:data rom:0x63BDC4
+b_area_sam_sam_02d = 0x80230230; // type:data rom:0x63BDD0
+b_area_sam_sam_03_UnkModelStuff_array = 0x80230260; // type:data rom:0x63BE00
+b_area_sam_sam_03_UnkModelStuffScript1 = 0x80230270; // type:data rom:0x63BE10
+b_area_sam_sam_03_UnkModelStuffScript2 = 0x802302AC; // type:data rom:0x63BE4C
+b_area_sam_sam_03_UnkModelStuffScript3 = 0x80230374; // type:data rom:0x63BF14
+b_area_sam_sam_03_UnkModelStuffScript4 = 0x80230454; // type:data rom:0x63BFF4
+b_area_sam_sam_03_beforeBattle = 0x80230518; // type:data rom:0x63C0B8
+b_area_sam_sam_03_afterBattle = 0x80230628; // type:data rom:0x63C1C8
+b_area_sam_sam_03_foregroundModelList = 0x80230638; // type:data rom:0x63C1D8
+b_area_sam_sam_03 = 0x80230644; // type:data rom:0x63C1E4
+b_area_sam_pos_rocks_1 = 0x80230670; // type:data rom:0x63C210
+b_area_sam_pos_rocks_2 = 0x802306AC; // type:data rom:0x63C24C
+b_area_sam_pos_rocks_3 = 0x802306E8; // type:data rom:0x63C288
+b_area_sam_pos_rocks_4 = 0x80230724; // type:data rom:0x63C2C4
+b_area_sam_pos_rocks_5 = 0x80230760; // type:data rom:0x63C300
+b_area_sam_pos_rocks_6 = 0x8023079C; // type:data rom:0x63C33C
+b_area_sam_pos_rocks_7 = 0x802307D8; // type:data rom:0x63C378
+b_area_sam_pos_rocks_8 = 0x80230814; // type:data rom:0x63C3B4
+b_area_sam_formation_01 = 0x80230850; // type:data rom:0x63C3F0
+b_area_sam_formation_02 = 0x80230888; // type:data rom:0x63C428
+b_area_sam_formation_03 = 0x8023094C; // type:data rom:0x63C4EC
+b_area_sam_formation_04 = 0x80230A2C; // type:data rom:0x63C5CC
+b_area_sam_formation_05 = 0x80230B0C; // type:data rom:0x63C6AC
+b_area_sam_formation_06 = 0x80230BEC; // type:data rom:0x63C78C
+b_area_sam_formation_07 = 0x80230CE8; // type:data rom:0x63C888
+b_area_sam_formation_08 = 0x80230D20; // type:data rom:0x63C8C0
+b_area_sam_formation_09 = 0x80230D90; // type:data rom:0x63C930
+b_area_sam_formation_0A = 0x80230E70; // type:data rom:0x63CA10
+b_area_sam_formation_0B = 0x80230F50; // type:data rom:0x63CAF0
+b_area_sam_formation_0C = 0x8023104C; // type:data rom:0x63CBEC
+b_area_sam_formation_0D = 0x80231084; // type:data rom:0x63CC24
+b_area_sam_formation_0E = 0x802310F4; // type:data rom:0x63CC94
+b_area_sam_formationTable = 0x80231164; // type:data rom:0x63CD04
+b_area_sam_stageTable = 0x80231290; // type:data rom:0x63CE30
 D_80231318_63CEB8 = 0x80231318; // type:data rom:0x63CEB8
 D_80231350_63CEF0 = 0x80231350; // type:data rom:0x63CEF0
 D_80231358_63CEF8 = 0x80231358; // type:data rom:0x63CEF8
@@ -11926,37 +13076,161 @@ D_80231624_63D1C4 = 0x80231624; // type:data rom:0x63D1C4
 D_8023162C_63D1CC = 0x8023162C; // type:data rom:0x63D1CC
 D_80231634_63D1D4 = 0x80231634; // type:data rom:0x63D1D4
 func_80218000_63D1E0 = 0x80218000; // type:func rom:0x63D1E0
-b_area_sam2_Dist3D = 0x80218314; // type:func rom:0x63D4F4
-b_area_sam2_UnkBackgroundFunc3 = 0x80218458; // type:func rom:0x63D638
-b_area_sam2_SetBackgroundAlpha = 0x8021849C; // type:func rom:0x63D67C
-b_area_sam2_StartRumbleWithParams = 0x802184D4; // type:func rom:0x63D6B4
-dup_b_area_sam2_StartRumbleWithParams = 0x80218530; // type:func rom:0x63D710
-b_area_sam2_ArcsinDeg = 0x80218588; // type:func rom:0x63D768
-b_area_sam2_CalculateRotationZ = 0x80218714; // type:func rom:0x63D8F4
-b_area_sam2_ShrinkActor = 0x80218810; // type:func rom:0x63D9F0
-b_area_sam2_GetSelectedMoveID = 0x80218968; // type:func rom:0x63DB48
-b_area_sam2_UnkBattleFunc1 = 0x80218994; // type:func rom:0x63DB74
-dup2_b_area_sam2_StartRumbleWithParams = 0x80218A60; // type:func rom:0x63DC40
-b_area_sam2_UnkFunc52 = 0x80218AB8; // type:func rom:0x63DC98
-func_80218B80_63DD60 = 0x80218B80; // type:func rom:0x63DD60
-b_area_sam2_Set80071270_0_16 = 0x80218D78; // type:func rom:0x63DF58
-b_area_sam2_UnkFloatFunc2 = 0x80218D9C; // type:func rom:0x63DF7C
-func_80218EA0_63E080 = 0x80218EA0; // type:func rom:0x63E080
-dup_b_area_sam2_Set80071270_0_16 = 0x80219098; // type:func rom:0x63E278
-dup_b_area_sam2_UnkFloatFunc2 = 0x802190BC; // type:func rom:0x63E29C
-func_802191C0_63E3A0 = 0x802191C0; // type:func rom:0x63E3A0
-dup2_b_area_sam2_Set80071270_0_16 = 0x802193B8; // type:func rom:0x63E598
-dup2_b_area_sam2_UnkFloatFunc2 = 0x802193DC; // type:func rom:0x63E5BC
-func_802194E0_63E6C0 = 0x802194E0; // type:func rom:0x63E6C0
-dup3_b_area_sam2_Set80071270_0_16 = 0x802196D8; // type:func rom:0x63E8B8
-dup3_b_area_sam2_UnkFloatFunc2 = 0x802196FC; // type:func rom:0x63E8DC
-func_80219800_63E9E0 = 0x80219800; // type:func rom:0x63E9E0
-dup4_b_area_sam2_Set80071270_0_16 = 0x802199F8; // type:func rom:0x63EBD8
-dup4_b_area_sam2_UnkFloatFunc2 = 0x80219A1C; // type:func rom:0x63EBFC
-func_80219B20_63ED00 = 0x80219B20; // type:func rom:0x63ED00
-dup5_b_area_sam2_Set80071270_0_16 = 0x80219D18; // type:func rom:0x63EEF8
-dup5_b_area_sam2_UnkFloatFunc2 = 0x80219D3C; // type:func rom:0x63EF1C
+b_area_sam2_monstar_Dist3D = 0x80218314; // type:func rom:0x63D4F4
+b_area_sam2_monstar_UnkBackgroundFunc3 = 0x80218458; // type:func rom:0x63D638
+b_area_sam2_monstar_SetBackgroundAlpha = 0x8021849C; // type:func rom:0x63D67C
+b_area_sam2_monstar_StartRumbleWithParams = 0x802184D4; // type:func rom:0x63D6B4
+b_area_sam2_paragoomba_StartRumbleWithParams = 0x80218530; // type:func rom:0x63D710
+b_area_sam2_paragoomba_ArcsinDeg = 0x80218588; // type:func rom:0x63D768
+b_area_sam2_paragoomba_CalculateRotationZ = 0x80218714; // type:func rom:0x63D8F4
+b_area_sam2_gray_magikoopa_ShrinkActor = 0x80218810; // type:func rom:0x63D9F0
+b_area_sam2_gray_magikoopa_GetSelectedMoveID = 0x80218968; // type:func rom:0x63DB48
+b_area_sam2_gray_magikoopa_UnkBattleFunc1 = 0x80218994; // type:func rom:0x63DB74
+b_area_sam2_gray_magikoopa_StartRumbleWithParams = 0x80218A60; // type:func rom:0x63DC40
+b_area_sam2_gray_magikoopa_UnkFunc52 = 0x80218AB8; // type:func rom:0x63DC98
+b_area_sam2_sam_01_UnkModelStuff_func1 = 0x80218B80; // type:func rom:0x63DD60
+b_area_sam2_sam_01_Set80071270_0_16 = 0x80218D78; // type:func rom:0x63DF58
+b_area_sam2_sam_01_UnkFloatFunc2 = 0x80218D9C; // type:func rom:0x63DF7C
+b_area_sam2_sam_02_UnkModelStuff_func1 = 0x80218EA0; // type:func rom:0x63E080
+b_area_sam2_sam_02_Set80071270_0_16 = 0x80219098; // type:func rom:0x63E278
+b_area_sam2_sam_02_UnkFloatFunc2 = 0x802190BC; // type:func rom:0x63E29C
+b_area_sam2_sam_02b_UnkModelStuff_func1 = 0x802191C0; // type:func rom:0x63E3A0
+b_area_sam2_sam_02b_Set80071270_0_16 = 0x802193B8; // type:func rom:0x63E598
+b_area_sam2_sam_02b_UnkFloatFunc2 = 0x802193DC; // type:func rom:0x63E5BC
+b_area_sam2_sam_02c_UnkModelStuff_func1 = 0x802194E0; // type:func rom:0x63E6C0
+b_area_sam2_sam_02c_Set80071270_0_16 = 0x802196D8; // type:func rom:0x63E8B8
+b_area_sam2_sam_02c_UnkFloatFunc2 = 0x802196FC; // type:func rom:0x63E8DC
+b_area_sam2_sam_02d_UnkModelStuff_func1 = 0x80219800; // type:func rom:0x63E9E0
+b_area_sam2_sam_02d_Set80071270_0_16 = 0x802199F8; // type:func rom:0x63EBD8
+b_area_sam2_sam_02d_UnkFloatFunc2 = 0x80219A1C; // type:func rom:0x63EBFC
+b_area_sam2_sam_03_UnkModelStuff_func1 = 0x80219B20; // type:func rom:0x63ED00
+b_area_sam2_sam_03_Set80071270_0_16 = 0x80219D18; // type:func rom:0x63EEF8
+b_area_sam2_sam_03_UnkFloatFunc2 = 0x80219D3C; // type:func rom:0x63EF1C
 func_80219E40_63F020 = 0x80219E40; // type:func rom:0x63F020
+b_area_sam2_monstar_defenseTable = 0x80219E60; // type:data rom:0x63F040
+b_area_sam2_monstar_statusTable = 0x80219E74; // type:data rom:0x63F054
+b_area_sam2_monstar_parts = 0x80219F20; // type:data rom:0x63F100
+b_area_sam2_monstar = 0x80219F68; // type:data rom:0x63F148
+b_area_sam2_monstar_idleAnimations = 0x80219F90; // type:data rom:0x63F170
+b_area_sam2_monstar_idleAnimations2 = 0x80219FE4; // type:data rom:0x63F1C4
+b_area_sam2_monstar_init = 0x80219FF0; // type:data rom:0x63F1D0
+battle_area_sam2_actor_img_png = 0x8021A098; // type:data rom:0x63F278
+battle_area_sam2_actor_img_pal = 0x8021A298; // type:data rom:0x63F478
+D_8021A2B8_63F498 = 0x8021A2B8; // type:data rom:0x63F498
+b_area_sam2_monstar_idle = 0x8021A2D0; // type:data rom:0x63F4B0
+b_area_sam2_monstar_handleEvent = 0x8021A4FC; // type:data rom:0x63F6DC
+b_area_sam2_monstar_unused = 0x8021A9BC; // type:data rom:0x63FB9C
+b_area_sam2_monstar_attack = 0x8021AB64; // type:data rom:0x63FD44
+b_area_sam2_monstar_nextTurn = 0x8021B384; // type:data rom:0x640564
+b_area_sam2_monstar_takeTurn = 0x8021B394; // type:data rom:0x640574
+b_area_sam2_monstar_OnDeath = 0x8021B55C; // type:data rom:0x64073C
+b_area_sam2_monstar_OnBurn = 0x8021B898; // type:data rom:0x640A78
+b_area_sam2_paragoomba_defenseTable_8021B110 = 0x8021BE90; // type:data rom:0x641070
+b_area_sam2_paragoomba_defenseTable_8021B11C = 0x8021BE9C; // type:data rom:0x64107C
+b_area_sam2_paragoomba_statusTable_8021B128 = 0x8021BEA8; // type:data rom:0x641088
+b_area_sam2_paragoomba_statusTable_8021B1D4 = 0x8021BF54; // type:data rom:0x641134
+b_area_sam2_paragoomba_partsTable_8021B280 = 0x8021C000; // type:data rom:0x6411E0
+b_area_sam2_paragoomba = 0x8021C090; // type:data rom:0x641270
+b_area_sam2_paragoomba_idleAnimations_8021B338 = 0x8021C0B8; // type:data rom:0x641298
+b_area_sam2_paragoomba_idleAnimations_8021B384 = 0x8021C104; // type:data rom:0x6412E4
+b_area_sam2_paragoomba_idleAnimations_8021B3D0 = 0x8021C150; // type:data rom:0x641330
+b_area_sam2_paragoomba_idleAnimations_8021B3DC = 0x8021C15C; // type:data rom:0x64133C
+b_area_sam2_paragoomba_init_8021B3E8 = 0x8021C168; // type:data rom:0x641348
+b_area_sam2_paragoomba_idle_8021B434 = 0x8021C1B4; // type:data rom:0x641394
+b_area_sam2_paragoomba_8021B6F0 = 0x8021C470; // type:data rom:0x641650
+b_area_sam2_paragoomba_handleEvent_8021B768 = 0x8021C4E8; // type:data rom:0x6416C8
+b_area_sam2_paragoomba_takeTurn_8021BD5C = 0x8021CADC; // type:data rom:0x641CBC
+b_area_sam2_paragoomba_8021C574 = 0x8021D2F4; // type:data rom:0x6424D4
+b_area_sam2_paragoomba_idleAnimations_8021CAFC = 0x8021D87C; // type:data rom:0x642A5C
+b_area_sam2_paragoomba_idleAnimations_8021CB48 = 0x8021D8C8; // type:data rom:0x642AA8
+b_area_sam2_paragoomba_8021CB94 = 0x8021D914; // type:data rom:0x642AF4
+b_area_sam2_paragoomba_idle_8021CBE0 = 0x8021D960; // type:data rom:0x642B40
+b_area_sam2_paragoomba_handleEvent_8021CEBC = 0x8021DC3C; // type:data rom:0x642E1C
+b_area_sam2_paragoomba_sinTable = 0x8021E2FC; // type:data rom:0x6434DC
+b_area_sam2_paragoomba_takeTurn_8021D6E8 = 0x8021E468; // type:data rom:0x643648
+b_area_sam2_gray_magikoopa_defenseTable = 0x8021F130; // type:data rom:0x644310
+b_area_sam2_gray_magikoopa_defenseTable_flying = 0x8021F13C; // type:data rom:0x64431C
+b_area_sam2_gray_magikoopa_statusTable = 0x8021F148; // type:data rom:0x644328
+b_area_sam2_gray_magikoopa_statusTable_flying = 0x8021F1F4; // type:data rom:0x6443D4
+b_area_sam2_gray_magikoopa_parts = 0x8021F2A0; // type:data rom:0x644480
+b_area_sam2_gray_magikoopa_parts_flying = 0x8021F2C4; // type:data rom:0x6444A4
+b_area_sam2_gray_magikoopa = 0x8021F330; // type:data rom:0x644510
+b_area_sam2_gray_magikoopa_flying = 0x8021F358; // type:data rom:0x644538
+b_area_sam2_gray_magikoopa_idleAnimations1 = 0x8021F380; // type:data rom:0x644560
+b_area_sam2_gray_magikoopa_idleAnimations2 = 0x8021F3CC; // type:data rom:0x6445AC
+b_area_sam2_gray_magikoopa_idleAnimations3 = 0x8021F418; // type:data rom:0x6445F8
+b_area_sam2_gray_magikoopa_idle = 0x8021F424; // type:data rom:0x644604
+b_area_sam2_gray_magikoopa_handleEvent = 0x8021F434; // type:data rom:0x644614
+b_area_sam2_gray_magikoopa_canBeKnockedOff = 0x8021F94C; // type:data rom:0x644B2C
+b_area_sam2_gray_magikoopa_knockOff = 0x8021FA58; // type:data rom:0x644C38
+b_area_sam2_gray_magikoopa_handleEvent_flying = 0x80220054; // type:data rom:0x645234
+b_area_sam2_gray_magikoopa_attackMagicBlast = 0x802206B8; // type:data rom:0x645898
+b_area_sam2_gray_magikoopa_attackWandStrike = 0x80220CD4; // type:data rom:0x645EB4
+b_area_sam2_gray_magikoopa_flee = 0x80221344; // type:data rom:0x646524
+b_area_sam2_gray_magikoopa_init = 0x80221568; // type:data rom:0x646748
+b_area_sam2_gray_magikoopa_init_flying = 0x8022160C; // type:data rom:0x6467EC
+b_area_sam2_gray_magikoopa_takeTurn = 0x802216B0; // type:data rom:0x646890
+b_area_sam2_sam_01_UnkModelStuff_array = 0x80221DF0; // type:data rom:0x646FD0
+b_area_sam2_sam_01_UnkModelStuffScript1 = 0x80221E00; // type:data rom:0x646FE0
+b_area_sam2_sam_01_UnkModelStuffScript2 = 0x80221E3C; // type:data rom:0x64701C
+b_area_sam2_sam_01_UnkModelStuffScript3 = 0x80221F04; // type:data rom:0x6470E4
+b_area_sam2_sam_01_UnkModelStuffScript4 = 0x80221FE4; // type:data rom:0x6471C4
+b_area_sam2_sam_01_beforeBattle = 0x802220A8; // type:data rom:0x647288
+b_area_sam2_sam_01_afterBattle = 0x802221B8; // type:data rom:0x647398
+b_area_sam2_sam_01_foregroundModelList = 0x802221C8; // type:data rom:0x6473A8
+b_area_sam2_sam_01 = 0x802221D4; // type:data rom:0x6473B4
+b_area_sam2_sam_02_UnkModelStuff_array = 0x80222200; // type:data rom:0x6473E0
+b_area_sam2_sam_02_UnkModelStuffScript1 = 0x80222210; // type:data rom:0x6473F0
+b_area_sam2_sam_02_UnkModelStuffScript2 = 0x8022224C; // type:data rom:0x64742C
+b_area_sam2_sam_02_UnkModelStuffScript3 = 0x80222314; // type:data rom:0x6474F4
+b_area_sam2_sam_02_UnkModelStuffScript4 = 0x802223F4; // type:data rom:0x6475D4
+b_area_sam2_sam_02_beforeBattle = 0x802224B8; // type:data rom:0x647698
+b_area_sam2_sam_02_afterBattle = 0x802225F0; // type:data rom:0x6477D0
+b_area_sam2_sam_02_foregroundModelList = 0x80222600; // type:data rom:0x6477E0
+b_area_sam2_sam_02 = 0x8022260C; // type:data rom:0x6477EC
+b_area_sam2_sam_02b_UnkModelStuff_array = 0x80222640; // type:data rom:0x647820
+b_area_sam2_sam_02b_UnkModelStuffScript1 = 0x80222650; // type:data rom:0x647830
+b_area_sam2_sam_02b_UnkModelStuffScript2 = 0x8022268C; // type:data rom:0x64786C
+b_area_sam2_sam_02b_UnkModelStuffScript3 = 0x80222754; // type:data rom:0x647934
+b_area_sam2_sam_02b_UnkModelStuffScript4 = 0x80222834; // type:data rom:0x647A14
+b_area_sam2_sam_02b_beforeBattle = 0x802228F8; // type:data rom:0x647AD8
+b_area_sam2_sam_02b_afterBattle = 0x8022294C; // type:data rom:0x647B2C
+b_area_sam2_sam_02b_foregroundModelList = 0x8022295C; // type:data rom:0x647B3C
+b_area_sam2_sam_02b = 0x80222968; // type:data rom:0x647B48
+b_area_sam2_sam_02c_UnkModelStuff_array = 0x80222990; // type:data rom:0x647B70
+b_area_sam2_sam_02c_UnkModelStuffScript1 = 0x802229A0; // type:data rom:0x647B80
+b_area_sam2_sam_02c_UnkModelStuffScript2 = 0x802229DC; // type:data rom:0x647BBC
+b_area_sam2_sam_02c_UnkModelStuffScript3 = 0x80222AA4; // type:data rom:0x647C84
+b_area_sam2_sam_02c_UnkModelStuffScript4 = 0x80222B84; // type:data rom:0x647D64
+b_area_sam2_sam_02c_beforeBattle = 0x80222C48; // type:data rom:0x647E28
+b_area_sam2_sam_02c_afterBattle = 0x80222CB0; // type:data rom:0x647E90
+b_area_sam2_sam_02c_foregroundModelList = 0x80222CC0; // type:data rom:0x647EA0
+b_area_sam2_sam_02c = 0x80222CCC; // type:data rom:0x647EAC
+b_area_sam2_sam_02d_UnkModelStuff_array = 0x80222D00; // type:data rom:0x647EE0
+b_area_sam2_sam_02d_UnkModelStuffScript1 = 0x80222D10; // type:data rom:0x647EF0
+b_area_sam2_sam_02d_UnkModelStuffScript2 = 0x80222D4C; // type:data rom:0x647F2C
+b_area_sam2_sam_02d_UnkModelStuffScript3 = 0x80222E14; // type:data rom:0x647FF4
+b_area_sam2_sam_02d_UnkModelStuffScript4 = 0x80222EF4; // type:data rom:0x6480D4
+b_area_sam2_sam_02d_beforeBattle = 0x80222FB8; // type:data rom:0x648198
+b_area_sam2_sam_02d_afterBattle = 0x80223034; // type:data rom:0x648214
+b_area_sam2_sam_02d_foregroundModelList = 0x80223044; // type:data rom:0x648224
+b_area_sam2_sam_02d = 0x80223050; // type:data rom:0x648230
+b_area_sam2_sam_03_UnkModelStuff_array = 0x80223080; // type:data rom:0x648260
+b_area_sam2_sam_03_UnkModelStuffScript1 = 0x80223090; // type:data rom:0x648270
+b_area_sam2_sam_03_UnkModelStuffScript2 = 0x802230CC; // type:data rom:0x6482AC
+b_area_sam2_sam_03_UnkModelStuffScript3 = 0x80223194; // type:data rom:0x648374
+b_area_sam2_sam_03_UnkModelStuffScript4 = 0x80223274; // type:data rom:0x648454
+b_area_sam2_sam_03_beforeBattle = 0x80223338; // type:data rom:0x648518
+b_area_sam2_sam_03_afterBattle = 0x80223448; // type:data rom:0x648628
+b_area_sam2_sam_03_foregroundModelList = 0x80223458; // type:data rom:0x648638
+b_area_sam2_sam_03 = 0x80223464; // type:data rom:0x648644
+b_area_sam2_80223490 = 0x80223490; // type:data rom:0x648670
+b_area_sam2_formation_01 = 0x8022349C; // type:data rom:0x64867C
+b_area_sam2_formation_02 = 0x802234B8; // type:data rom:0x648698
+b_area_sam2_formationTable = 0x802234F0; // type:data rom:0x6486D0
+b_area_sam2_stageTable = 0x8022352C; // type:data rom:0x64870C
+b_area_sam2_monstar_dlist = 0x80223570; // type:data rom:0x648750
+monstar_bubbles = 0x80223680; // type:data rom:0x648860
 b_area_pra_UnkBattleFunc1 = 0x80218000; // type:func rom:0x648E10
 b_area_pra_UnkBattleFunc2 = 0x802180CC; // type:func rom:0x648EDC
 b_area_pra_UnkBattleFunc2_2 = 0x80218180; // type:func rom:0x648F90
@@ -11988,50 +13262,336 @@ dup4_b_area_pra_StartRumbleWithParams = 0x80219310; // type:func rom:0x64A120
 dup4_b_area_pra_UnkFunc52 = 0x80219368; // type:func rom:0x64A178
 b_area_pra_GetBootsHammerLevel = 0x8021942C; // type:func rom:0x64A23C
 b_area_pra_UnkBattleFunc5 = 0x8021948C; // type:func rom:0x64A29C
-b_area_pra2_StartRumbleWithParams = 0x80218000; // type:func rom:0x660750
-b_area_pra2_UnkFloatFunc = 0x80218058; // type:func rom:0x6607A8
+b_area_pra2_crystal_king_StartRumbleWithParams = 0x80218000; // type:func rom:0x660750
+b_area_pra2_crystal_king_UnkFloatFunc = 0x80218058; // type:func rom:0x6607A8
 GetActorPartOpacity = 0x802181E8; // type:func rom:0x660938
 func_80218280_6609D0 = 0x80218280; // type:func rom:0x6609D0
 func_802182E4_660A34 = 0x802182E4; // type:func rom:0x660A34
 func_80218344_660A94 = 0x80218344; // type:func rom:0x660A94
 func_802183A4_660AF4 = 0x802183A4; // type:func rom:0x660AF4
 func_8021848C_660BDC = 0x8021848C; // type:func rom:0x660BDC
-func_802185D0_660D20 = 0x802185D0; // type:func rom:0x660D20
-func_802186C0_660E10 = 0x802186C0; // type:func rom:0x660E10
-b_area_pra2_Set80071270_0_16 = 0x802188B8; // type:func rom:0x661008
-b_area_pra2_UnkFloatFunc2 = 0x802188DC; // type:func rom:0x66102C
+UpdateCrystalBitEffect = 0x802185D0; // type:func rom:0x660D20
+b_area_pra2_sam_04_UnkModelStuff_func1 = 0x802186C0; // type:func rom:0x660E10
+b_area_pra2_sam_04_Set80071270_0_16 = 0x802188B8; // type:func rom:0x661008
+b_area_pra2_sam_04_UnkFloatFunc2 = 0x802188DC; // type:func rom:0x66102C
 func_802189E0_661130 = 0x802189E0; // type:func rom:0x661130
-b_area_pra3_UnkFunc62 = 0x80218000; // type:func rom:0x669D80
-b_area_pra3_ActorJumpToPos = 0x80218890; // type:func rom:0x66A610
-b_area_pra3_UnkActorSizeFunc = 0x802189E4; // type:func rom:0x66A764
-b_area_pra3_UnkEffect6CFunc = 0x80218A90; // type:func rom:0x66A810
-func_80218AF4_66A874 = 0x80218AF4; // type:func rom:0x66A874
-func_80218B2C_66A8AC = 0x80218B2C; // type:func rom:0x66A8AC
-dup2_b_area_pra3_UnkBattleFunc1 = 0x80218B74; // type:func rom:0x66A8F4
-func_80218C40_66A9C0 = 0x80218C40; // type:func rom:0x66A9C0
-b_area_pra3_UnkActorPosFunc = 0x80218D64; // type:func rom:0x66AAE4
-func_80218E88_66AC08 = 0x80218E88; // type:func rom:0x66AC08
-func_80219304_66B084 = 0x80219304; // type:func rom:0x66B084
-func_80219358_66B0D8 = 0x80219358; // type:func rom:0x66B0D8
-func_802193A4_66B124 = 0x802193A4; // type:func rom:0x66B124
-func_802193F0_66B170 = 0x802193F0; // type:func rom:0x66B170
-b_area_pra3_UnkBackgroundFunc3 = 0x8021943C; // type:func rom:0x66B1BC
-b_area_pra3_SetBackgroundAlpha = 0x80219480; // type:func rom:0x66B200
-func_802194B8_66B238 = 0x802194B8; // type:func rom:0x66B238
-func_80219524_66B2A4 = 0x80219524; // type:func rom:0x66B2A4
-dup3_b_area_pra3_UnkBattleFunc1 = 0x802195F0; // type:func rom:0x66B370
-b_area_pra3_UnkBattleFunc2 = 0x802196BC; // type:func rom:0x66B43C
-b_area_pra3_UnkBattleFunc2_2 = 0x80219770; // type:func rom:0x66B4F0
-b_area_pra3_ShrinkActor = 0x80219830; // type:func rom:0x66B5B0
-b_area_pra3_GetSelectedMoveID = 0x80219988; // type:func rom:0x66B708
-b_area_pra3_UnkBattleFunc1 = 0x802199B4; // type:func rom:0x66B734
-b_area_pra3_StartRumbleWithParams = 0x80219A80; // type:func rom:0x66B800
-b_area_pra3_UnkFunc52 = 0x80219AD8; // type:func rom:0x66B858
-dup_b_area_pra3_ShrinkActor = 0x80219BA0; // type:func rom:0x66B920
-dup_b_area_pra3_GetSelectedMoveID = 0x80219CF8; // type:func rom:0x66BA78
-dup_b_area_pra3_UnkBattleFunc1 = 0x80219D24; // type:func rom:0x66BAA4
-dup_b_area_pra3_StartRumbleWithParams = 0x80219DF0; // type:func rom:0x66BB70
-dup_b_area_pra3_UnkFunc52 = 0x80219E48; // type:func rom:0x66BBC8
+b_area_pra2_crystal_king_idleAnimations = 0x80218A00; // type:data rom:0x661150
+b_area_pra2_crystal_king_defenseTable = 0x80218A2C; // type:data rom:0x66117C
+b_area_pra2_crystal_king_statusTable = 0x80218A48; // type:data rom:0x661198
+b_area_pra2_crystal_king_parts = 0x80218AF4; // type:data rom:0x661244
+b_area_pra2_crystal_king = 0x80218B18; // type:data rom:0x661268
+b_area_pra2_crystal_king_init = 0x80218B40; // type:data rom:0x661290
+b_area_pra2_crystal_king_idle = 0x80218C4C; // type:data rom:0x66139C
+b_area_pra2_crystal_king_FlyWithClones = 0x80218E34; // type:data rom:0x661584
+b_area_pra2_crystal_king_RemoveClone = 0x80219270; // type:data rom:0x6619C0
+b_area_pra2_crystal_king_OnHit = 0x8021952C; // type:data rom:0x661C7C
+b_area_pra2_crystal_king_OnDeath = 0x80219B80; // type:data rom:0x6622D0
+b_area_pra2_crystal_king_handleEvent = 0x80219F30; // type:data rom:0x662680
+b_area_pra2_crystal_king_takeTurn = 0x8021AEEC; // type:data rom:0x66363C
+b_area_pra2_crystal_king_AttackIcyBreath = 0x8021B670; // type:data rom:0x663DC0
+b_area_pra2_crystal_king_AttackIceBolt = 0x8021BDBC; // type:data rom:0x66450C
+b_area_pra2_crystal_king_clone_statusTable = 0x8021C6DC; // type:data rom:0x664E2C
+b_area_pra2_crystal_king_clone_script = 0x8021C788; // type:data rom:0x664ED8
+b_area_pra2_crystal_king_clone_init = 0x8021C798; // type:data rom:0x664EE8
+b_area_pra2_crystal_king_clone = 0x8021C7E4; // type:data rom:0x664F34
+b_area_pra2_crystal_king_pos_crystal_clone = 0x8021C80C; // type:data rom:0x664F5C
+b_area_pra2_crystal_king_clone_formation = 0x8021C818; // type:data rom:0x664F68
+b_area_pra2_crystal_king_MakeIllusions = 0x8021C834; // type:data rom:0x664F84
+b_area_pra2_crystal_king_formation_bit_1 = 0x8021D5E8; // type:data rom:0x665D38
+b_area_pra2_crystal_king_formation_bit_2 = 0x8021D604; // type:data rom:0x665D54
+b_area_pra2_crystal_king_formation_bit_3 = 0x8021D620; // type:data rom:0x665D70
+b_area_pra2_crystal_king_array_1 = 0x8021D63C; // type:data rom:0x665D8C
+b_area_pra2_crystal_king_array_2 = 0x8021D67C; // type:data rom:0x665DCC
+b_area_pra2_crystal_king_array_3 = 0x8021D6BC; // type:data rom:0x665E0C
+b_area_pra2_crystal_king_CrystalBitAppear = 0x8021D6FC; // type:data rom:0x665E4C
+b_area_pra2_crystal_king_SummonCrystalBits = 0x8021DA2C; // type:data rom:0x66617C
+b_area_pra2_crystal_king_AttackIcyBreathWithClones = 0x8021DE9C; // type:data rom:0x6665EC
+b_area_pra2_crystal_king_MoveBitToTarget = 0x8021EF84; // type:data rom:0x6676D4
+b_area_pra2_crystal_king_RemoveCrystalBit = 0x8021F150; // type:data rom:0x6678A0
+b_area_pra2_crystal_king_AttackWithCrystalBit = 0x8021F3A4; // type:data rom:0x667AF4
+b_area_pra2_crystal_king_NormalAttack = 0x8021F6B0; // type:data rom:0x667E00
+b_area_pra2_crystal_king_Heal = 0x8021FE90; // type:data rom:0x6685E0
+b_area_pra2_crystal_bit_idleAnimations_1 = 0x80220480; // type:data rom:0x668BD0
+b_area_pra2_crystal_bit_idleAnimations_2 = 0x8022048C; // type:data rom:0x668BDC
+b_area_pra2_crystal_bit_idleAnimations_3 = 0x80220498; // type:data rom:0x668BE8
+b_area_pra2_crystal_bit_defenseTable = 0x802204A4; // type:data rom:0x668BF4
+b_area_pra2_crystal_bit_statusTable = 0x802204C0; // type:data rom:0x668C10
+b_area_pra2_crystal_bit_parts_1 = 0x8022056C; // type:data rom:0x668CBC
+b_area_pra2_crystal_bit_parts_2 = 0x802205B4; // type:data rom:0x668D04
+b_area_pra2_crystal_bit_parts_3 = 0x802205FC; // type:data rom:0x668D4C
+b_area_pra2_crystal_bit_1 = 0x80220644; // type:data rom:0x668D94
+b_area_pra2_crystal_bit_2 = 0x8022066C; // type:data rom:0x668DBC
+b_area_pra2_crystal_bit_3 = 0x80220694; // type:data rom:0x668DE4
+b_area_pra2_crystal_bit_init = 0x802206BC; // type:data rom:0x668E0C
+b_area_pra2_crystal_bit_idle = 0x8022071C; // type:data rom:0x668E6C
+b_area_pra2_crystal_bit_handleEvent = 0x802207C8; // type:data rom:0x668F18
+b_area_pra2_crystal_bit_takeTurn = 0x802211C0; // type:data rom:0x669910
+b_area_pra2_crystal_bit_nextTurn = 0x802211D0; // type:data rom:0x669920
+b_area_pra2_sam_04_UnkModelStuff_array = 0x802211E0; // type:data rom:0x669930
+b_area_pra2_sam_04_UnkModelStuffScript1 = 0x802211F0; // type:data rom:0x669940
+b_area_pra2_sam_04_UnkModelStuffScript2 = 0x8022122C; // type:data rom:0x66997C
+b_area_pra2_sam_04_UnkModelStuffScript3 = 0x802212F4; // type:data rom:0x669A44
+b_area_pra2_sam_04_UnkModelStuffScript4 = 0x802213D4; // type:data rom:0x669B24
+b_area_pra2_sam_04_beforeBattle = 0x80221498; // type:data rom:0x669BE8
+b_area_pra2_sam_04_afterBattle = 0x802214C4; // type:data rom:0x669C14
+b_area_pra2_sam_04 = 0x802214D4; // type:data rom:0x669C24
+b_area_pra2_pos_crystal_king = 0x80221500; // type:data rom:0x669C50
+b_area_pra2_pos_crystal_bit_1 = 0x8022150C; // type:data rom:0x669C5C
+b_area_pra2_pos_crystal_bit_2 = 0x80221518; // type:data rom:0x669C68
+b_area_pra2_pos_crystal_bit_3 = 0x80221524; // type:data rom:0x669C74
+b_area_pra2_formation_01 = 0x80221530; // type:data rom:0x669C80
+b_area_pra2_formationTable = 0x802215A0; // type:data rom:0x669CF0
+b_area_pra2_stageTable = 0x802215C8; // type:data rom:0x669D18
+b_area_pra3_duplighost_UnkFunc62 = 0x80218000; // type:func rom:0x669D80
+b_area_pra3_duplighost_ActorJumpToPos = 0x80218890; // type:func rom:0x66A610
+b_area_pra3_duplighost_UnkActorSizeFunc = 0x802189E4; // type:func rom:0x66A764
+b_area_pra3_duplighost_UnkEffect6CFunc = 0x80218A90; // type:func rom:0x66A810
+b_area_pra3_duplighost_UnkTattleEffectFunc1 = 0x80218AF4; // type:func rom:0x66A874
+b_area_pra3_duplighost_UnkTattleEffectFunc2 = 0x80218B2C; // type:func rom:0x66A8AC
+b_area_pra3_duplighost_UnkBattleFunc1 = 0x80218B74; // type:func rom:0x66A8F4
+b_area_pra3_duplighost_kooper_UnkActorPosFunc = 0x80218C40; // type:func rom:0x66A9C0
+b_area_pra3_duplighost_UnkActorPosFunc = 0x80218D64; // type:func rom:0x66AAE4
+b_area_pra3_duplighost_UnkWattEffectFunc1 = 0x80218E88; // type:func rom:0x66AC08
+b_area_pra3_duplighost_UnkWattEffectFunc2 = 0x80219304; // type:func rom:0x66B084
+b_area_pra3_duplighost_UnkWattEffectFunc3 = 0x80219358; // type:func rom:0x66B0D8
+b_area_pra3_duplighost_UnkWattEffectFunc4 = 0x802193A4; // type:func rom:0x66B124
+b_area_pra3_duplighost_UnkWattEffectFunc5 = 0x802193F0; // type:func rom:0x66B170
+b_area_pra3_duplighost_UnkBackgroundFunc3 = 0x8021943C; // type:func rom:0x66B1BC
+b_area_pra3_duplighost_SetBackgroundAlpha = 0x80219480; // type:func rom:0x66B200
+b_area_pra3_duplighost_GetPartnerAndLevel = 0x802194B8; // type:func rom:0x66B238
+b_area_pra3_duplighost_CopyPriority = 0x80219524; // type:func rom:0x66B2A4
+b_area_pra3_swoopula_UnkBattleFunc1 = 0x802195F0; // type:func rom:0x66B370
+b_area_pra3_swoopula_UnkBattleFunc2 = 0x802196BC; // type:func rom:0x66B43C
+b_area_pra3_swoopula_UnkBattleFunc2_2 = 0x80219770; // type:func rom:0x66B4F0
+b_area_pra3_red_magikoopa_ShrinkActor = 0x80219830; // type:func rom:0x66B5B0
+b_area_pra3_red_magikoopa_GetSelectedMoveID = 0x80219988; // type:func rom:0x66B708
+b_area_pra3_red_magikoopa_UnkBattleFunc1 = 0x802199B4; // type:func rom:0x66B734
+b_area_pra3_red_magikoopa_StartRumbleWithParams = 0x80219A80; // type:func rom:0x66B800
+b_area_pra3_red_magikoopa_UnkFunc52 = 0x80219AD8; // type:func rom:0x66B858
+b_area_pra3_gray_magikoopa_ShrinkActor = 0x80219BA0; // type:func rom:0x66B920
+b_area_pra3_gray_magikoopa_GetSelectedMoveID = 0x80219CF8; // type:func rom:0x66BA78
+b_area_pra3_gray_magikoopa_UnkBattleFunc1 = 0x80219D24; // type:func rom:0x66BAA4
+b_area_pra3_gray_magikoopa_StartRumbleWithParams = 0x80219DF0; // type:func rom:0x66BB70
+b_area_pra3_gray_magikoopa_UnkFunc52 = 0x80219E48; // type:func rom:0x66BBC8
+b_area_pra3_duplighost_idleAnimations = 0x80219F10; // type:data rom:0x66BC90
+b_area_pra3_duplighost_idleAnimations2 = 0x80219F5C; // type:data rom:0x66BCDC
+b_area_pra3_duplighost_idleAnimations3 = 0x80219F68; // type:data rom:0x66BCE8
+b_area_pra3_duplighost_defenseTable = 0x80219F74; // type:data rom:0x66BCF4
+b_area_pra3_duplighost_statusTable = 0x80219F80; // type:data rom:0x66BD00
+b_area_pra3_duplighost_parts = 0x8021A02C; // type:data rom:0x66BDAC
+b_area_pra3_duplighost = 0x8021A050; // type:data rom:0x66BDD0
+b_area_pra3_duplighost_init = 0x8021A078; // type:data rom:0x66BDF8
+b_area_pra3_duplighost_nextTurn = 0x8021A0F0; // type:data rom:0x66BE70
+b_area_pra3_duplighost_idle = 0x8021A190; // type:data rom:0x66BF10
+b_area_pra3_duplighost_returnHome = 0x8021A1A0; // type:data rom:0x66BF20
+b_area_pra3_duplighost_handleEvent = 0x8021A1DC; // type:data rom:0x66BF5C
+b_area_pra3_duplighost_attack = 0x8021A6DC; // type:data rom:0x66C45C
+b_area_pra3_duplighost_OnDeath = 0x8021AC7C; // type:data rom:0x66C9FC
+b_area_pra3_duplighost_OnHitElectric = 0x8021ACB4; // type:data rom:0x66CA34
+b_area_pra3_duplighost_OnShockHit = 0x8021B178; // type:data rom:0x66CEF8
+b_area_pra3_duplighost_OnShockDeath = 0x8021B804; // type:data rom:0x66D584
+b_area_pra3_duplighost_pos_summon = 0x8021BB68; // type:data rom:0x66D8E8
+b_area_pra3_duplighost_goombario_idleAnimations = 0x8021BB74; // type:data rom:0x66D8F4
+b_area_pra3_duplighost_goombario_defenseTable = 0x8021BBC0; // type:data rom:0x66D940
+b_area_pra3_duplighost_goombario_statusTable = 0x8021BBCC; // type:data rom:0x66D94C
+b_area_pra3_duplighost_goombario_parts = 0x8021BC78; // type:data rom:0x66D9F8
+b_area_pra3_duplighost_goombario = 0x8021BC9C; // type:data rom:0x66DA1C
+b_area_pra3_duplighost_goombario_init = 0x8021BCC4; // type:data rom:0x66DA44
+b_area_pra3_duplighost_goombario_idle = 0x8021BD10; // type:data rom:0x66DA90
+b_area_pra3_duplighost_goombario_handleEvent = 0x8021BD20; // type:data rom:0x66DAA0
+b_area_pra3_duplighost_goombario_returnBack = 0x8021C290; // type:data rom:0x66E010
+b_area_pra3_duplighost_goombario_runToPlayer = 0x8021C718; // type:data rom:0x66E498
+b_area_pra3_duplighost_goombario_8021C7FC = 0x8021C7FC; // type:data rom:0x66E57C
+b_area_pra3_duplighost_goombario_attack = 0x8021C8E4; // type:data rom:0x66E664
+b_area_pra3_duplighost_goombario_tattle = 0x8021D370; // type:data rom:0x66F0F0
+b_area_pra3_duplighost_goombario_takeTurn = 0x8021D684; // type:data rom:0x66F404
+b_area_pra3_duplighost_formation_goombario = 0x8021D6E0; // type:data rom:0x66F460
+b_area_pra3_duplighost_kooper_idleAnimations = 0x8021D6FC; // type:data rom:0x66F47C
+b_area_pra3_duplighost_kooper_idleAnimations2 = 0x8021D748; // type:data rom:0x66F4C8
+b_area_pra3_duplighost_kooper_defenseTable = 0x8021D794; // type:data rom:0x66F514
+b_area_pra3_duplighost_kooper_defenseTable2 = 0x8021D7A0; // type:data rom:0x66F520
+b_area_pra3_duplighost_kooper_statusTable = 0x8021D7AC; // type:data rom:0x66F52C
+b_area_pra3_duplighost_kooper_parts = 0x8021D858; // type:data rom:0x66F5D8
+b_area_pra3_duplighost_kooper = 0x8021D87C; // type:data rom:0x66F5FC
+b_area_pra3_duplighost_kooper_init = 0x8021D8A4; // type:data rom:0x66F624
+b_area_pra3_duplighost_kooper_idle = 0x8021D920; // type:data rom:0x66F6A0
+b_area_pra3_duplighost_kooper_dispOffsets = 0x8021DA40; // type:data rom:0x66F7C0
+b_area_pra3_duplighost_kooper_handleEvent = 0x8021DA98; // type:data rom:0x66F818
+b_area_pra3_duplighost_kooper_takeTurn = 0x8021E3F4; // type:data rom:0x670174
+b_area_pra3_duplighost_formation_kooper = 0x8021F394; // type:data rom:0x671114
+b_area_pra3_duplighost_bombette_idleAnimations = 0x8021F3B0; // type:data rom:0x671130
+b_area_pra3_duplighost_bombette_defenseTable = 0x8021F3FC; // type:data rom:0x67117C
+b_area_pra3_duplighost_bombette_statusTable = 0x8021F408; // type:data rom:0x671188
+b_area_pra3_duplighost_bombette_parts = 0x8021F4B4; // type:data rom:0x671234
+b_area_pra3_duplighost_bombette = 0x8021F4D8; // type:data rom:0x671258
+b_area_pra3_duplighost_bombette_init = 0x8021F500; // type:data rom:0x671280
+b_area_pra3_duplighost_bombette_idle = 0x8021F54C; // type:data rom:0x6712CC
+b_area_pra3_duplighost_bombette_playEffects = 0x8021F55C; // type:data rom:0x6712DC
+b_area_pra3_duplighost_bombette_handleEvent = 0x8021F6D4; // type:data rom:0x671454
+b_area_pra3_duplighost_bombette_takeTurn = 0x8021FD20; // type:data rom:0x671AA0
+b_area_pra3_duplighost_formation_bombette = 0x802205F4; // type:data rom:0x672374
+b_area_pra3_duplighost_parakarry_idleAnimations = 0x80220610; // type:data rom:0x672390
+b_area_pra3_duplighost_parakarry_defenseTable = 0x8022065C; // type:data rom:0x6723DC
+b_area_pra3_duplighost_parakarry_statusTable = 0x80220668; // type:data rom:0x6723E8
+b_area_pra3_duplighost_parakarry_parts = 0x80220714; // type:data rom:0x672494
+b_area_pra3_duplighost_parakarry = 0x8022075C; // type:data rom:0x6724DC
+b_area_pra3_duplighost_parakarry_init = 0x80220784; // type:data rom:0x672504
+b_area_pra3_duplighost_parakarry_idle = 0x802207D0; // type:data rom:0x672550
+b_area_pra3_duplighost_parakarry_handleEvent = 0x802207E0; // type:data rom:0x672560
+b_area_pra3_duplighost_parakarry_doTakeTurn = 0x80220DD4; // type:data rom:0x672B54
+b_area_pra3_duplighost_parakarry_takeTurn = 0x80221564; // type:data rom:0x6732E4
+b_area_pra3_duplighost_formation_parakarry = 0x80221580; // type:data rom:0x673300
+b_area_pra3_duplighost_bow_idleAnimations = 0x8022159C; // type:data rom:0x67331C
+b_area_pra3_duplighost_bow_defenseTable = 0x802215E8; // type:data rom:0x673368
+b_area_pra3_duplighost_bow_statusTable = 0x802215F4; // type:data rom:0x673374
+b_area_pra3_duplighost_bow_parts = 0x802216A0; // type:data rom:0x673420
+b_area_pra3_duplighost_bow = 0x802216E8; // type:data rom:0x673468
+b_area_pra3_duplighost_bow_init = 0x80221710; // type:data rom:0x673490
+b_area_pra3_duplighost_bow_idle = 0x8022175C; // type:data rom:0x6734DC
+b_area_pra3_duplighost_bow_handleEvent = 0x8022176C; // type:data rom:0x6734EC
+b_area_pra3_duplighost_bow_takeTurn = 0x80221CFC; // type:data rom:0x673A7C
+b_area_pra3_duplighost_formation_bow = 0x80222950; // type:data rom:0x6746D0
+b_area_pra3_duplighost_watt_idleAnimations = 0x8022296C; // type:data rom:0x6746EC
+b_area_pra3_duplighost_watt_defenseTable = 0x802229B8; // type:data rom:0x674738
+b_area_pra3_duplighost_watt_statusTable = 0x802229CC; // type:data rom:0x67474C
+b_area_pra3_duplighost_watt_parts = 0x80222A78; // type:data rom:0x6747F8
+b_area_pra3_duplighost_watt = 0x80222AC0; // type:data rom:0x674840
+b_area_pra3_duplighost_watt_init = 0x80222AE8; // type:data rom:0x674868
+b_area_pra3_duplighost_watt_idle = 0x80222B34; // type:data rom:0x6748B4
+b_area_pra3_duplighost_watt_handleEvent = 0x80222B5C; // type:data rom:0x6748DC
+b_area_pra3_duplighost_watt_takeTurn = 0x80222FD0; // type:data rom:0x674D50
+b_area_pra3_duplighost_formation_watt = 0x8022384C; // type:data rom:0x6755CC
+b_area_pra3_duplighost_sushie_idleAnimations = 0x80223868; // type:data rom:0x6755E8
+b_area_pra3_duplighost_sushie_defenseTable = 0x802238B4; // type:data rom:0x675634
+b_area_pra3_duplighost_sushie_statusTable = 0x802238C0; // type:data rom:0x675640
+b_area_pra3_duplighost_sushie_parts = 0x8022396C; // type:data rom:0x6756EC
+b_area_pra3_duplighost_sushie = 0x80223990; // type:data rom:0x675710
+b_area_pra3_duplighost_sushie_init = 0x802239B8; // type:data rom:0x675738
+b_area_pra3_duplighost_sushie_idle = 0x80223A04; // type:data rom:0x675784
+b_area_pra3_duplighost_sushie_handleEvent = 0x80223A14; // type:data rom:0x675794
+b_area_pra3_duplighost_sushie_takeTurn = 0x80223F84; // type:data rom:0x675D04
+b_area_pra3_duplighost_formation_sushie = 0x802251E4; // type:data rom:0x676F64
+b_area_pra3_duplighost_lakilester_idleAnimations = 0x80225200; // type:data rom:0x676F80
+b_area_pra3_duplighost_lakilester_idleAnimations2 = 0x8022524C; // type:data rom:0x676FCC
+b_area_pra3_duplighost_lakilester_defenseTable = 0x80225258; // type:data rom:0x676FD8
+b_area_pra3_duplighost_lakilester_statusTable = 0x80225264; // type:data rom:0x676FE4
+b_area_pra3_duplighost_lakilester_parts = 0x80225310; // type:data rom:0x677090
+b_area_pra3_duplighost_lakilester = 0x80225358; // type:data rom:0x6770D8
+b_area_pra3_duplighost_lakilester_init = 0x80225380; // type:data rom:0x677100
+b_area_pra3_duplighost_lakilester_idle = 0x802253CC; // type:data rom:0x67714C
+b_area_pra3_duplighost_lakilester_handleEvent = 0x802253DC; // type:data rom:0x67715C
+b_area_pra3_duplighost_lakilester_takeTurn = 0x802259A4; // type:data rom:0x677724
+b_area_pra3_duplighost_formation_lakilester = 0x80226484; // type:data rom:0x678204
+b_area_pra3_duplighost_copyPartner = 0x802264A0; // type:data rom:0x678220
+b_area_pra3_duplighost_takeTurn = 0x80226CC0; // type:data rom:0x678A40
+b_area_pra3_swoopula_defenseTable = 0x80226E50; // type:data rom:0x678BD0
+b_area_pra3_swoopula_statusTable = 0x80226E5C; // type:data rom:0x678BDC
+b_area_pra3_swoopula_parts = 0x80226F08; // type:data rom:0x678C88
+b_area_pra3_swoopula = 0x80226F2C; // type:data rom:0x678CAC
+b_area_pra3_swoopula_idleAnimations = 0x80226F54; // type:data rom:0x678CD4
+b_area_pra3_swoopula_idleAnimations_flying = 0x80226FA0; // type:data rom:0x678D20
+b_area_pra3_swoopula_init = 0x80226FEC; // type:data rom:0x678D6C
+b_area_pra3_swoopula_idle = 0x80227050; // type:data rom:0x678DD0
+b_area_pra3_swoopula_returnHome = 0x80227060; // type:data rom:0x678DE0
+b_area_pra3_swoopula_hadleEvent_flying = 0x80227220; // type:data rom:0x678FA0
+b_area_pra3_swoopula_knockDown = 0x802276A4; // type:data rom:0x679424
+b_area_pra3_swoopula_handleEvent = 0x80227A04; // type:data rom:0x679784
+b_area_pra3_swoopula_takeTurn_flying = 0x80228184; // type:data rom:0x679F04
+b_area_pra3_swoopula_takeTurn = 0x80229DA4; // type:data rom:0x67BB24
+b_area_pra3_white_clubba_idleAnimations = 0x8022B130; // type:data rom:0x67CEB0
+b_area_pra3_white_clubba_defenseTable = 0x8022B17C; // type:data rom:0x67CEFC
+b_area_pra3_white_clubba_statusTable = 0x8022B198; // type:data rom:0x67CF18
+b_area_pra3_white_clubba_parts = 0x8022B244; // type:data rom:0x67CFC4
+b_area_pra3_white_clubba = 0x8022B268; // type:data rom:0x67CFE8
+b_area_pra3_white_clubba_init = 0x8022B290; // type:data rom:0x67D010
+b_area_pra3_white_clubba_idle = 0x8022B2DC; // type:data rom:0x67D05C
+b_area_pra3_white_clubba_handleEvent = 0x8022B2EC; // type:data rom:0x67D06C
+b_area_pra3_white_clubba_takeTurn = 0x8022B7FC; // type:data rom:0x67D57C
+b_area_pra3_red_magikoopa_8022C120 = 0x8022C120; // type:data rom:0x67DEA0
+b_area_pra3_red_magikoopa_8022C12C = 0x8022C12C; // type:data rom:0x67DEAC
+b_area_pra3_red_magikoopa_8022C138 = 0x8022C138; // type:data rom:0x67DEB8
+b_area_pra3_red_magikoopa_8022C1E4 = 0x8022C1E4; // type:data rom:0x67DF64
+b_area_pra3_red_magikoopa_parts = 0x8022C290; // type:data rom:0x67E010
+b_area_pra3_red_magikoopa_8022C2B4 = 0x8022C2B4; // type:data rom:0x67E034
+b_area_pra3_red_magikoopa = 0x8022C320; // type:data rom:0x67E0A0
+b_area_pra3_red_magikoopa_flying = 0x8022C348; // type:data rom:0x67E0C8
+b_area_pra3_red_magikoopa_8022C370 = 0x8022C370; // type:data rom:0x67E0F0
+b_area_pra3_red_magikoopa_8022C3BC = 0x8022C3BC; // type:data rom:0x67E13C
+b_area_pra3_red_magikoopa_8022C408 = 0x8022C408; // type:data rom:0x67E188
+b_area_pra3_red_magikoopa_8022C414 = 0x8022C414; // type:data rom:0x67E194
+b_area_pra3_red_magikoopa_8022C424 = 0x8022C424; // type:data rom:0x67E1A4
+b_area_pra3_red_magikoopa_8022C93C = 0x8022C93C; // type:data rom:0x67E6BC
+b_area_pra3_red_magikoopa_8022CA48 = 0x8022CA48; // type:data rom:0x67E7C8
+b_area_pra3_red_magikoopa_8022D044 = 0x8022D044; // type:data rom:0x67EDC4
+b_area_pra3_red_magikoopa_8022D6A8 = 0x8022D6A8; // type:data rom:0x67F428
+b_area_pra3_red_magikoopa_8022DCC4 = 0x8022DCC4; // type:data rom:0x67FA44
+b_area_pra3_red_magikoopa_8022E334 = 0x8022E334; // type:data rom:0x6800B4
+b_area_pra3_red_magikoopa_8022E558 = 0x8022E558; // type:data rom:0x6802D8
+b_area_pra3_red_magikoopa_8022E5FC = 0x8022E5FC; // type:data rom:0x68037C
+b_area_pra3_red_magikoopa_8022E6A0 = 0x8022E6A0; // type:data rom:0x680420
+b_area_pra3_gray_magikoopa_defenseTable = 0x8022EDE0; // type:data rom:0x680B60
+b_area_pra3_gray_magikoopa_defenseTable_flying = 0x8022EDEC; // type:data rom:0x680B6C
+b_area_pra3_gray_magikoopa_statusTable = 0x8022EDF8; // type:data rom:0x680B78
+b_area_pra3_gray_magikoopa_statusTable_flying = 0x8022EEA4; // type:data rom:0x680C24
+b_area_pra3_gray_magikoopa_parts = 0x8022EF50; // type:data rom:0x680CD0
+b_area_pra3_gray_magikoopa_parts_flying = 0x8022EF74; // type:data rom:0x680CF4
+b_area_pra3_gray_magikoopa = 0x8022EFE0; // type:data rom:0x680D60
+b_area_pra3_gray_magikoopa_flying = 0x8022F008; // type:data rom:0x680D88
+b_area_pra3_gray_magikoopa_idleAnimations1 = 0x8022F030; // type:data rom:0x680DB0
+b_area_pra3_gray_magikoopa_idleAnimations2 = 0x8022F07C; // type:data rom:0x680DFC
+b_area_pra3_gray_magikoopa_idleAnimations3 = 0x8022F0C8; // type:data rom:0x680E48
+b_area_pra3_gray_magikoopa_idle = 0x8022F0D4; // type:data rom:0x680E54
+b_area_pra3_gray_magikoopa_handleEvent = 0x8022F0E4; // type:data rom:0x680E64
+b_area_pra3_gray_magikoopa_canBeKnockedOff = 0x8022F5FC; // type:data rom:0x68137C
+b_area_pra3_gray_magikoopa_knockOff = 0x8022F708; // type:data rom:0x681488
+b_area_pra3_gray_magikoopa_handleEvent_flying = 0x8022FD04; // type:data rom:0x681A84
+b_area_pra3_gray_magikoopa_attackMagicBlast = 0x80230368; // type:data rom:0x6820E8
+b_area_pra3_gray_magikoopa_attackWandStrike = 0x80230984; // type:data rom:0x682704
+b_area_pra3_gray_magikoopa_flee = 0x80230FF4; // type:data rom:0x682D74
+b_area_pra3_gray_magikoopa_init = 0x80231218; // type:data rom:0x682F98
+b_area_pra3_gray_magikoopa_init_flying = 0x802312BC; // type:data rom:0x68303C
+b_area_pra3_gray_magikoopa_takeTurn = 0x80231360; // type:data rom:0x6830E0
+b_area_pra3_pra_01_beforeBattle = 0x80231AA0; // type:data rom:0x683820
+b_area_pra3_pra_01_afterBattle = 0x80231AEC; // type:data rom:0x68386C
+b_area_pra3_pra_01_foregroundModelList = 0x80231AFC; // type:data rom:0x68387C
+b_area_pra3_pra_01 = 0x80231B0C; // type:data rom:0x68388C
+b_area_pra3_pra_02_80231B40 = 0x80231B40; // type:data rom:0x6838C0
+b_area_pra3_pra_02_80231C10 = 0x80231C10; // type:data rom:0x683990
+b_area_pra3_pra_02_80231CFC = 0x80231CFC; // type:data rom:0x683A7C
+b_area_pra3_pra_02_beforeBattle = 0x80231DE8; // type:data rom:0x683B68
+b_area_pra3_pra_02_afterBattle = 0x80231ECC; // type:data rom:0x683C4C
+b_area_pra3_pra_02_foregroundModelList = 0x80231EDC; // type:data rom:0x683C5C
+b_area_pra3_pra_02 = 0x80231EEC; // type:data rom:0x683C6C
+b_area_pra3_pra_03_beforeBattle = 0x80231F20; // type:data rom:0x683CA0
+b_area_pra3_pra_03_afterBattle = 0x80231F5C; // type:data rom:0x683CDC
+b_area_pra3_pra_03 = 0x80231F6C; // type:data rom:0x683CEC
+b_area_pra3_pra_03b_beforeBattle = 0x80231FA0; // type:data rom:0x683D20
+b_area_pra3_pra_03b_afterBattle = 0x80231FF0; // type:data rom:0x683D70
+b_area_pra3_pra_03b = 0x80232000; // type:data rom:0x683D80
+b_area_pra3_pra_03c_beforeBattle = 0x80232030; // type:data rom:0x683DB0
+b_area_pra3_pra_03c_afterBattle = 0x80232094; // type:data rom:0x683E14
+b_area_pra3_pra_03c = 0x802320A4; // type:data rom:0x683E24
+b_area_pra3_pra_04_802320D0 = 0x802320D0; // type:data rom:0x683E50
+b_area_pra3_pra_04_802321A0 = 0x802321A0; // type:data rom:0x683F20
+b_area_pra3_pra_04_8023228C = 0x8023228C; // type:data rom:0x68400C
+b_area_pra3_pra_04_beforeBattle = 0x80232378; // type:data rom:0x6840F8
+b_area_pra3_pra_04_afterBattle = 0x8023245C; // type:data rom:0x6841DC
+b_area_pra3_pra_04 = 0x8023246C; // type:data rom:0x6841EC
+b_area_pra3_pos_swoopula = 0x802324A0; // type:data rom:0x684220
+b_area_pra3_formation_01 = 0x802324D0; // type:data rom:0x684250
+b_area_pra3_formation_02 = 0x80232524; // type:data rom:0x6842A4
+b_area_pra3_formation_03 = 0x80232540; // type:data rom:0x6842C0
+b_area_pra3_formation_04 = 0x80232578; // type:data rom:0x6842F8
+b_area_pra3_formation_05 = 0x802325CC; // type:data rom:0x68434C
+b_area_pra3_formation_06 = 0x8023263C; // type:data rom:0x6843BC
+b_area_pra3_formation_07 = 0x80232690; // type:data rom:0x684410
+b_area_pra3_formation_08 = 0x802326E4; // type:data rom:0x684464
+b_area_pra3_formation_09 = 0x8023271C; // type:data rom:0x68449C
+b_area_pra3_formation_0A = 0x80232770; // type:data rom:0x6844F0
+b_area_pra3_formation_0B = 0x802327C4; // type:data rom:0x684544
+b_area_pra3_formation_0C = 0x80232834; // type:data rom:0x6845B4
+b_area_pra3_formationTable = 0x80232888; // type:data rom:0x684608
+b_area_pra3_stageTable = 0x8023298C; // type:data rom:0x68470C
 D_80232A18_684798 = 0x80232A18; // type:data rom:0x684798
 D_80232A50_6847D0 = 0x80232A50; // type:data rom:0x6847D0
 D_80232A60_6847E0 = 0x80232A60; // type:data rom:0x6847E0
@@ -24172,25 +25732,8 @@ kmr_20_config = 0x2800380; // type:data
 battle_item_insecticide_herb_temp = 0x28003C0; // type:data
 battle_item_insecticide_herb_temp2 = 0x28003D0; // type:data
 battle_item_mystery_tempStc = 0x2800410; // type:data
-D_090000E0 = 0x90000E0; // type:data
-D_090001B8 = 0x90001B8; // type:data
-D_09000240 = 0x9000240; // type:data
-D_090002C0 = 0x90002C0; // type:data
-D_090002E8 = 0x90002E8; // type:data
-D_090002F0 = 0x90002F0; // type:data
-D_09000330 = 0x9000330; // type:data
-D_09000370 = 0x9000370; // type:data
-D_090003B0 = 0x90003B0; // type:data
-D_090003F0 = 0x90003F0; // type:data
-D_09000430 = 0x9000430; // type:data
-D_09000470 = 0x9000470; // type:data
 D_09000800 = 0x9000800; // type:data
-D_090008D8 = 0x90008D8; // type:data
-D_09000900 = 0x9000900; // type:data
-D_090009E8 = 0x90009E8; // type:data
-D_090009F0 = 0x90009F0; // type:data
 D_09000A00 = 0x9000A00; // type:data
-D_09000A10 = 0x9000A10; // type:data
 D_09000B88 = 0x9000B88; // type:data
 D_09000BA8 = 0x9000BA8; // type:data
 D_09000BC8 = 0x9000BC8; // type:data
@@ -24206,25 +25749,15 @@ D_09000CA8 = 0x9000CA8; // type:data
 D_09000CC8 = 0x9000CC8; // type:data
 D_09000CE8 = 0x9000CE8; // type:data
 D_09000D08 = 0x9000D08; // type:data
-D_09000E08 = 0x9000E08; // type:data
-D_09000E20 = 0x9000E20; // type:data
-D_09000E38 = 0x9000E38; // type:data
-D_09000FA0 = 0x9000FA0; // type:data
 D_09001038 = 0x9001038; // type:data
-D_09001060 = 0x9001060; // type:data
 D_090010C0 = 0x90010C0; // type:data
-D_09001120 = 0x9001120; // type:data
 D_09001148 = 0x9001148; // type:data
 D_090011D0 = 0x90011D0; // type:data
-D_090011E0 = 0x90011E0; // type:data
 D_09001258 = 0x9001258; // type:data
 D_09001280 = 0x9001280; // type:data
-D_090012A0 = 0x90012A0; // type:data
 D_090012E0 = 0x90012E0; // type:data
 D_09001358 = 0x9001358; // type:data
-D_09001360 = 0x9001360; // type:data
 D_09001368 = 0x9001368; // type:data
-D_09001420 = 0x9001420; // type:data
 D_09001430 = 0x9001430; // type:data
 D_09001500 = 0x9001500; // type:data
 D_09001508 = 0x9001508; // type:data
@@ -24244,66 +25777,26 @@ D_09001938 = 0x9001938; // type:data
 D_09001C80 = 0x9001C80; // type:data
 D_09001CC8 = 0x9001CC8; // type:data
 D_09001D00 = 0x9001D00; // type:data
-D_09001D40 = 0x9001D40; // type:data
-D_09001DE0 = 0x9001DE0; // type:data
-D_09001E50 = 0x9001E50; // type:data
-D_09001E90 = 0x9001E90; // type:data
-D_09001ED0 = 0x9001ED0; // type:data
-D_09001F10 = 0x9001F10; // type:data
-D_09001F50 = 0x9001F50; // type:data
-D_09001F90 = 0x9001F90; // type:data
-D_09001FD0 = 0x9001FD0; // type:data
 D_09002000 = 0x9002000; // type:data
-D_09002010 = 0x9002010; // type:data
-D_09002050 = 0x9002050; // type:data
-D_09002090 = 0x9002090; // type:data
-D_090020D0 = 0x90020D0; // type:data
 D_090020E8 = 0x90020E8; // type:data
-D_09002100 = 0x9002100; // type:data
-D_09002110 = 0x9002110; // type:data
-D_09002150 = 0x9002150; // type:data
-D_09002160 = 0x9002160; // type:data
 D_09002170 = 0x9002170; // type:data
-D_09002180 = 0x9002180; // type:data
-D_09002190 = 0x9002190; // type:data
-D_09002198 = 0x9002198; // type:data
-D_090021A8 = 0x90021A8; // type:data
-D_090021C0 = 0x90021C0; // type:data
 D_090021D0 = 0x90021D0; // type:data
-D_090021E0 = 0x90021E0; // type:data
-D_09002200 = 0x9002200; // type:data
-D_09002230 = 0x9002230; // type:data
 D_09002238 = 0x9002238; // type:data
-D_09002250 = 0x9002250; // type:data
-D_09002270 = 0x9002270; // type:data
-D_09002290 = 0x9002290; // type:data
-D_090022B0 = 0x90022B0; // type:data
 D_090022E0 = 0x90022E0; // type:data
 D_09002308 = 0x9002308; // type:data
-D_09002320 = 0x9002320; // type:data
-D_09002360 = 0x9002360; // type:data
-D_090023A0 = 0x90023A0; // type:data
 D_090023B0 = 0x90023B0; // type:data
 D_090023C8 = 0x90023C8; // type:data
 D_090023D8 = 0x90023D8; // type:data
 D_090023E0 = 0x90023E0; // type:data
 D_090023F8 = 0x90023F8; // type:data
 D_09002410 = 0x9002410; // type:data
-D_09002420 = 0x9002420; // type:data
 D_09002428 = 0x9002428; // type:data
 D_09002440 = 0x9002440; // type:data
 D_09002458 = 0x9002458; // type:data
-D_09002460 = 0x9002460; // type:data
 D_09002480 = 0x9002480; // type:data
-D_090024A0 = 0x90024A0; // type:data
 D_090024A8 = 0x90024A8; // type:data
-D_090024E0 = 0x90024E0; // type:data
-D_09002520 = 0x9002520; // type:data
 D_09002550 = 0x9002550; // type:data
-D_09002560 = 0x9002560; // type:data
 D_09002578 = 0x9002578; // type:data
-D_090025A0 = 0x90025A0; // type:data
-D_090025E0 = 0x90025E0; // type:data
 D_09002780 = 0x9002780; // type:data
 D_09002868 = 0x9002868; // type:data
 D_09002950 = 0x9002950; // type:data
@@ -24311,7 +25804,6 @@ D_09002A38 = 0x9002A38; // type:data
 D_09002B20 = 0x9002B20; // type:data
 D_09002B40 = 0x9002B40; // type:data
 D_09002B60 = 0x9002B60; // type:data
-D_09002D40 = 0x9002D40; // type:data
 D_09003540 = 0x9003540; // type:data
 D_09003580 = 0x9003580; // type:data
 D_090035C0 = 0x90035C0; // type:data
@@ -24324,19 +25816,6 @@ D_09003740 = 0x9003740; // type:data
 D_09003780 = 0x9003780; // type:data
 D_090037C0 = 0x90037C0; // type:data
 D_09003800 = 0x9003800; // type:data
-D_09003880 = 0x9003880; // type:data
-D_090038F8 = 0x90038F8; // type:data
-D_09003968 = 0x9003968; // type:data
-D_090039D8 = 0x90039D8; // type:data
-D_09003A48 = 0x9003A48; // type:data
-D_09003AB8 = 0x9003AB8; // type:data
-D_09003B28 = 0x9003B28; // type:data
-D_09003B98 = 0x9003B98; // type:data
-D_09003C08 = 0x9003C08; // type:data
-D_09003C78 = 0x9003C78; // type:data
-D_09003CE8 = 0x9003CE8; // type:data
-D_09003D58 = 0x9003D58; // type:data
-D_09003DC8 = 0x9003DC8; // type:data
 D_0A000328 = 0xA000328; // type:data
 D_0A000380 = 0xA000380; // type:data
 D_0A000740 = 0xA000740; // type:data
@@ -24356,16 +25835,17 @@ D_0A0031E0 = 0xA0031E0; // type:data
 D_0A003508 = 0xA003508; // type:data
 D_0A003F70 = 0xA003F70; // type:data
 D_0A004350 = 0xA004350; // type:data
-D_7012ACA1 = 0x7012ACA1; // type:data
-D_7012BC11 = 0x7012BC11; // type:data
+obfuscated_battle_heap_create = 0x7012ACA1; // type:data
+obfuscated_general_heap_create = 0x7012BC11; // type:data
+D_7599F6D8 = 0x7599F6D8; // type:data
 osTvType = 0x80000300; //
 osRomBase = 0x80000308; // type:data
 D_8000030C = 0x8000030C; // type:data
 osMemSize = 0x80000318; // type:data
 D_8000031C = 0x8000031C; // type:data
-D_80026AC7 = 0x80026AC7; // type:data
-D_8004AA85 = 0x8004AA85; // type:data
-gcc2_compiled. = 0x80060D60; // type:data
+obfuscated_load_engine_data = 0x80026AC7; // type:data
+dead_atan2 = 0x8002AF70; // type:data
+obfuscated_create_audio_system = 0x8004AA85; // type:data
 ai = 0x8006AD64; //
 si = 0x8006AD90; //
 dp = 0x8006AE0C; //
@@ -24380,8 +25860,6 @@ D_80079540 = 0x80079540; // type:data
 dead_gCurrentCameraID = 0x8007C760; // type:data
 dead_gItemTable = 0x8008D2C0; // type:data
 rdpstateinit_dl = 0x80093BB8; // type:data
-hdwrBugFlag.2 = 0x80093DA0; // type:data
-dtor.2 = 0x80093DC0; // type:data
 D_80094664 = 0x80094664; // type:data
 D_80094900 = 0x80094900; // type:data
 D_80097D60 = 0x80097D60; // type:data
@@ -24391,8 +25869,6 @@ D_80097D78 = 0x80097D78; // type:data
 D_80097D80 = 0x80097D80; // type:data
 D_80097D88 = 0x80097D88; // type:data
 pad = 0x80098474; // type:data
-fchar.2 = 0x80099BF0; // type:data
-fbit.3 = 0x80099BF8; // type:data
 nuScPreNMIFlag = 0x8009A5B0; // type:data
 D_8009BB30 = 0x8009BB30; // type:data
 D_8009C4E0 = 0x8009C4E0; // type:data
@@ -24421,165 +25897,7 @@ dead_gPlayerStatusPtr = 0x800FFC90; // type:data
 dead_wPartnerHudScripts = 0x80100060; // type:data
 D_801000A0 = 0x801000A0; // type:data
 dead_wDisabledPartnerHudScripts = 0x801000A0; // type:data
-HES_ArrowLeft = 0x801049B0; // type:data
-HES_ArrowRight = 0x801049D8; // type:data
-HES_HandPointer = 0x80104A00; // type:data
-HES_AnimatedHandPointer = 0x80104A28; // type:data
-HES_FilledCircle = 0x80104A70; // type:data
-HES_EmptyCircle = 0x80104A98; // type:data
-SparkleScript_Coin = 0x80104AC0; // type:data
-HES_StatusSPShine = 0x80104BEC; // type:data
-HES_StatusStarPiece = 0x80104C10; // type:data
-HES_AsleepLoop = 0x80104C68; // type:data
-HES_AsleepBegin = 0x80104CC4; // type:data
-HES_AsleepEnd = 0x80104E64; // type:data
-HES_ElectrifiedLoop = 0x80104FBC; // type:data
-HES_ElectrifiedBegin = 0x801050A8; // type:data
-HES_ElectrifiedEnd = 0x801052D8; // type:data
-HES_ParalyzedLoop = 0x80105430; // type:data
-HES_ParalyzedBegin = 0x8010551C; // type:data
-HES_ParalyzedEnd = 0x8010574C; // type:data
-HES_DizzyLoop = 0x801058A4; // type:data
-HES_DizzyBegin = 0x80105900; // type:data
-HES_DizzyEnd = 0x80105AA0; // type:data
-HES_PoisonedLoop = 0x80105BF8; // type:data
-HES_PoisonedBegin = 0x80105C54; // type:data
-HES_PoisonedEnd = 0x80105DF4; // type:data
-HES_FrozenLoop = 0x80105F4C; // type:data
-HES_FrozenBegin = 0x80105FA8; // type:data
-HES_FrozenEnd = 0x80106148; // type:data
-HES_WeakenedLoop = 0x801062A0; // type:data
-HES_WeakenedBegin = 0x801062DC; // type:data
-HES_WeakenedEnd = 0x8010645C; // type:data
 HES_StoppedLoop = 0x801065B4; // type:data
-HES_StoppedBegin = 0x80106610; // type:data
-HES_StoppedEnd = 0x801067B0; // type:data
-HES_ShrunkLoop = 0x80106908; // type:data
-HES_ShrunkBegin = 0x80106964; // type:data
-HES_ShrunkEnd = 0x80106B04; // type:data
-HES_TransparentLoop = 0x80106C5C; // type:data
-HES_TransparentBegin = 0x80106CD8; // type:data
-HES_TransparentEnd = 0x80106E98; // type:data
-HES_BoostJumpLoop = 0x80106FF0; // type:data
-HES_BoostJumpBegin = 0x8010701C; // type:data
-HES_BoostJumpEnd = 0x8010717C; // type:data
-HES_BoostHammerLoop = 0x801072E8; // type:data
-HES_BoostHammerBegin = 0x80107314; // type:data
-HES_BoostHammerEnd = 0x80107474; // type:data
-HES_BoostPartner = 0x801075E0; // type:data
-HES_Surprise = 0x8010760C; // type:data
-HES_FPCost = 0x80107638; // type:data
-HES_FPCostReduced = 0x80107664; // type:data
-HES_FPCostReducedTwice = 0x80107690; // type:data
-HES_NotEnoughFP = 0x801076BC; // type:data
-HES_POWCost = 0x801076E8; // type:data
-HES_POWCostReduced = 0x80107714; // type:data
-HES_POWCostReducedTwice = 0x80107740; // type:data
-HES_NotEnoughPOW = 0x8010776C; // type:data
-HES_GreenArrowDown = 0x80107798; // type:data
-HES_GreenArrowUp = 0x801077E4; // type:data
-HES_UnusedPinkFrame = 0x80107830; // type:data
-HES_UnusedDigit1 = 0x8010785C; // type:data
-HES_UnusedDigit2 = 0x80107888; // type:data
-HES_UnusedDigit3 = 0x801078B4; // type:data
-HES_RedBar1 = 0x801078E0; // type:data
-HES_EmptyBar = 0x8010790C; // type:data
-HES_RedBar2 = 0x80107938; // type:data
-HES_Eldstar = 0x80107990; // type:data
-HES_EldstarDisabled = 0x801079BC; // type:data
-HES_Mamar = 0x801079E8; // type:data
-HES_MamarDisabled = 0x80107A14; // type:data
-HES_Skolar = 0x80107A40; // type:data
-HES_SkolarDisabled = 0x80107A6C; // type:data
-HES_Muskular = 0x80107A98; // type:data
-HES_MuskularDisabled = 0x80107AC4; // type:data
-HES_Misstar = 0x80107AF0; // type:data
-HES_MisstarDisabled = 0x80107B1C; // type:data
-HES_Klevar = 0x80107B48; // type:data
-HES_KlevarDisabled = 0x80107B74; // type:data
-HES_Kalmar = 0x80107BA0; // type:data
-HES_KalmarDisabled = 0x80107BCC; // type:data
-HES_StarBeam = 0x80107BF8; // type:data
-HES_StarBeamDisabled = 0x80107C24; // type:data
-HES_PeachBeam = 0x80107C50; // type:data
-HES_PeachBeamDisabled = 0x80107C7C; // type:data
-HES_Partner0 = 0x80107CA8; // type:data
-HES_Partner0Disabled = 0x80107CD0; // type:data
-HES_Goombario = 0x80107CF8; // type:data
-HES_GoombarioDisabled = 0x80107D20; // type:data
-HES_Kooper = 0x80107D48; // type:data
-HES_KooperDisabled = 0x80107D70; // type:data
-HES_Bombette = 0x80107D98; // type:data
-HES_BombetteDisabled = 0x80107DC0; // type:data
-HES_Parakarry = 0x80107DE8; // type:data
-HES_ParakarryDisabled = 0x80107E10; // type:data
-HES_Bow = 0x80107E38; // type:data
-HES_BowDisabled = 0x80107E60; // type:data
-HES_Watt = 0x80107E88; // type:data
-HES_WattDisabled = 0x80107EB0; // type:data
-HES_Sushie = 0x80107ED8; // type:data
-HES_SushieDisabled = 0x80107F00; // type:data
-HES_Lakilester = 0x80107F28; // type:data
-HES_LakilesterDisabled = 0x80107F50; // type:data
-HES_PartnerA = 0x80107FC8; // type:data
-HES_PartnerADisabled = 0x80107FF0; // type:data
-HES_StatusTimes = 0x80108068; // type:data
-HES_StatusSlash = 0x80108090; // type:data
-HES_StatusDigit0 = 0x801080B8; // type:data
-HES_StatusDigit1 = 0x801080E0; // type:data
-HES_StatusDigit2 = 0x80108108; // type:data
-HES_StatusDigit3 = 0x80108130; // type:data
-HES_StatusDigit4 = 0x80108158; // type:data
-HES_StatusDigit5 = 0x80108180; // type:data
-HES_StatusDigit6 = 0x801081A8; // type:data
-HES_StatusDigit7 = 0x801081D0; // type:data
-HES_StatusDigit8 = 0x801081F8; // type:data
-HES_StatusDigit9 = 0x80108220; // type:data
-HES_StatusHP = 0x80108248; // type:data
-HES_StatusFP = 0x80108270; // type:data
-HES_StatusSPEmptyIncrement = 0x801083B0; // type:data
-HES_StatusStar1 = 0x801083D8; // type:data
-HES_StatusStarEmpty = 0x801084F0; // type:data
-HES_StatusHeart = 0x80108518; // type:data
-HES_StatusFlower = 0x80108538; // type:data
-HES_StatusCoin = 0x80108558; // type:data
-HES_StatusStarPoint = 0x801086AC; // type:data
-HES_MenuBoots1 = 0x80108744; // type:data
-HES_MenuBoots1Disabled = 0x8010876C; // type:data
-HES_MenuBoots2 = 0x80108794; // type:data
-HES_MenuBoots2Disabled = 0x801087BC; // type:data
-HES_MenuBoots3 = 0x801087E4; // type:data
-HES_MenuBoots3Disabled = 0x8010880C; // type:data
-HES_MenuHammer1 = 0x80108834; // type:data
-HES_MenuHammer1Disabled = 0x8010885C; // type:data
-HES_MenuHammer2 = 0x80108884; // type:data
-HES_MenuHammer2Disabled = 0x801088AC; // type:data
-HES_MenuHammer3 = 0x801088D4; // type:data
-HES_MenuHammer3Disabled = 0x801088FC; // type:data
-HES_MenuItem = 0x80108924; // type:data
-HES_MenuItemDisabled = 0x8010894C; // type:data
-HES_MenuStarPower = 0x80108974; // type:data
-HES_MenuStarPowerDisabled = 0x8010899C; // type:data
-HES_Peril = 0x801089C4; // type:data
-HES_Danger = 0x80108A14; // type:data
-HES_Happy = 0x80108AAC; // type:data
-HES_HPDrain = 0x80108AD4; // type:data
-HES_BlueMeter = 0x80108AFC; // type:data
-HES_AButton = 0x80108B28; // type:data
-HES_AButtonDown = 0x80108B54; // type:data
-HES_MashAButton = 0x80108B80; // type:data
-HES_PressAButton = 0x80108BBC; // type:data
-HES_SlowlyMashAButton = 0x80108C34; // type:data
-HES_RotateStickCW = 0x80108D6C; // type:data
-HES_StickNeutral = 0x80108E1C; // type:data
-HES_StickHoldLeft = 0x80108E48; // type:data
-HES_StickBackAndForth = 0x80108E80; // type:data
-HES_StickMashLeft = 0x80108F30; // type:data
-HES_StickTapLeft = 0x80108F90; // type:data
-HES_StickTapNeutral = 0x80108FF0; // type:data
-HES_StickTapRight = 0x801091E4; // type:data
-HES_RunAwayOK = 0x80109244; // type:data
-HES_MenuTimes = 0x80109270; // type:data
 D_80109480 = 0x80109480; // type:data
 D_80109484 = 0x80109484; // type:data
 D_80109488 = 0x80109488; // type:data
@@ -24666,6 +25984,7 @@ _render_transition_stencil = 0x80136A80; // type:func
 get_default_variation_for_song = 0x8014A430; //
 D_8014F120 = 0x8014F120; // type:data
 D_8014F128 = 0x8014F128; // type:data
+rodata_padding_2 = 0x80150BBC; // type:data
 B_801512B0 = 0x801512B0; // type:data
 D_801512B0 = 0x801512B0; // type:data
 D_801512E8 = 0x801512E8; // type:data
@@ -24681,6 +26000,7 @@ D_80156903 = 0x80156903; // type:data
 D_8015690B = 0x8015690B; // type:data
 D_8015C7A8 = 0x8015C7A8; // type:data
 D_80164000 = 0x80164000; // type:data
+dead_gCollisionStatus = 0x80169B10; // type:data
 D_80197000 = 0x80197000; // type:data
 D_801A6000 = 0x801A6000; // type:data
 D_801A7000 = 0x801A7000; // type:data
@@ -24691,6 +26011,7 @@ D_80210000 = 0x80210000; // type:data
 D_80219040 = 0x80219040; // type:data
 spiked_goomba = 0x8021B0AC; // type:data
 paragoomba = 0x8021CD00; // type:data
+b_area_pra2_crystal_king_paths = 0x80221630; // type:data
 D_80224D60 = 0x80224D60; // type:data
 D_80224D64 = 0x80224D64; // type:data
 D_80224D70 = 0x80224D70; // type:data
@@ -24782,8 +26103,6 @@ flo_22_pad_518 = 0x80240518; // type:data
 dgb_11_pad_56C = 0x8024056C; // type:data
 arn_09_pad_5A8 = 0x802405A8; // type:data
 dgb_06_Chest_VarStash = 0x80240620; // type:data
-varStash.2 = 0x80240620; // type:data
-varTable.2 = 0x80240620; // type:data
 dgb_10_pad_66C = 0x8024066C; // type:data
 arn_11_pad_674 = 0x80240674; // type:data
 sbk_00_pad_78C = 0x8024078C; // type:data
@@ -24840,7 +26159,6 @@ dgb_02_pad_1AA8 = 0x80241AA8; // type:data
 flo_11_pad_1AB8 = 0x80241AB8; // type:data
 arn_03_pad_1BB8 = 0x80241BB8; // type:data
 arn_03_varStash = 0x80241C68; // type:data
-varTable.32 = 0x80241C68; // type:data
 flo_10_pad_1CA8 = 0x80241CA8; // type:data
 dgb_07_pad_1E74 = 0x80241E88; // type:data
 dgb_15_pad_1E94 = 0x80241E94; // type:data
@@ -25068,7 +26386,6 @@ D_802479F0 = 0x802479F0; // type:data
 D_80247AF0 = 0x80247AF0; // type:data
 D_80247B00 = 0x80247B00; // type:data
 flo_13_D_80247B00 = 0x80247B00; // type:data
-palette.2 = 0x80247B00; // type:data
 D_80247BB8 = 0x80247BB8; // type:data
 D_80247BF0 = 0x80247BF0; // type:data
 D_80247CA0 = 0x80247CA0; // type:data
@@ -25076,7 +26393,6 @@ D_80247CB4 = 0x80247CB4; // type:data
 jan_00_LetterDelivery_SavedNpcAnim = 0x80247CB4; // type:data
 D_80247D00 = 0x80247D00; // type:data
 flo_13_D_80247D00 = 0x80247D00; // type:data
-raster.3 = 0x80247D00; // type:data
 D_80247DF0 = 0x80247DF0; // type:data
 D_80247E68 = 0x80247E68; // type:data
 D_80248380 = 0x80248380; // type:data
@@ -25115,7 +26431,6 @@ sam_02_Quizmo_AudienceEffect = 0x8024B9B4; // type:data
 sam_02_Quizmo_VannaTEffect = 0x8024B9B8; // type:data
 D_8024BA90 = 0x8024BA90; // type:data
 flo_13_D_8024BA90 = 0x8024BA90; // type:data
-images.4 = 0x8024BA90; // type:data
 D_8024BB80 = 0x8024BB80; // type:data
 hos_03_Quizmo_Worker = 0x8024BDD0; // type:data
 hos_03_Quizmo_AnswerResult = 0x8024BDE8; // type:data
@@ -25512,9 +26827,7 @@ EnterSingleDoor = 0x80285DD4; //
 ExitDoubleDoor = 0x80285E4C; //
 EnterDoubleDoor = 0x80285E74; //
 D_80286520 = 0x80286520; // type:data
-D_80286520.16 = 0x80286520; // type:data
 D_80286524 = 0x80286524; // type:data
-D_80286524.17 = 0x80286524; // type:data
 D_80286528 = 0x80286528; // type:data
 D_8028652C = 0x8028652C; // type:data
 D_80286530 = 0x80286530; // type:data
@@ -25532,49 +26845,6 @@ MerleeAttackBonus = 0x80288400; //
 MerleeDefenseBonus = 0x8028870C; //
 MerleeExpBonus = 0x80288A58; //
 PlayerHappy = 0x80288D64; //
-HES_HPDigit0 = 0x80291FA8; // type:data
-HES_HPDigit1 = 0x80291FD0; // type:data
-HES_HPDigit2 = 0x80291FF8; // type:data
-HES_HPDigit3 = 0x80292020; // type:data
-HES_HPDigit4 = 0x80292048; // type:data
-HES_HPDigit5 = 0x80292070; // type:data
-HES_HPDigit6 = 0x80292098; // type:data
-HES_HPDigit7 = 0x802920C0; // type:data
-HES_HPDigit8 = 0x802920E8; // type:data
-HES_HPDigit9 = 0x80292110; // type:data
-HES_TimingBar1Chance = 0x802922F0; // type:data
-HES_TimingWait = 0x8029275C; // type:data
-HES_TimingCharge4a = 0x802927F0; // type:data
-HES_TimingCharge1 = 0x8029281C; // type:data
-HES_TimingCharge4b = 0x80292848; // type:data
-HES_TimingCharge2 = 0x80292874; // type:data
-HES_TimingCharge4c = 0x802928A0; // type:data
-HES_TimingCharge3 = 0x802928CC; // type:data
-HES_RunningAway = 0x802928F8; // type:data
-HES_100pct = 0x80292974; // type:data
-HES_RightOn = 0x80292A2C; // type:data
-HES_TimingBar3Chances = 0x80292AFC; // type:data
-HES_TimingOK = 0x80292B54; // type:data
-HES_TimingMiss = 0x80292B80; // type:data
-HES_FillGaugeResult = 0x80292BAC; // type:data
-HES_ProjectorReel = 0x80292BD8; // type:data
-HES_ProjectorSpot = 0x80292C00; // type:data
-HES_SwapZ = 0x80292C50; // type:data
-HES_SwapArrowLeft = 0x80292C7C; // type:data
-HES_SwapArrowRight = 0x80292CB8; // type:data
-HES_SwapBackground = 0x80292CF4; // type:data
-HES_AimMarkerA = 0x80292D1C; // type:data
-HES_AimMarkerB = 0x80292DB4; // type:data
-HES_AimMarkerC = 0x80292E4C; // type:data
-HES_AimMarkerD = 0x80292EE4; // type:data
-HES_AimMarkerE = 0x80292F7C; // type:data
-HES_AimMarkerF = 0x80293014; // type:data
-HES_AimShimmerA = 0x802931DC; // type:data
-HES_AimShimmerB = 0x80293274; // type:data
-HES_AimShimmerC = 0x8029330C; // type:data
-HES_AimShimmerD = 0x802933A4; // type:data
-HES_AimShimmerE = 0x8029343C; // type:data
-HES_AimShimmerF = 0x802934D4; // type:data
 gBattleItemTable = 0x80293C04; // type:data
 UseMystery = 0x80293E40; //
 D_802941C0 = 0x802941C0; // type:data
@@ -26465,7 +27735,6 @@ D_E007C510 = 0xE007C510; // type:data
 D_E007EC2F = 0xE007EC2F; // type:data
 D_E007EC40 = 0xE007EC40; // type:data
 D_E0082D30 = 0xE0082D30; // type:data
-D_E0082D30.6 = 0xE0082D30; // type:data
 D_E0082D60 = 0xE0082D60; // type:data
 D_E0086AA0 = 0xE0086AA0; // type:data
 D_E0086AB4 = 0xE0086AB4; // type:data
@@ -26822,8 +28091,8 @@ dead_playFX_11 = 0x80075170; // type:func dead:yes
 dead_gGameStatusPtr = 0x80079430; // type:data dead:yes
 D_80079540 = 0x80079540; // type:data dead:yes
 dead_gCurrentCameraID = 0x8007C760; // type:data dead:yes
-dead_gItemTable = 0x8008D2C0; // type:data dead:yes
 dead_gItemTable = 0x8008D2C0; // type:data dead:true
+dead_gItemTable = 0x8008D2C0; // type:data dead:yes
 dead_gCurrentCamID = 0x800A158C; // type:data dead:yes
 dead_gOverrideFlags = 0x800A15A8; // type:data dead:yes
 dead_gCurrentEncounter = 0x800B7EF0; // type:data dead:yes
diff --git a/ver/us/undefined_syms.txt b/ver/us/undefined_syms.txt
index a4e38d5618..54889a48b1 100644
--- a/ver/us/undefined_syms.txt
+++ b/ver/us/undefined_syms.txt
@@ -58,25 +58,18 @@ D_F79DDD0F = 0xF79DDD0F;
 D_FA000028 = 0xFA000028;
 D_FD100008 = 0xFD100008;
 
+D_7599F6D8 = 0x7599F6D8;
+
 // Obfuscation symbols
-D_7012ACA1 = 0x7012ACA1;
-D_7012BC11 = 0x7012BC11;
-D_80026AC7 = 0x80026AC7;
-D_8004AA85 = 0x8004AA85;
+obfuscated_battle_heap_create = battle_heap_create - 0xFEFFFFF;
+obfuscated_general_heap_create = general_heap_create - 0xFEFEFEF;
+obfuscated_load_engine_data = load_engine_data - 0x315;
+obfuscated_create_audio_system = create_audio_system - 0x7B;
 
 fx_sun_undeclared = fx_sun;
 
 D_E007EC2F = 0xE007EC2F;
 
-// effect_1
-D_09000FA0 = 0x09000FA0;
-D_09001060 = 0x09001060;
-D_09001120 = 0x09001120;
-D_090011E0 = 0x090011E0;
-D_090012A0 = 0x090012A0;
-D_09001360 = 0x09001360;
-D_09001420 = 0x09001420;
-
 // effect_6
 D_09002780 = 0x09002780;
 D_09002868 = 0x09002868;
@@ -93,27 +86,6 @@ D_09002950 = 0x09002950;
 D_09002B20 = 0x09002B20;
 D_09002B40 = 0x09002B40;
 
-// effect_8
-D_09000E08 = 0x09000E08;
-
-// effect_9
-D_09000E20 = 0x09000E20;
-D_09000E38 = 0x09000E38;
-
-// effect_10, effect_11
-D_090000E0 = 0x090000E0;
-D_090001B8 = 0x090001B8;
-
-// effect_12
-D_09000240 = 0x09000240;
-
-// effect_13
-D_090002F0 = 0x090002F0;
-
-// effect_14
-D_09000900 = 0x09000900;
-D_090009E8 = 0x090009E8;
-
 // effect_16
 D_09002170 = 0x09002170;
 D_09002238 = 0x09002238;
@@ -126,19 +98,6 @@ D_090024A8 = 0x090024A8;
 D_09002550 = 0x09002550;
 D_09002578 = 0x09002578;
 
-// effect 31 (debuff)
-D_09000240 = 0x09000240;
-D_090002E8 = 0x090002E8;
-
-// effect_73
-D_090002C0 = 0x090002C0;
-D_09000330 = 0x09000330;
-D_09000370 = 0x09000370;
-D_090003B0 = 0x090003B0;
-D_090003F0 = 0x090003F0;
-D_09000430 = 0x09000430;
-D_09000470 = 0x09000470;
-
 // effect_75
 D_09001280 = 0x09001280;
 D_09001358 = 0x09001358;
@@ -223,78 +182,6 @@ D_09000B88 = 0x09000B88;
 D_09000C00 = 0x09000C00;
 D_09000C20 = 0x09000C20;
 
-// effect_disable_x
-D_09002100 = 0x09002100;
-D_09002198 = 0x09002198;
-D_09002230 = 0x09002230;
-D_09002250 = 0x09002250;
-D_09002270 = 0x09002270;
-D_09002290 = 0x09002290;
-D_090022B0 = 0x090022B0;
-D_09002320 = 0x09002320;
-D_09002360 = 0x09002360;
-D_090023A0 = 0x090023A0;
-D_090023E0 = 0x090023E0;
-D_09002420 = 0x09002420;
-D_09002460 = 0x09002460;
-D_090024A0 = 0x090024A0;
-D_090024E0 = 0x090024E0;
-D_09002520 = 0x09002520;
-D_09002560 = 0x09002560;
-D_090025A0 = 0x090025A0;
-D_090025E0 = 0x090025E0;
-
-// effect_throw_spiny
-D_09000800 = 0x09000800;
-D_090008D8 = 0x090008D8;
-D_090009F0 = 0x090009F0;
-
-// effect_damage_indicator
-D_09001D40 = 0x09001D40;
-D_09001DE0 = 0x09001DE0;
-D_09001E50 = 0x09001E50;
-D_09001E90 = 0x09001E90;
-D_09001ED0 = 0x09001ED0;
-D_09001F10 = 0x09001F10;
-D_09001F50 = 0x09001F50;
-D_09001F90 = 0x09001F90;
-D_09001FD0 = 0x09001FD0;
-D_09002010 = 0x09002010;
-D_09002050 = 0x09002050;
-D_09002090 = 0x09002090;
-D_090020D0 = 0x090020D0;
-D_09002110 = 0x09002110;
-D_09002150 = 0x09002150;
-D_09002160 = 0x09002160;
-D_09002170 = 0x09002170;
-D_09002180 = 0x09002180;
-D_090021A8 = 0x090021A8;
-D_09002190 = 0x09002190;
-D_090021C0 = 0x090021C0;
-D_090021E0 = 0x090021E0;
-D_09002200 = 0x09002200;
-
-// effect_big_snowflakes
-D_09000900 = 0x09000900;
-D_090009E8 = 0x090009E8;
-D_09000A10 = 0x09000A10;
-
-// effect_butterflies
-D_09002D40 = 0x09002D40;
-D_09003880 = 0x09003880;
-D_090038F8 = 0x090038F8;
-D_09003968 = 0x09003968;
-D_090039D8 = 0x090039D8;
-D_09003A48 = 0x09003A48;
-D_09003AB8 = 0x09003AB8;
-D_09003B28 = 0x09003B28;
-D_09003B98 = 0x09003B98;
-D_09003C08 = 0x09003C08;
-D_09003C78 = 0x09003C78;
-D_09003CE8 = 0x09003CE8;
-D_09003D58 = 0x09003D58;
-D_09003DC8 = 0x09003DC8;
-
 // Invalid pointers from dead code
 dead_atan2 = 0x8002AF70;
 dead_gCurrentCamID = 0x800A158C;